sys/contrib/dev/acpica/tests/misc/grammar.asl

   1 /*
   2  * Some or all of this work - Copyright (c) 2006 - 2014, Intel Corp.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without modification,
   6  * are permitted provided that the following conditions are met:
   7  *
   8  * Redistributions of source code must retain the above copyright notice,
   9  * this list of conditions and the following disclaimer.
  10  * Redistributions in binary form must reproduce the above copyright notice,
  11  * this list of conditions and the following disclaimer in the documentation
  12  * and/or other materials provided with the distribution.
  13  * Neither the name of Intel Corporation nor the names of its contributors
  14  * may be used to endorse or promote products derived from this software
  15  * without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  18  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  21  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  25  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  26  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 //
  30 //
  31 // Grammar.asl - Minimally excercises most ASL constructs
  32 //
  33 // NOTE -- use: iasl -f -of grammar.asl to compile
  34 //
  35 //         This 1) Ignores errors (checks compiler error handling)
  36 //              2) Disables constant folding
  37 //
  38 //
  39
  40 /*******************************************************************************
  41 Compilation should look like this:
  42
  43 C:\acpica\tests\misc>iasl -f -of grammar.asl
  44
  45 Intel ACPI Component Architecture
  46 ASL Optimizing Compiler version 20090422 [Apr 22 2009]
  47 Copyright (C) 2000 - 2009 Intel Corporation
  48 Supports ACPI Specification Revision 3.0a
  49
  50 grammar.asl   187:     Name (_NPK, Package (8)
  51 Warning  1098 -                 ^ Unknown reserved name (_NPK)
  52
  53 grammar.asl   510:     NAME (ESC1, "abcdefg\x00hijklmn")
  54 Warning  1042 -                                ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
  55
  56 grammar.asl   511:     NAME (ESC2, "abcdefg\000hijklmn")
  57 Warning  1042 -                                ^ Invalid Hex/Octal Escape - Non-ASCII or NULL
  58
  59 grammar.asl   601:     Method (RCIV, 1)
  60 Warning  1087 -                   ^ Not all control paths return a value (RCIV)
  61
  62 grammar.asl   608:         RCIV (Subtract (Arg0, 1))
  63 Remark   5073 -               ^ Recursive method call (RCIV)
  64
  65 grammar.asl   937:     Method (_ERR, 2)
  66 Warning  1077 -                   ^ Reserved method has too few arguments (_ERR requires 3)
  67
  68 grammar.asl  1377:         Store (0x1234567887654321, QWD2)
  69 Warning  1032 -                                    ^ 64-bit integer in 32-bit table, truncating
  70
  71 grammar.asl  1379:         if (LNotEqual (Local0, 0x1234567887654321))
  72 Warning  1032 -         64-bit integer in 32-bit table, truncating ^
  73
  74 grammar.asl  1459:         SizeOf (BUFO)
  75 Warning  1105 -                       ^ Result is not used, operator has no effect
  76
  77 grammar.asl  1485:         Acquire (MTX2, 1)
  78 Warning  1104 -                           ^ Possible operator timeout is ignored
  79
  80 grammar.asl  1633:         Add (Local0, Local1)
  81 Warning  1105 -                      ^ Result is not used, operator has no effect
  82
  83 grammar.asl  1804:     Method (COND)
  84 Warning  1087 -                   ^ Not all control paths return a value (COND)
  85
  86 grammar.asl  6010:             Name (_HID, "*PNP0A06")
  87 Error    4001 -                                     ^ String must be entirely alphanumeric (*PNP0A06)
  88
  89 grammar.asl  6461:             Name (_CRS, Buffer(26)  {"\_SB_.PCI2._CRS..........."})
  90 Warning  1038 -        Invalid or unknown escape sequence ^
  91
  92 grammar.asl  6800:                 And (Local0, 1, Local0) //  Local0 &= 1
  93 Error    4050 -                              ^ Method local variable is not initialized (Local0)
  94
  95 grammar.asl  6886:             Name (_HID, "*PNP0C0A")     //  Control Method Battey ID
  96 Error    4001 -                                     ^ String must be entirely alphanumeric (*PNP0C0A)
  97
  98 ASL Input:  grammar.asl - 10254 lines, 322162 bytes, 4810 keywords
  99 AML Output: grammar.aml - 43392 bytes, 669 named objects, 4141 executable opcodes
 100
 101 Compilation complete. 3 Errors, 12 Warnings, 1 Remarks, 1101 Optimizations
 102
 103 ***************************************************************************************************/
 104
 105 DefinitionBlock (
 106     "grammar.aml",      //Output filename
 107     "DSDT",             //Signature
 108     0x01,               //DSDT Revision ---> 32-bit table
 109     "Intel",            //OEMID
 110     "GRMTEST",          //TABLE ID
 111     0x20090511          //OEM Revision
 112     )
 113 {
 114
 115     External (\ABCD, UnknownObj)
 116
 117
 118     /* Device with _STA and _INI */
 119
 120     Device (A1)
 121     {
 122         Method (_STA)
 123         {
 124             Return (0x0F)
 125         }
 126
 127         Method (_INI)
 128         {
 129             Return
 130         }
 131     }
 132
 133     /* Device with no _STA, has _INI */
 134
 135     Device (A2)
 136     {
 137         Method (_INI)
 138         {
 139             Return
 140         }
 141     }
 142
 143     /* Device with _STA, no _INI */
 144
 145     Device (A3)
 146     {
 147         Method (_STA)
 148         {
 149             Return (0x0F)
 150         }
 151     }
 152
 153     /* Device with _STA and _INI, but not present */
 154
 155     Device (A4)
 156     {
 157         Method (_STA)
 158         {
 159             Return (Zero)
 160         }
 161
 162         Method (_INI)
 163         {
 164             Return
 165         }
 166     }
 167
 168
 169     /* Resource descriptors */
 170
 171     Device (IRES)
 172     {
 173         Name (PRT0, ResourceTemplate ()
 174         {
 175             IRQ (Edge, ActiveHigh, Exclusive) {3,4,5,6,7,9,10,11,14,15}
 176
 177             StartDependentFn (1,1)
 178             {
 179                 IRQNoFlags () {0,1,2}
 180             }
 181             EndDependentFn ()
 182         })
 183
 184         Method (_CRS, 0, NotSerialized)
 185         {
 186             Store ("_CRS:", Debug)
 187             Store (PRT0, Debug)
 188             Return (PRT0)
 189         }
 190
 191         Method (_SRS, 1, Serialized)
 192         {
 193             Store ("_SRS:", Debug)
 194             Store (Arg0, Debug)
 195             Return (Zero)
 196         }
 197     }
 198
 199     Name (_NPK, Package ()
 200     {
 201         0x1111,
 202         0x2222,
 203         0x3333,
 204         0x4444
 205     })
 206
 207
 208     Device (RES)
 209     {
 210         Name (_PRT, Package (0x04)
 211         {
 212             Package (0x04)
 213             {
 214                 0x0002FFFF,
 215                 Zero,
 216                 Zero,
 217                 Zero
 218             },
 219
 220             Package (0x04)
 221             {
 222                 0x0002FFFF,
 223                 One,
 224                 Zero,
 225                 Zero
 226             },
 227
 228             Package (0x04)
 229             {
 230                 0x000AFFFF,
 231                 Zero,
 232                 Zero,
 233                 Zero
 234             },
 235
 236             Package (0x04)
 237             {
 238                 0x000BFFFF,
 239                 Zero,
 240                 Zero,
 241                 Zero
 242             }
 243         })
 244
 245         Method (_CRS, 0, Serialized)
 246         {
 247             Name (PRT0, ResourceTemplate ()
 248             {
 249                 WordBusNumber (ResourceConsumer, MinFixed, MaxFixed, SubDecode,
 250                     0x0000, // Address Space Granularity
 251                     0xFFF2, // Address Range Minimum
 252                     0xFFF3, // Address Range Maximum
 253                     0x0032, // Address Translation Offset
 254                     0x0002,,,)
 255                 WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
 256                     0x0000, // Address Space Granularity
 257                     0x0000, // Address Range Minimum
 258                     0x00FF, // Address Range Maximum
 259                     0x0000, // Address Translation Offset
 260                     0x0100,,,)
 261                 WordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
 262                     0x0000, // Address Space Granularity
 263                     0xA000, // Address Range Minimum
 264                     0xBFFF, // Address Range Maximum
 265                     0x0000, // Address Translation Offset
 266                     0x2000,,,)
 267                 IO (Decode16, 0x0CF8, 0x0CFF, 0x01, 0x08)
 268                 WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
 269                     0x0000, // Address Space Granularity
 270                     0x0000, // Address Range Minimum
 271                     0x0CF7, // Address Range Maximum
 272                     0x0000, // Address Translation Offset
 273                     0x0CF8,,,
 274                     , TypeStatic)
 275                 WordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
 276                     0x0000, // Address Space Granularity
 277                     0x0D00, // Address Range Minimum
 278                     0xFFFF, // Address Range Maximum
 279                     0x0000, // Address Translation Offset
 280                     0xF300,,,
 281                     , TypeStatic)
 282                 DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
 283                     0x00000000, // Address Space Granularity
 284                     0x00000000, // Address Range Minimum
 285                     0x00000CF7, // Address Range Maximum
 286                     0x00000000, // Address Translation Offset
 287                     0x00000CF8,,,
 288                     , TypeStatic)
 289                 DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
 290                     0x00000000, // Address Space Granularity
 291                     0x000C8000, // Address Range Minimum
 292                     0x000EFFFF, // Address Range Maximum
 293                     0x00000000, // Address Translation Offset
 294                     0x00028000,,,
 295                     , AddressRangeMemory, TypeStatic)
 296                 DWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
 297                     0x00000000, // Address Space Granularity
 298                     0x000C8000, // Address Range Minimum
 299                     0x000EFFFF, // Address Range Maximum
 300                     0x00000000, // Address Translation Offset
 301                     0x00028000,,,)
 302                 QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
 303                     0x0000000000000000, // Address Space Granularity
 304                     0x0000000000000000, // Address Range Minimum
 305                     0x0000000000000CF7, // Address Range Maximum
 306                     0x0000000000000000, // Address Translation Offset
 307                     0x0000000000000CF8, 0x44, "This is a ResouceSource string",
 308                     , TypeStatic)
 309                 QWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
 310                     0x0000000000000000, // Address Space Granularity
 311                     0x0000000000000000, // Address Range Minimum
 312                     0x0000000000000CF7, // Address Range Maximum
 313                     0x0000000000000000, // Address Translation Offset
 314                     0x0000000000000CF8,,,
 315                     , TypeStatic)
 316                 QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
 317                     0x0000000000000000, // Address Space Granularity
 318                     0x0000000000100000, // Address Range Minimum
 319                     0x00000000FFDFFFFF, // Address Range Maximum
 320                     0x0000000000000000, // Address Translation Offset
 321                     0x00000000FFD00000,,,
 322                     , AddressRangeMemory, TypeStatic)
 323                 QWordSpace (0xC3, ResourceConsumer, PosDecode, MinFixed, MaxFixed, 0xA5,
 324                     0x0000000000000000, // Address Space Granularity
 325                     0x0000000000000000, // Address Range Minimum
 326                     0x0000000000000CF7, // Address Range Maximum
 327                     0x0000000000000000, // Address Translation Offset
 328                     0x0000000000000CF8,,,)
 329                 ExtendedIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
 330                     0x0000000000000000, // Address Space Granularity
 331                     0x0000000000000000, // Address Range Minimum
 332                     0x0000000000000CF7, // Address Range Maximum
 333                     0x0000000000000000, // Address Translation Offset
 334                     0x0000000000000CF8, // Address Length
 335                     0x0000000000000000, // Type Specific Attributes
 336                     , TypeStatic)
 337                 ExtendedMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
 338                     0x0000000000000000, // Address Space Granularity
 339                     0x0000000000100000, // Address Range Minimum
 340                     0x00000000FFDFFFFF, // Address Range Maximum
 341                     0x0000000000000000, // Address Translation Offset
 342                     0x00000000FFD00000, // Address Length
 343                     0x0000000000000000, // Type Specific Attributes
 344                     , AddressRangeMemory, TypeStatic)
 345                 ExtendedSpace (0xC3, ResourceProducer, PosDecode, MinFixed, MaxFixed, 0xA3,
 346                     0x0000000000000000, // Address Space Granularity
 347                     0x0000000000100000, // Address Range Minimum
 348                     0x00000000FFDFFFFF, // Address Range Maximum
 349                     0x0000000000000000, // Address Translation Offset
 350                     0x00000000FFD00000, // Address Length
 351                     0x0000000000000000) // Type Specific Attributes
 352                 IO (Decode16, 0x0010, 0x0020, 0x01, 0x10)
 353                 IO (Decode16, 0x0090, 0x00A0, 0x01, 0x10)
 354                 FixedIO (0x0061, 0x01)
 355                 IRQNoFlags () {2}
 356                 DMA (Compatibility, BusMaster, Transfer8_16) {4}
 357                 DMA (Compatibility, BusMaster, Transfer8) {2,5,7}
 358                 Memory32Fixed (ReadWrite, 0x00100000, 0x00000000)
 359                 Memory32Fixed (ReadOnly, 0xFFFE0000, 0x00020000)
 360                 Memory32 (ReadOnly, 0x00020000, 0xFFFE0000, 0x00000004, 0x00000200)
 361                 Memory24 (ReadOnly, 0x1111, 0x2222, 0x0004, 0x0200)
 362                 Interrupt (ResourceConsumer, Level, ActiveLow, Exclusive, 0xE, "\\_SB_.TEST")
 363                 {
 364                     0x00000E01,
 365                 }
 366                 Interrupt (ResourceConsumer, Edge, ActiveHigh, Exclusive, 0x6, "xxxx")
 367                 {
 368                     0x00000601,
 369                     0x00000003,
 370                     0x00000002,
 371                     0x00000001,
 372                 }
 373                 Interrupt (ResourceProducer, Edge, ActiveHigh, Exclusive)
 374                 {
 375                     0xFFFF0000,
 376                     0x00000003,
 377                     0x00000002,
 378                     0x00000001,
 379                     0x00000005,
 380                     0x00000007,
 381                     0x00000009,
 382                 }
 383                 VendorShort () {0x01, 0x02, 0x03}
 384                 VendorLong ()
 385                 {
 386                     0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 387                     0x09
 388                 }
 389                 Register (SystemIO, 0x08, 0x00, 0x00000000000000B2, , R000)
 390                 Register (SystemMemory, 0x08, 0x00, 0x00000000000000B2)
 391                 StartDependentFnNoPri ()
 392                 {
 393                     IRQNoFlags () {0,1,2}
 394                     IRQ (Level, ActiveLow, Shared) {3,4,5,6,7,9,10,11,14,15}
 395                 }
 396                 EndDependentFn ()
 397             })
 398             CreateWordField (PRT0, 0x08, BMIN)
 399             CreateByteField (PRT0, R000._ASZ, RSIZ)
 400             Store (0x03, BMIN)
 401             Return (PRT0)
 402         }
 403
 404         Method (_PRS, 0, Serialized)
 405         {
 406             Name (BUF0, ResourceTemplate ()
 407             {
 408                 StartDependentFn (0x01, 0x02)
 409                 {
 410                     IO (Decode16, 0x03D8, 0x03F8, 0x01, 0x08)
 411                     IRQNoFlags () {4}
 412                 }
 413                 StartDependentFn (0x02, 0x01)
 414                 {
 415                     IO (Decode16, 0x03D8, 0x03E8, 0x01, 0x08)
 416                     IRQNoFlags () {4}
 417                 }
 418                 StartDependentFn (0x00, 0x02)
 419                 {
 420                     IO (Decode16, 0x02E8, 0x02F8, 0x01, 0x08)
 421                     IRQNoFlags () {3}
 422                 }
 423                 StartDependentFn (0x00, 0x02)
 424                 {
 425                     IO (Decode16, 0x02D8, 0x02E8, 0x01, 0x08)
 426                     IRQNoFlags () {3}
 427                 }
 428                 StartDependentFn (0x02, 0x00)
 429                 {
 430                     IO (Decode16, 0x0100, 0x03F8, 0x08, 0x08)
 431                     IRQNoFlags () {1,3,4,5,6,7,8,10,11,12,13,14,15}
 432                 }
 433                 EndDependentFn ()
 434             })
 435             Return (BUF0)
 436         }
 437
 438         Method (_SRS, 1, Serialized)
 439         {
 440             Return (Zero)
 441         }
 442     }
 443
 444
 445     Name(\_S0,Package(0x04){
 446         0x00,
 447         0x00,
 448         0x00,
 449         0x00
 450     })
 451     Name(\_S3,Package(0x04){
 452         0x05,
 453         0x05,
 454         0x00,
 455         0x00
 456     })
 457     Name(\_S4,Package(0x04){
 458         0x06,
 459         0x06,
 460         0x00,
 461         0x00
 462     })
 463     Name(\_S5,Package(0x04){
 464         0x07,
 465         0x07,
 466         0x00,
 467         0x00
 468     })
 469
 470 /* Examine this table header (DSDT) */
 471
 472 /*
 473     DataTableRegion (HDR, "DSDT", "", "")
 474     Field (HDR, AnyAcc, NoLock, Preserve)
 475     {
 476         SIG,  32,
 477         LENG, 32,
 478         REV,  8,
 479         SUM,  8,
 480         OID,  48,
 481         OTID, 64,
 482         OREV, 32,
 483         CID,  32,
 484         CREV, 32
 485     }
 486
 487     Method (SIZE)
 488     {
 489         If (LLess (REV, 2))
 490         {
 491             Store ("32-bit table", Debug)
 492         }
 493         else
 494         {
 495             Store ("64-bit table", Debug)
 496         }
 497         Return (0)
 498     }
 499
 500 */
 501     Name (SIZE, 0)
 502
 503     /* Custom operation region */
 504
 505     OperationRegion(MYOP,0x80,0xFD60,0x6)
 506     Field(MYOP,ByteAcc,NoLock,Preserve)
 507     {
 508         MFLD,8
 509     }
 510
 511     Method (TCOP,, Serialized)
 512     {
 513         Name (_STR, Unicode ("test"))
 514         Store (4, MFLD)
 515         Store (MFLD, Local0)
 516     }
 517
 518     Name (ERRS, 0x0)
 519
 520     /* Warning should be issued for premature string termination */
 521
 522     NAME (ESC1, "abcdefg\x00hijklmn")
 523     NAME (ESC2, "abcdefg\000hijklmn")
 524     Name (ESC3, "abc\a\bdef\f\n\r\t\v\x03ffff\432")
 525
 526
 527     Name(CRSA,ResourceTemplate()
 528     {
 529         WORDBusNumber(ResourceProducer,MinFixed,MaxFixed,PosDecode,0x0000,0x0019,0x001D,0x0000,0x0005)
 530         WORDIO(ResourceProducer,MinFixed,MaxFixed,PosDecode,NonISAOnlyRanges,0x0000,0xC000,0xCFFF,0x0000,0x1000)
 531         DWORDMemory(ResourceProducer,PosDecode,MinFixed,MaxFixed,NonCacheable,ReadWrite,0x00000000,0xD8000000,0xDBFFFFFF,0x00000000,0x04000000)
 532
 533     })
 534     Name(CRSB,ResourceTemplate()
 535     {
 536         DWORDMemory(ResourceProducer,PosDecode,MinFixed,MaxFixed,NonCacheable,ReadWrite,0x00000000,0xD8000000,0xDBFFFFFF,0x00000000,0x04000000)
 537
 538     })
 539
 540     Name(CRSC,ResourceTemplate()
 541     {
 542         VendorShort () {0x1, 0x2, 0x3}
 543     })
 544     Name(CRSD,ResourceTemplate()
 545     {
 546         VendorLong (VNDL) {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9}
 547     })
 548
 549     Name(CRSE,ResourceTemplate()
 550     {
 551         IRQNoFlags(){3,4,10,11}
 552         IRQNoFlags(xxxt){3,4,10,11}
 553     })
 554     Name(CRSR, Buffer (Add (SizeOf(CRSA),SizeOf(CRSB))){})
 555     Method(_CRS,0,NotSerialized)
 556     {
 557         Return(CRSR)
 558     }
 559
 560
 561     //
 562     // Unnamed scope
 563     //
 564     Scope (\)
 565     {
 566         Name(Bxxx,0xFFFFFFFF)
 567     }
 568
 569     Name (LANS, 0x0)
 570
 571     PowerResource(LANP,1,0)
 572     {
 573         Method(_STA){
 574             If(LEqual(And(LANS,0x30),0x30)){
 575                 Return(One)
 576             } Else {
 577                 Return(Zero)
 578             }
 579         }
 580         Method(_ON){
 581             If(LNot(_STA())){
 582                 Store (0x30, LANS)
 583             }
 584         }
 585         Method(_OFF){
 586             If(_STA()){
 587                 Store (0, LANS)
 588             }
 589         }
 590     }
 591
 592
 593     /* Can a method define another method? */
 594
 595     /**********************************
 596     Method (TASK, 2, SERIALIZED)
 597     {
 598         Sleep (100)
 599
 600         Method (TAS2)
 601         {
 602             Sleep (100)
 603         }
 604
 605         TAS2()
 606         Return
 607
 608     }
 609     ************************************/
 610
 611     /* A recursive method */
 612
 613     Method (RCIV, 1)
 614     {
 615         Store (Arg0, Debug)
 616         If (Lequal (Arg0, 0))
 617         {
 618             Return ()
 619         }
 620         RCIV (Subtract (Arg0, 1))
 621     }
 622
 623     Method (RTOP)
 624     {
 625         RCIV (100)
 626     }
 627
 628
 629     Scope(\_PR)
 630     {
 631         Processor(CPU0,0x0,0xFFFFFFFF,0x0) {}
 632     }
 633
 634     Name(B1TP,0xFFFFFFFF)
 635
 636     Name(B2TP,0xFFFFFFFF)
 637     Name(ADPS,0xFFFFFFFF)
 638     Name(B1PS,0xFFFFFFFF)
 639     Name(B1RS,0xFFFFFFFF)
 640     Name(B1CS,0xFFFFFFFF)
 641     Name(B2PS,0xFFFFFFFF)
 642     Name(B2RS,0xFFFFFFFF)
 643     Name(B2CS,0xFFFFFFFF)
 644     Name(B1DC,3000)
 645     Name(B2DC,2600)
 646     Name(B1LF,3000)
 647     Name(B2LF,2600)
 648     Name(BPIF,0)
 649     Name(PBLL,0)
 650
 651     Name(RBIF,Package()
 652     {
 653         0x1,
 654         2200,
 655         2200,
 656         0x1,
 657         10800,
 658         0,
 659         0,
 660         1,
 661         1,
 662         "CA54200-5003/5",
 663         "1",
 664         "LION",
 665         "Fujitsu"
 666     })
 667
 668     Method(SMWE, 4)
 669     {
 670        return(ONES)
 671     }
 672
 673     Method(SMRE, 4)
 674     {
 675        return(ONES)
 676     }
 677
 678 /*
 679     Method(RDBT,0,Serialized){
 680         If(LNot(SMWE(0x09,0x15,1,1))){
 681                     Store(0x18,Local2)
 682             }
 683     }
 684 */
 685     Scope(_SB)
 686     {
 687
 688         Name (SBUF, Buffer (128) {})
 689
 690         CreateBitField (SBUF, 3, BITY)
 691         CreateByteField (SBUF, 1, BYTY)
 692         CreateWordField (SBUF, 2, WRDZ)
 693         CreateDwordField (SBUF, 4, DWDZ)
 694         CreateQwordField (SBUF, 8, QWDZ)
 695         CreateField (SBUF, 128, 12, FLDZ)
 696         CreateField (SBUF, 148, 96, FLDY)
 697         CreateField (SBUF, 148, 96, \_SB_.FLDW)
 698
 699         Method (_INI)
 700         {
 701             CreateField (\_SB_.SBUF, 148, 96, FLDV)
 702         }
 703
 704
 705         Device(PCI0)
 706         {
 707             Name(_HID,EISAID("PNP0A03"))
 708             Name(_ADR,0x0)
 709
 710             Method(_CRS,, Serialized)
 711             {
 712                 Name(PRT0, ResourceTemplate() {
 713                     WORDBusNumber(                          // Bus number resource(0)
 714                             ResourceConsumer,               // bit 0 of general flags is 1
 715                             MinFixed,                       // Range is notfixed
 716                             MaxFixed,                       // Range is not fixed
 717                             SubDecode,                      // SubDecode
 718                             0x0000,                           // Granularity
 719                             0xfff1,                           // Min
 720                             0xfff2,                           // Max
 721                             0x0032,                           // Translation
 722                             0x0002,,,                         // Range Length
 723                             BUS0
 724                     ) } )// PRT0
 725
 726                 CreateWordField(PRT0, BUS0._MIN, BMIN)          //Minimum bus number suported under this bridge.
 727
 728                 Store(3, BMIN)
 729                 Return(PRT0)
 730
 731             } // _CRS
 732
 733             Method(_SRS)
 734             {
 735                 Return ()
 736             }
 737
 738             Device(EIO)
 739             {
 740                 OperationRegion(FJIO,SystemIO,0xFD60,0x6)
 741                     Field(FJIO,ByteAcc,NoLock,Preserve)
 742                     {
 743                         GIDX,8,
 744
 745                         GDTA,8,
 746
 747                         PIDX,8,
 748
 749                         PDTA,8,
 750
 751                         SIDX,8,
 752
 753                         SDTA,8
 754                     }
 755                     IndexField(GIDX,GDTA,ByteAcc,NoLock,Preserve)
 756                     {
 757                         Offset(0x2),
 758                          ,5,
 759                         VGAS,2,
 760                         Offset(0x4),
 761                          ,4,
 762                         DCKE,1,
 763                         Offset(0x5),
 764                          ,6,
 765                         ACPW,1,
 766
 767                         Offset(0xA),
 768                         B1P,1,
 769
 770                         B2P,1,
 771
 772                         B1C,1,
 773
 774                         B2C,1,
 775
 776                         B1ER,1,
 777
 778                         B2ER,1,
 779
 780                         Offset(0xB),
 781                         B1CP,8,
 782
 783                         B2CP,8,
 784
 785                         BCP,8,
 786
 787                         B1VH,8,
 788
 789                         B1VL,8,
 790
 791                         B2VH,8,
 792
 793                         B2VL,8,
 794
 795                         B1TM,8,
 796
 797                         B2TM,8,
 798
 799                         B1CH,8,
 800
 801                         B1CL,8,
 802
 803                         B2CH,8,
 804
 805                         B2CL,8
 806                     }
 807                 }
 808             }
 809         }
 810
 811         Method(RDBT,3,Serialized){
 812             Store(0x1FFF,Local1)
 813             If( Arg0 ){
 814                 Store(0x2FFF,Local1)
 815             }
 816             Store(0x18,Local2)
 817             If( Arg1 ){
 818                 Store(0x10,Local2)
 819             }
 820             If(LNot(SMRE(0x09,0x15,1,RefOf(Local0)))){
 821                 If(LNot(SMWE(0x08,0x14,1,Local1))){
 822                     If(LNot(SMRE(0x09,0x17,Local2,RefOf(Local3)))){
 823                         Store(Local1,Arg2)
 824                     }
 825                 }
 826                 Or(Local0,0xFFF,Local0)
 827                 SMWE(0x08,0x14,1,Local0)
 828             }
 829         }
 830         Method(MKWD,2)
 831         {
 832             If(And(Arg1,0x80)) {
 833                 Or(0xFFFF0000,Arg0,Local0)
 834                 Or(Local0,ShiftLeft(Arg1,8),Local0)
 835                 Subtract(Zero,Local0,Local0)
 836             } else {
 837                 Store(Arg0,Local0)
 838                 Or(Local0,ShiftLeft(Arg1,8),Local0)
 839             }
 840             Return(Local0)
 841         }
 842
 843         Device(CMB1)
 844         {
 845             Name(_HID,EISAID("PNP0C0A"))
 846             Name(_UID,0x1)
 847             Alias(\_SB.PCI0.EIO.B1P,\_SB_.PCI0.XXXX)
 848             Alias(\_SB.PCI0.EIO.B1P,B1P)
 849             Alias(\_SB.PCI0.EIO.B1C,B1C)
 850             Alias(\_SB.PCI0.EIO.B1CH,B1CH)
 851             Alias(\_SB.PCI0.EIO.B1CL,B1CL)
 852             Alias(\_SB.PCI0.EIO.B1VH,B1VH)
 853             Alias(\_SB.PCI0.EIO.B1VL,B1VL)
 854             Alias(\_SB.PCI0.EIO.B1CP,B1CP)
 855
 856             Method(_INI)
 857                         {
 858                 Store(B1P, B1PS)
 859                 Store(B1CP,B1RS)
 860                 Store(B1C, B1CS)
 861             }
 862
 863             Method(_BIF){
 864                 RDBT(Zero,Zero,RefOf(B1DC))
 865                 RDBT(Zero,One,RefOf(B1LF))
 866                 Store(B1DC,Index(RBIF,1))
 867                 Store(B1LF,Index(RBIF,2))
 868                 Store("CA54200-5003/5",Index(RBIF,9))
 869                 Store("1",Index(RBIF,10))
 870                 Return(RBIF)
 871             }
 872
 873             Method(_BST,, Serialized) {
 874
 875                 _INI()
 876
 877                 Store(Zero,Local0)
 878
 879                 if (LAnd(B1P,LNot(B1C))){
 880                     Or(Local0,1,Local0)
 881                 }
 882
 883                 if (LAnd(B1P,B1C)) {
 884                     Or(Local0,2,Local0)
 885                 }
 886
 887                 if (LLessEqual(B1CP,1)) {
 888                     Or(Local0,4,Local0)
 889                 }
 890
 891                 Store(MKWD(B1CL,B1CH),Local1)
 892
 893                 Store(Divide(Add(Multiply(B1CP,B1LF),99),100),Local2)
 894
 895                 Store(MKWD(B1VL,B1VH),Local3)
 896
 897                 Name(STAT,Package(4){})
 898                 Store(Local0,Index(STAT,0))
 899                 Store(Local1,Index(STAT,1))
 900                 Store(Local2,Index(STAT,2))
 901                 Store(Local3,Index(STAT,3))
 902
 903                 If(LNot(BPIF)){
 904 //                    \_SB.PCI0.EIO.EC0.IECT()
 905 //                    \_SB.PCI0.EIO.EC0.SECT()
 906                     Store(One,BPIF)
 907                 }
 908                 return(STAT)
 909             }
 910
 911         }
 912
 913     Device (DEV1)
 914     {
 915     }
 916
 917     Scope(\_TZ)
 918     {
 919         ThermalZone(TZ1)
 920         {
 921             Name(_PSL,Package()
 922             {
 923                 \_PR.CPU0
 924             })
 925         }
 926     }
 927
 928     Method (TZ2, 0, SERIALIZED)
 929     {
 930         Name(_PSL,Package()
 931         {
 932             \_PR.CPU0
 933         })
 934
 935         Return (_PSL)
 936     }
 937
 938     ThermalZone (THM1)
 939     {
 940     }
 941
 942     Method (NOTI)
 943     {
 944         Notify (\DEV1, 0)
 945         Notify (\THM1, 0)
 946         Notify (\_PR.CPU0, 0)
 947     }
 948
 949     Method (_ERR, 2)
 950     {
 951         Increment (ERRS)
 952         Store ("Run-time exception:", Debug)
 953         Store (Arg0, Debug)
 954         Store (Arg1, Debug)
 955
 956         Return (0)          // Map error to AE_OK
 957     }
 958
 959     Method (DIV0)
 960     {
 961         Store (1, Local0)
 962         Store (0, Local1)
 963         Divide (Local0, Local1, Local3)
 964
 965         Store ("DIV0 - noabort", Debug)
 966     }
 967
 968     Method (ERR_, 1)
 969     {
 970         if (LEqual (Arg0, 0))
 971         {
 972             Store ("+*+*+*+* MTHD_ERROR: Results not equal!", Debug)
 973         }
 974         if (LEqual (Arg0, 1))
 975         {
 976             Store ("+*+*+*+* MTHD_ERROR: Numeric result is incorrect!", Debug)
 977         }
 978         if (LEqual (Arg0, 2))
 979         {
 980             Store ("+*+*+*+* MTHD_ERROR: Operand was clobbered!", Debug)
 981         }
 982
 983         Notify (DEV1, Arg0)
 984         Increment (ERRS)
 985     }
 986
 987     Method (R226, 2)
 988     {
 989     }
 990     Method (R225, 2)
 991     {
 992         R226 (Arg0, Arg1)
 993     }
 994     Method (R224, 2)
 995     {
 996         R225 (Arg1, Arg0)
 997     }
 998     Method (R223, 2)
 999     {
1000         R224 (Arg0, Arg1)
1001     }
1002     Method (R222, 2)
1003     {
1004         R223 (Arg1, Arg0)
1005     }
1006     Method (R111)
1007     {
1008         Store (0x01010101, Local0)
1009         R222 (0xABAB, Local0)
1010         Store (Local0, Local1)
1011     }
1012
1013     Method (MAIN)
1014     {
1015
1016 //      SIZE()
1017         Store (NUM1(), Local0)
1018         \CMB1._BST()
1019         RDBT(1,2,3)
1020         OBJ1(1)
1021         OBJ2(2)
1022         CHEK()
1023         RETZ()
1024         BITZ()
1025         LOGS()
1026         REFS()
1027         COND()
1028         TZ2()
1029
1030         //
1031         // iPCO tests added
1032         //
1033         Store (\IFEL.TEST(), Local0)
1034         if (LGreater (Local0, 0))
1035         {
1036             ERR_ (1)
1037             Return(Local0)
1038         }
1039
1040         Store (\NOSV.TEST(), Local0)
1041         if (LGreater (Local0, 0))
1042         {
1043             ERR_ (1)
1044             Return(Local0)
1045         }
1046
1047         Store (\IDXF.TEST(), Local0)
1048         if (LGreater (Local0, 0))
1049         {
1050             ERR_ (1)
1051             Return(Local0)
1052         }
1053
1054         Store (\_SB_.NSTL.TEST(), Local0)
1055         if (LGreater (Local0, 0))
1056         {
1057             ERR_ (1)
1058             Return(Local0)
1059         }
1060
1061         Store (\RTBF.TEST(), Local0)
1062         if (LGreater (Local0, 0))
1063         {
1064             ERR_ (1)
1065             Return(Local0)
1066         }
1067
1068         Store (\_SB_.RTLV.TEST(), Local0)
1069         if (LGreater (Local0, 0))
1070         {
1071             ERR_ (1)
1072             Return(Local0)
1073         }
1074
1075         Store (\_SB_.RETP.TEST(), Local0)
1076         if (LGreater (Local0, 0))
1077         {
1078             ERR_ (1)
1079             Return(Local0)
1080         }
1081
1082         Store (\WHLR.TEST(), Local0)
1083         if (LGreater (Local0, 0))
1084         {
1085             ERR_ (1)
1086             Return(Local0)
1087         }
1088
1089         Store (\ANDO.TEST(), Local0)
1090         if (LGreater (Local0, 0))
1091         {
1092             ERR_ (1)
1093             Return(Local0)
1094         }
1095
1096         Store (\BRKP.TEST(), Local0)
1097         if (LGreater (Local0, 0))
1098         {
1099             ERR_ (1)
1100             Return(Local0)
1101         }
1102
1103         Store (\ADSU.TEST(), Local0)
1104         if (LGreater (Local0, 0))
1105         {
1106             ERR_ (1)
1107             Return(Local0)
1108         }
1109
1110         Store (\INDC.TEST(), Local0)
1111         if (LGreater (Local0, 0))
1112         {
1113             ERR_ (1)
1114             Return(Local0)
1115         }
1116
1117         Store (\LOPS.TEST(), Local0)
1118         if (LGreater (Local0, 0))
1119         {
1120             ERR_ (1)
1121             Return(Local0)
1122         }
1123
1124         Store (\FDSO.TEST(), Local0)
1125         if (LGreater (Local0, 0))
1126         {
1127             ERR_ (1)
1128             Return(Local0)
1129         }
1130
1131         Store (\MLDV.TEST(), Local0)
1132         if (LGreater (Local0, 0))
1133         {
1134             ERR_ (1)
1135             Return(Local0)
1136         }
1137
1138         Store (\NBIT.TEST(), Local0)
1139         if (LGreater (Local0, 0))
1140         {
1141             ERR_ (1)
1142             Return(Local0)
1143         }
1144
1145         Store (\SHFT.TEST(), Local0)
1146         if (LGreater (Local0, 0))
1147         {
1148             ERR_ (1)
1149             Return(Local0)
1150         }
1151
1152         Store (\XORD.TEST(), Local0)
1153         if (LGreater (Local0, 0))
1154         {
1155             ERR_ (1)
1156             Return(Local0)
1157         }
1158
1159         Store (\CRBF.TEST(), Local0)
1160         if (LGreater (Local0, 0))
1161         {
1162             ERR_ (1)
1163             Return(Local0)
1164         }
1165
1166         Store (\IDX4.TEST(), Local0)
1167         if (LGreater (Local0, 0))
1168         {
1169             ERR_ (1)
1170             Return(Local0)
1171         }
1172
1173         Store (\EVNT.TEST(), Local0)
1174         if (LGreater (Local0, 0))
1175         {
1176             ERR_ (1)
1177             Return(Local0)
1178         }
1179
1180         Store (\SZLV.TEST(), Local0)
1181         if (LGreater (Local0, 0))
1182         {
1183             ERR_ (1)
1184             Return(Local0)
1185         }
1186
1187         Store (\_SB_.BYTF.TEST(), Local0)
1188         if (LGreater (Local0, 0))
1189         {
1190             ERR_ (1)
1191             Return(Local0)
1192         }
1193
1194         Store (\DWDF.TEST(), Local0)
1195         if (LGreater (Local0, 0))
1196         {
1197             ERR_ (1)
1198             Return(Local0)
1199         }
1200
1201         Store (\DVAX.TEST(), Local0)
1202         if (LGreater (Local0, 0))
1203         {
1204             ERR_ (1)
1205             Return(Local0)
1206         }
1207
1208         Store (\IDX6.TEST(), Local0)
1209         if (LGreater (Local0, 0))
1210         {
1211             ERR_ (1)
1212             Return(Local0)
1213         }
1214
1215         Store (\IDX5.TEST(), Local0)
1216         if (LGreater (Local0, 0))
1217         {
1218             ERR_ (1)
1219             Return(Local0)
1220         }
1221
1222         Store (\_SB_.IDX0.TEST(), Local0)
1223         if (LGreater (Local0, 0))
1224         {
1225             ERR_ (1)
1226             Return(Local0)
1227         }
1228
1229         Store (\_SB_.IDX3.TEST(), Local0)
1230         if (LGreater (Local0, 0))
1231         {
1232             ERR_ (1)
1233             Return(Local0)
1234         }
1235
1236         Store (\IDX7.TEST(), Local0)
1237         if (LGreater (Local0, 0))
1238         {
1239             ERR_ (1)
1240             Return(Local0)
1241         }
1242
1243         Store (\MTCH.TEST(), Local0)
1244         if (LGreater (Local0, 0))
1245         {
1246             ERR_ (1)
1247             Return(Local0)
1248         }
1249
1250         Store (\WHLB.TEST(), Local0)
1251         if (LGreater (Local0, 0))
1252         {
1253             ERR_ (1)
1254             Return(Local0)
1255         }
1256
1257         Store (\_SB_.IDX2.TEST(), Local0)
1258         if (LGreater (Local0, 0))
1259         {
1260             ERR_ (1)
1261             Return(Local0)
1262         }
1263
1264         Store (\SIZO.TEST(), Local0)
1265         if (LGreater (Local0, 0))
1266         {
1267             ERR_ (1)
1268             Return(Local0)
1269         }
1270
1271         Store (\_SB_.SMIS.TEST(), Local0)
1272         if (LGreater (Local0, 0))
1273         {
1274             ERR_ (1)
1275             Return(Local0)
1276         }
1277
1278         if (LGreater (ERRS, 0))
1279         {
1280             Store ("****** There were errors during the execution of the test ******", Debug)
1281         }
1282
1283         //
1284         // Last Test
1285         //
1286
1287         Return(0) // Success
1288     }
1289
1290
1291     Method (OBJ1, 1, SERIALIZED)
1292     {
1293
1294         Store (3, Local0)
1295         Name(BUFR, Buffer (Local0) {})
1296         Name(BUF1, Buffer (4) {1,2,3,4})
1297         Name(BUF2, Buffer (4) {})
1298
1299         Store (BUF1, BUF2)
1300         Mutex (MTX1, 4)
1301
1302         Alias (MTX1, MTX2)
1303     }
1304
1305
1306     Mutex (MTXT, 0)
1307     Mutex (MTXX, 0)
1308
1309     /*
1310      * Field Creation
1311      */
1312
1313     Method (FLDS,, Serialized)
1314     {
1315         Store ("++++++++ Creating BufferFields", Debug)
1316         Name (BUF2, Buffer (128) {})
1317
1318         CreateBitField (BUF2, 3, BIT2)
1319         CreateByteField (BUF2, 1, BYT2)
1320         CreateWordField (BUF2, 2, WRD2)
1321         CreateDwordField (BUF2, 4, DWD2)
1322         CreateQwordField (BUF2, 8, QWD2)
1323         CreateField (BUF2, 128, 12, FLD2)
1324         CreateField (BUF2, 148, 96, FLD3)
1325
1326         Store (0x1, BIT2)
1327         Store (BIT2, Local0)
1328         if (LNotEqual (Local0, 0x1))
1329         {
1330             ERR_ (1)
1331         }
1332         else
1333         {
1334             Store (DerefOf (Index (BUF2, 0)), Local0)
1335             if (LNotEqual (Local0, 0x08))
1336             {
1337                 ERR_ (1)
1338             }
1339             else
1340             {
1341                 Store ("++++++++ Bit BufferField I/O PASS", Debug)
1342             }
1343         }
1344
1345         Store (0x1A, BYT2)
1346         Store (BYT2, Local0)
1347         if (LNotEqual (Local0, 0x1A))
1348         {
1349             ERR_ (1)
1350         }
1351         else
1352         {
1353             Store ("++++++++ Byte BufferField I/O PASS", Debug)
1354         }
1355
1356         Store (0x1234, WRD2)
1357         Store (WRD2, Local0)
1358         if (LNotEqual (Local0, 0x1234))
1359         {
1360             ERR_ (1)
1361         }
1362         else
1363         {
1364             Store ("++++++++ Word BufferField I/O PASS", Debug)
1365         }
1366
1367         Store (0x123, FLD2)
1368         Store (FLD2, Local0)
1369         if (LNotEqual (Local0, 0x123))
1370         {
1371             ERR_ (1)
1372         }
1373         else
1374         {
1375             Store ("++++++++ 12-bit BufferField I/O PASS", Debug)
1376         }
1377
1378         Store (0x12345678, DWD2)
1379         Store (DWD2, Local0)
1380         if (LNotEqual (Local0, 0x12345678))
1381         {
1382             ERR_ (1)
1383         }
1384         else
1385         {
1386             Store ("++++++++ Dword BufferField I/O PASS", Debug)
1387         }
1388
1389         Store (0x1234567887654321, QWD2)
1390         Store (QWD2, Local0)
1391         if (LNotEqual (Local0, 0x1234567887654321))
1392         {
1393             ERR_ (1)
1394         }
1395         else
1396         {
1397             Store ("++++++++ Qword BufferField I/O PASS", Debug)
1398         }
1399     }
1400
1401
1402     /* Field execution */
1403
1404     Method (FLDX,, Serialized)
1405     {
1406         Field (\_SB_.MEM.SMEM, AnyAcc, NoLock, Preserve)
1407         {   //  Field:  SMEM overlay using 32-bit field elements
1408             SMD0,   32, //  32-bits
1409             SMD1,   32,     //  32-bits
1410             SMD2,   32,     //  32-bits
1411             SMD3,   32  //  32-bits
1412         }   //  Field:  SMEM overlay using 32-bit field elements
1413         Field (\_SB_.MEM.SMEM, AnyAcc, NoLock, Preserve)
1414         {   //  Field:  SMEM overlay using greater than 32-bit field elements
1415             SME0,   69, //  larger than an integer (32 or 64)
1416             SME1,   97  //  larger than an integer
1417         }   //  Field:  SMEM overlay using greater than 32-bit field elements
1418     }
1419
1420
1421     Method (MTX_, )
1422     {
1423         /* Test "Force release" of mutex on method exit */
1424
1425         Acquire (MTXT, 0xFFFF)
1426         Acquire (MTXX, 0xFFFF)
1427
1428         Store ("++++++++ Acquiring Mutex MTX2", Debug)
1429         Acquire (_GL_, 0xFFFF)
1430
1431
1432         Store ("++++++++ Releasing Mutex MTX2", Debug)
1433         Release (_GL_)
1434     }
1435
1436
1437     Method (OBJ2, 1, Serialized)
1438     {
1439         Store ("++++++++ Creating Buffer BUFO", Debug)
1440         Name (BUFO, Buffer (32) {})
1441
1442         Store ("++++++++ Creating OpRegion OPR2", Debug)
1443         OperationRegion (OPR2, SystemMemory, Arg0, 256)
1444
1445         Store ("++++++++ Creating Field(s) in OpRegion OPR2", Debug)
1446         Field (OPR2, ByteAcc, NoLock, Preserve)
1447         {
1448             IDX2, 8,
1449             DAT2, 8,
1450             BNK2, 4
1451         }
1452
1453         Store ("++++++++ Creating BankField BNK2 in OpRegion OPR2", Debug)
1454         //
1455         // mcw 3/20/00 - changed FET0, 4, FET1, 3 to FET0, 1, FET1, 1
1456         //
1457         BankField (OPR2, BNK2, 0, ByteAcc, NoLock, Preserve)
1458         {
1459             FET0, 4,
1460             FET1, 3
1461         }
1462
1463         Store ("++++++++ Creating IndexField", Debug)
1464         IndexField (IDX2, DAT2, ByteAcc, NoLock, Preserve)
1465         {
1466             FET2, 4,
1467             FET3, 3
1468         }
1469
1470         Store ("++++++++ SizeOf (BUFO)", Debug)
1471         SizeOf (BUFO)
1472
1473         Store ("++++++++ Store (SizeOf (BUFO), Local0)", Debug)
1474         Store (SizeOf (BUFO), Local0)
1475
1476         Store ("++++++++ Concatenate (\"abd\", \"def\", Local0)", Debug)
1477         Concatenate ("abd", "def", Local0)
1478         Store (Local0, Debug)
1479
1480         Store ("++++++++ Concatenate (\"abd\", 0x7B, Local0)", Debug)
1481         Concatenate ("abd", 0x7B, Local0)
1482         Store (Local0, Debug)
1483
1484         Store ("++++++++ Creating Event EVT2", Debug)
1485         Event (EVT2)
1486
1487         Store ("++++++++ Creating Mutex MTX2", Debug)
1488         Mutex (MTX2, 0)
1489
1490         Store ("++++++++ Creating Alias MTXA to MTX2", Debug)
1491         Alias (MTX2, MTXA)
1492
1493         Store ("++++++++ Acquiring Mutex MTX2", Debug)
1494         Acquire (MTX2, 0xFFFF)
1495
1496         Store ("++++++++ Acquiring Mutex MTX2 (2nd acquire)", Debug)
1497         Acquire (MTX2, 1)
1498
1499         Store ("++++++++ Releasing Mutex MTX2", Debug)
1500         Release (MTX2)
1501
1502         // Type 1 opcodes
1503
1504         Store ("++++++++ Signalling Event EVT2", Debug)
1505         Signal (EVT2)
1506
1507         Store ("++++++++ Resetting Event EVT2", Debug)
1508         Reset (EVT2)
1509
1510         Store ("++++++++ Signalling Event EVT2", Debug)
1511         Signal (EVT2)
1512
1513         Store ("++++++++ Waiting Event EVT2", Debug)
1514         Wait (EVT2, 0xFFFF)
1515
1516         Store ("++++++++ Sleep", Debug)
1517         Sleep (100)
1518
1519         Store ("++++++++ Stall", Debug)
1520         Stall (254)
1521
1522         Store ("++++++++ NoOperation", Debug)
1523         Noop
1524
1525         // Type 2 Opcodes
1526
1527         Store ("++++++++ Return from Method OBJ2", Debug)
1528         return (4)
1529     }
1530
1531
1532     Method (NUM1, 0)
1533     {
1534         /* ADD */
1535
1536         Store ("++++++++ Add (0x12345678, 0x11111111, Local0)", Debug)
1537         Add (0x12345678, 0x11111111, Local0)
1538
1539         Store ("++++++++ Store (Add (0x12345678, 0x11111111), Local1)", Debug)
1540         Store (Add (0x12345678, 0x11111111), Local1)
1541
1542         Store ("++++++++ Checking result from ADD", Debug)
1543         if (LNotEqual (Local0, Local1))
1544         {
1545             ERR_ (0)
1546         }
1547
1548
1549         /* SUBTRACT */
1550
1551         Store ("++++++++ Subtract (0x87654321, 0x11111111, Local4)", Debug)
1552         Subtract (0x87654321, 0x11111111, Local4)
1553
1554         Store ("++++++++ Store (Subtract (0x87654321, 0x11111111), Local5)", Debug)
1555         Store (Subtract (0x87654321, 0x11111111), Local5)
1556
1557         Store ("++++++++ Checking result from SUBTRACT", Debug)
1558         if (LNotEqual (Local4, Local5))
1559         {
1560             ERR_ (0)
1561         }
1562
1563
1564         /* MULTIPLY */
1565
1566         Store ("++++++++ Multiply (33, 10, Local6)", Debug)
1567         Multiply (33, 10, Local6)
1568
1569         Store ("++++++++ Store (Multiply (33, 10), Local7)", Debug)
1570         Store (Multiply (33, 10), Local7)
1571
1572
1573         Store ("++++++++ Checking result from MULTIPLY", Debug)
1574         if (LNotEqual (Local6, Local7))
1575         {
1576             ERR_ (0)
1577         }
1578
1579
1580         /* DIVIDE */
1581
1582         Store ("++++++++ Divide (100, 9, Local1, Local2)", Debug)
1583         Divide (100, 9, Local1, Local2)
1584
1585         Store ("++++++++ Store (Divide (100, 9), Local3)", Debug)
1586         Store (Divide (100, 9), Local3)
1587
1588         Store ("++++++++ Checking (quotient) result from DIVIDE", Debug)
1589         if (LNotEqual (Local2, Local3))
1590         {
1591             ERR_ (0)
1592         }
1593
1594
1595         /* INCREMENT */
1596
1597         Store ("++++++++ Increment (Local0)", Debug)
1598         Store (1, Local0)
1599         Store (2, Local1)
1600         Increment (Local0)
1601
1602         Store ("++++++++ Checking result from INCREMENT", Debug)
1603         if (LNotEqual (Local0, Local1))
1604         {
1605             ERR_ (0)
1606         }
1607
1608
1609         /* DECREMENT */
1610
1611         Store ("++++++++ Decrement (Local0)", Debug)
1612         Store (2, Local0)
1613         Store (1, Local1)
1614         Decrement (Local0)
1615
1616         Store ("++++++++ Checking result from DECREMENT", Debug)
1617         if (LNotEqual (Local0, Local1))
1618         {
1619             ERR_ (0)
1620         }
1621
1622
1623         /* TOBCD */
1624         /* FROMBCD */
1625
1626         Store ("++++++++ ToBCD (0x1234, Local5)", Debug)
1627         ToBCD (0x1234, Local5)
1628
1629         Store ("++++++++ FromBCD (Local5, Local6)", Debug)
1630         FromBCD (Local5, Local6)
1631
1632         Store ("++++++++ Return (Local6)", Debug)
1633         Return (Local6)
1634     }
1635
1636
1637     Method (CHEK)
1638     {
1639
1640         Store (3, Local0)
1641         Store (3, Debug)
1642         Store (Local0, Debug)
1643         Store (7, Local1)
1644
1645         Add (Local0, Local1)
1646         if (LNotEqual (Local0, 3))
1647         {
1648             ERR_ (2)
1649         }
1650         if (LNotEqual (Local1, 7))
1651         {
1652             ERR_ (2)
1653         }
1654
1655
1656         Add (Local0, Local1, Local2)
1657         if (LNotEqual (Local0, 3))
1658         {
1659             ERR_ (2)
1660         }
1661         if (LNotEqual (Local1, 7))
1662         {
1663             ERR_ (2)
1664         }
1665     }
1666
1667
1668     Method (RET1)
1669     {
1670         Store (3, Local0)
1671         Return (Local0)
1672     }
1673
1674     Method (RET2)
1675     {
1676         Return (RET1())
1677     }
1678
1679     Method (RETZ)
1680     {
1681         RET2 ()
1682     }
1683
1684
1685     Method (BITZ)
1686     {
1687         Store ("++++++++ FindSetLeftBit (0x00100100, Local0)", Debug)
1688         FindSetLeftBit (0x00100100, Local0)
1689         if (LNotEqual (Local0, 21))
1690         {
1691             ERR_ (1)
1692         }
1693
1694         Store ("++++++++ FindSetRightBit (0x00100100, Local1)", Debug)
1695         FindSetRightBit (0x00100100, Local1)
1696         if (LNotEqual (Local1, 9))
1697         {
1698             ERR_ (1)
1699         }
1700
1701         Store ("++++++++ And (0xF0F0F0F0, 0x11111111, Local2)", Debug)
1702         And (0xF0F0F0F0, 0x11111111, Local2)
1703         if (LNotEqual (Local2, 0x10101010))
1704         {
1705             ERR_ (1)
1706         }
1707
1708         Store ("++++++++ NAnd (0xF0F0F0F0, 0x11111111, Local3)", Debug)
1709         NAnd (0xF0F0F0F0, 0x11111111, Local3)
1710         if (LNotEqual (Local3, 0xEFEFEFEF))
1711         {
1712             ERR_ (1)
1713         }
1714
1715         Store ("++++++++ Or (0x11111111, 0x22222222, Local4)", Debug)
1716         Or (0x11111111, 0x22222222, Local4)
1717         if (LNotEqual (Local4, 0x33333333))
1718         {
1719             ERR_ (1)
1720         }
1721
1722         Store ("++++++++ NOr (0x11111111, 0x22222222, Local5)", Debug)
1723         NOr (0x11111111, 0x22222222, Local5)
1724         if (LNotEqual (Local5, 0xCCCCCCCC))
1725         {
1726             ERR_ (1)
1727         }
1728
1729         Store ("++++++++ XOr (0x11113333, 0x22222222, Local6)", Debug)
1730         XOr (0x11113333, 0x22222222, Local6)
1731         if (LNotEqual (Local6, 0x33331111))
1732         {
1733             ERR_ (1)
1734         }
1735
1736         Store ("++++++++ ShiftLeft (0x11112222, 2, Local7)", Debug)
1737         ShiftLeft (0x11112222, 2, Local7)
1738         if (LNotEqual (Local7, 0x44448888))
1739         {
1740             ERR_ (1)
1741         }
1742
1743         Store ("++++++++ ShiftRight (Local7, 2, Local7)", Debug)
1744         ShiftRight (Local7, 2, Local7)
1745         if (LNotEqual (Local7, 0x11112222))
1746         {
1747             ERR_ (1)
1748         }
1749
1750
1751         Store ("++++++++ Not (Local0, Local1)", Debug)
1752         Store (0x22224444, Local0)
1753         Not (Local0, Local1)
1754         if (LNotEqual (Local0, 0x22224444))
1755         {
1756             ERR_ (2)
1757         }
1758
1759         if (LNotEqual (Local1, 0xDDDDBBBB))
1760         {
1761             ERR_ (1)
1762         }
1763
1764         Return (Local7)
1765     }
1766
1767
1768     Method (LOGS)
1769     {
1770
1771         Store ("++++++++ Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)", Debug)
1772         Store (LAnd (0xFFFFFFFF, 0x11111111), Local0)
1773
1774         Store ("++++++++ Store (LEqual (0xFFFFFFFF, 0x11111111), Local)", Debug)
1775         Store (LEqual (0xFFFFFFFF, 0x11111111), Local1)
1776
1777         Store ("++++++++ Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)", Debug)
1778         Store (LGreater (0xFFFFFFFF, 0x11111111), Local2)
1779
1780         Store ("++++++++ Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)", Debug)
1781         Store (LGreaterEqual (0xFFFFFFFF, 0x11111111), Local3)
1782
1783         Store ("++++++++ Store (LLess (0xFFFFFFFF, 0x11111111), Local4)", Debug)
1784         Store (LLess (0xFFFFFFFF, 0x11111111), Local4)
1785
1786         Store ("++++++++ Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)", Debug)
1787         Store (LLessEqual (0xFFFFFFFF, 0x11111111), Local5)
1788
1789         Store ("++++++++ Store (LNot (0x31313131), Local6)", Debug)
1790         Store (0x00001111, Local6)
1791         Store (LNot (Local6), Local7)
1792         if (LNotEqual (Local6, 0x00001111))
1793         {
1794             ERR_ (2)
1795         }
1796
1797         if (LNotEqual (Local7, 0x0))
1798         {
1799             ERR_ (1)
1800         }
1801
1802
1803         Store ("++++++++ Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)", Debug)
1804         Store (LNotEqual (0xFFFFFFFF, 0x11111111), Local7)
1805
1806         Store ("++++++++ Lor (0x0, 0x1)", Debug)
1807         if (Lor (0x0, 0x1))
1808         {
1809             Store ("+_+_+_+_+ Lor (0x0, 0x1) returned TRUE", Debug)
1810         }
1811
1812         return (Local7)
1813     }
1814
1815
1816     Method (COND)
1817     {
1818         Store ("++++++++ Store (0x4, Local0)", Debug)
1819         Store (0x4, Local0)
1820
1821         Store ("++++++++ While (Local0)", Debug)
1822         While (Local0)
1823         {
1824             Store ("++++++++ Decrement (Local0)", Debug)
1825             Decrement (Local0)
1826         }
1827
1828
1829         Store ("++++++++ Store (0x3, Local6)", Debug)
1830         Store (0x3, Local6)
1831
1832         Store ("++++++++ While (Subtract (Local6, 1))", Debug)
1833         While (Subtract (Local6, 1))
1834         {
1835             Store ("++++++++ Decrement (Local6)", Debug)
1836             Decrement (Local6)
1837         }
1838
1839
1840         Store ("++++++++ [LVL1] If (LGreater (0x2, 0x1))", Debug)
1841         If (LGreater (0x2, 0x1))
1842         {
1843             Store ("++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))", Debug)
1844             If (LEqual (0x11111111, 0x22222222))
1845             {
1846                 Store ("++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE", Debug)
1847             }
1848
1849             else
1850             {
1851                 Store ("++++++++ [LVL3] If (LNot (0x0))", Debug)
1852                 If (LNot (0x0))
1853                 {
1854                     Store ("++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))", Debug)
1855                     If (LAnd (0xEEEEEEEE, 0x2))
1856                     {
1857                         Store ("++++++++ [LVL5] If (LLess (0x44444444, 0x3))", Debug)
1858                         If (LLess (0x44444444, 0x3))
1859                         {
1860                             Store ("++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE", Debug)
1861                         }
1862
1863                         else
1864                         {
1865                             Store ("++++++++ Exiting from nested IF/ELSE statements", Debug)
1866                         }
1867                     }
1868                 }
1869             }
1870         }
1871
1872
1873         Store ("++++++++ [LVL1] If (LGreater (0x2, 0x1))", Debug)
1874         If (LGreater (0x2, 0x1))
1875         {
1876             Store ("++++++++ [LVL2] If (LEqual (0x11111111, 0x22222222))", Debug)
1877             If (LEqual (0x11111111, 0x22222222))
1878             {
1879                 Store ("++++++++ ERROR: If (LEqual (0x11111111, 0x22222222)) returned TRUE", Debug)
1880             }
1881
1882             else
1883             {
1884                 Store ("++++++++ [LVL3] If (LNot (0x0))", Debug)
1885                 If (LNot (0x0))
1886                 {
1887                     Store ("++++++++ [LVL4] If (LAnd (0xEEEEEEEE, 0x2))", Debug)
1888                     If (LAnd (0xEEEEEEEE, 0x2))
1889                     {
1890                         Store ("++++++++ [LVL5] If (LLess (0x44444444, 0x3))", Debug)
1891                         If (LLess (0x44444444, 0x3))
1892                         {
1893                             Store ("++++++++ ERROR: If (LLess (0x44444444, 0x3)) returned TRUE", Debug)
1894                         }
1895
1896                         else
1897                         {
1898                             Store ("++++++++ Returning from nested IF/ELSE statements", Debug)
1899                             Return (Local6)
1900                         }
1901                     }
1902                 }
1903             }
1904         }
1905
1906     }
1907
1908
1909     Method (REFS,, Serialized)
1910     {
1911         Name (BBUF, Buffer() {0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7})
1912
1913         Name (NEST, Package ()
1914         {
1915             Package ()
1916             {
1917                 0x01, 0x02, 0x03, 0x04, 0x05, 0x06
1918             },
1919             Package ()
1920             {
1921                 0x11, 0x12, 0x12, 0x14, 0x15, 0x16
1922             }
1923         })
1924
1925     /* Parser thinks this is a method invocation!! */
1926
1927         Store (RefOf (MAIN), Local5)
1928
1929         // For this to work, ABCD must NOT exist.
1930
1931         Store (CondRefOf (ABCD, Local0), Local1)
1932         if (LNotEqual (Local1, 0))
1933         {
1934             ERR_ (2)
1935         }
1936
1937         Store (CondRefOf (BBUF, Local0), Local1)
1938         if (LNotEqual (Local1, Ones))
1939         {
1940             ERR_ (2)
1941         }
1942
1943         Store (DeRefOf (Index (BBUF, 3)), Local6)
1944         if (LNotEqual (Local6, 0xB3))
1945         {
1946             ERR_ (2)
1947         }
1948
1949         Store (DeRefOf (Index (DeRefOf (Index (NEST, 1)), 3)), Local0)
1950         if (LNotEqual (Local0, 0x14))
1951         {
1952             ERR_ (2)
1953         }
1954
1955
1956         Store (0x11223344, Local0)
1957         Store (RefOf (Local0), Local1)
1958
1959         Store (DerefOf (Local1), Local2)
1960         If (LNotEqual (Local2, 0x11223344))
1961         {
1962             ERR_ (2)
1963         }
1964
1965
1966     /* Parser thinks this is a method invocation!! */
1967
1968     //  RefOf (MAIN)
1969
1970
1971     //  RefOf (R___)
1972     //  RefOf (BBUF)
1973
1974     //  Store (RefOf (Local0), Local1)
1975
1976     //  CondRefOf (BBUF, Local2)
1977     //  CondRefOf (R___, Local3)
1978
1979     //  Store (DerefOf (Local1), Local4)
1980
1981     //  Return (Local4)
1982     }
1983
1984
1985     Method (INDX, 0, Serialized)
1986     {
1987         Name(STAT,Package(4){})
1988         Store(0x44443333,Index(STAT,0))
1989     }
1990
1991 //=================================================================
1992 //=================================================================
1993 //===================== iPCO TESTS ================================
1994 //=================================================================
1995 //=================================================================
1996 //
1997 //
1998 // test IfElseOp.asl
1999 //
2000 //  test for IfOp and ElseOp, including validation of object stack cleanup
2001 //
2002     Device (IFEL)
2003     {
2004         Name (DWRD, 1)
2005         Name (RSLT, 0)
2006
2007         //  IFNR control method executes IfOp branch with NO nested Return
2008         //  and no Else branch
2009         Method (IFNR)
2010         {
2011             Store (DWRD, RSLT)
2012             If (LEqual (DWRD, 1))
2013             {
2014                 Store (0, RSLT)
2015             }
2016         }   //  IFNR
2017
2018         //  NINR control method does not execute If branch and has no Else branch
2019         Method (NINR)
2020         {
2021             Store (0, RSLT)
2022             If (LNotEqual (DWRD, 1))
2023             {
2024                 Store (DWRD, RSLT)
2025             }
2026         }   //  NINR
2027
2028         //  IENR control method executes IfOp branch with NO nested Return
2029         Method (IENR)
2030         {
2031             If (LEqual (DWRD, 1))
2032             {
2033                 Store (0, RSLT)
2034             }
2035             Else
2036             {
2037                 Store (DWRD, RSLT)
2038             }
2039         }   //  IENR
2040
2041         //  ELNR control method executes ElseOp branch with NO nested Return
2042         Method (ELNR)
2043         {
2044             If (LNotEqual (DWRD, 1))
2045             {
2046                 Store (DWRD, RSLT)
2047             }
2048             Else
2049             {
2050                 Store (0, RSLT)
2051             }
2052         }   //  ELNR
2053
2054         //  IFRT control method executes IfOp branch with nested Return with
2055         //  no Else branch
2056         Method (IFRT)
2057
2058         {
2059             If (LEqual (DWRD, 1))
2060             {
2061                 Return (0)
2062             }
2063             Return (DWRD)
2064         }   //  IFRT
2065
2066         //  IERT control method executes IfOp branch with nested Return with
2067         //  Else branch
2068         Method (IERT)
2069         {
2070             If (LEqual (DWRD, 1))
2071             {
2072                 Return (0)
2073             }
2074             Else
2075             {
2076                 Return (DWRD)
2077             }
2078         }   //  IERT
2079
2080         //  ELRT control method executes ElseOp branch with nested Return
2081         Method (ELRT)
2082         {
2083             If (LNotEqual (DWRD, 1))
2084             {
2085                 Return (DWRD)
2086             }
2087             Else
2088             {
2089                 Return (0)
2090             }
2091         }   //  ELRT
2092
2093         Method (TEST)
2094         {
2095             Store ("++++++++ IfElseOp Test", Debug)
2096
2097             //  IfOp with NO return value
2098             IFNR()
2099             If (LNotEqual (RSLT, 0))
2100             {
2101                 Return (RSLT)
2102             }
2103
2104             //  IfOp with NO return value
2105             NINR()
2106             If (LNotEqual (RSLT, 0))
2107             {
2108                 Return (RSLT)
2109             }
2110
2111             //  IfOp with NO return value
2112             IENR()
2113             If (LNotEqual (RSLT, 0))
2114             {
2115                 Return (RSLT)
2116             }
2117
2118             //  ElseOp with NO return value
2119             ELNR()
2120             If (LNotEqual (RSLT, 0))
2121             {
2122                 Return (RSLT)
2123             }
2124
2125             //  IfOp with return value
2126             Store (IFRT, RSLT)
2127             If (LNotEqual (RSLT, 0))
2128             {
2129                 Return (RSLT)
2130             }
2131
2132             //  IfOp with return value
2133             Store (IERT, RSLT)
2134             If (LNotEqual (RSLT, 0))
2135             {
2136                 Return (RSLT)
2137             }
2138
2139             //  ElseOp with return value
2140             Store (ELRT, RSLT)
2141             If (LNotEqual (RSLT, 0))
2142             {
2143                 Return (RSLT)
2144             }
2145
2146             Return (0)
2147         }   //  TEST
2148     }   //  IFEL
2149
2150 //
2151 // test NoSave.asl
2152 //
2153 //
2154 //  Internal test cases to validate IfOp (Operator (,,)) where Operator
2155 //  target is ZeroOp to throw away the results.
2156 //  Includes internal test cases for logical operators with no destination
2157 //  operands.
2158 //
2159     Device (NOSV)
2160     {
2161         Method (TEST,, Serialized)
2162         {
2163             Store ("++++++++ NoSave Test", Debug)
2164
2165             Name (WRD, 0x1234)
2166
2167             //
2168             //  Begin test of nested operators without saving results
2169             //
2170
2171             //  Test If (And ()) with no save of And result
2172             If (And (3, 1, ))
2173             {
2174                 Store (1, WRD)  //  pass -- just do something
2175             }
2176             else
2177             {
2178                 Return (1)      //  fail
2179             }
2180
2181             //  Test If (And ()) with no save of And result
2182             If (And (4, 1, ))
2183             {
2184                 Return (2)      //  fail
2185             }
2186             else
2187             {
2188                 Store (2, WRD)  //  pass -- just do something
2189             }
2190
2191
2192             //  Test If (NAnd ()) with no save of NAnd result
2193             If (NAnd (3, 1, ))
2194             {
2195                 Store (3, WRD)  //  pass -- just do something
2196             }
2197             else
2198             {
2199                 Return (3)      //  fail
2200             }
2201
2202             //  Test If (NAnd ()) with no save of NAnd result
2203             If (NAnd (0xFFFFFFFF, 0xFFFFFFFF, ))
2204             {
2205                 Return (4)      // fail
2206             }
2207             else
2208             {
2209                 Store (4, WRD)  //  pass -- just do something
2210             }
2211
2212
2213             //  Test If (NOr ()) with no save of NOr result
2214             If (NOr (0, 1, ))
2215             {
2216                 Store (5, WRD)  //  pass -- just do something
2217             }
2218             else
2219             {
2220                 Return (5)      //  fail
2221             }
2222
2223             //  Test If (NOr ()) with no save of NOr result
2224             If (NOr (0xFFFFFFFE, 1, ))
2225             {
2226                 Return (6)      // fail
2227             }
2228             else
2229             {
2230                 Store (6, WRD)  //  pass -- just do something
2231             }
2232
2233
2234             //  Test If (Not ()) with no save of Not result
2235             If (Not (1, ))
2236             {
2237                 Store (7, WRD)  //  pass -- just do something
2238             }
2239             else
2240             {
2241                 Return (7)      //  fail
2242             }
2243
2244             //  Test If (Not ()) with no save of Not result
2245             If (Not (0xFFFFFFFF, ))
2246             {
2247                 Return (8)      // fail
2248             }
2249             else
2250             {
2251                 Store (8, WRD)  //  pass -- just do something
2252             }
2253
2254
2255             //  Test If (Or ()) with no save of Or result
2256             If (Or (3, 1, ))
2257             {
2258                 Store (9, WRD)  //  pass -- just do something
2259             }
2260             else
2261             {
2262                 Return (9)      //  fail
2263             }
2264
2265             //  Test If (Or ()) with no save of Or result
2266             If (Or (0, 0, ))
2267             {
2268                 Return (10)     //  fail
2269             }
2270             else
2271             {
2272                 Store (10, WRD) //  pass -- just do something
2273             }
2274
2275
2276             //  Test If (XOr ()) with no save of XOr result
2277             If (XOr (3, 1, ))
2278             {
2279                 Store (11, WRD) //  pass -- just do something
2280             }
2281             else
2282             {
2283                 Return (11)     // fail
2284             }
2285
2286             //  Test If (XOr ()) with no save of XOr result
2287             If (XOr (3, 3, ))
2288             {
2289                 Return (12)     // fail
2290             }
2291             else
2292             {
2293                 Store (12, WRD) //  pass -- just do something
2294             }
2295
2296
2297             //
2298             //  Begin test of logical operators with no destination operands
2299             //
2300
2301             //  Test If (LAnd ()) with no save of LAnd result
2302             If (LAnd (3, 3))
2303             {
2304                 Store (21, WRD) //  pass -- just do something
2305             }
2306             else
2307             {
2308                 Return (21)     // fail
2309             }
2310
2311             //  Test If (LAnd ()) with no save of LAnd result
2312             If (LAnd (3, 0))
2313             {
2314                 Return (22)     // fail
2315             }
2316             else
2317             {
2318                 Store (22, WRD) //  pass -- just do something
2319             }
2320
2321             //  Test If (LAnd ()) with no save of LAnd result
2322             If (LAnd (0, 3))
2323             {
2324                 Return (23)     //  fail
2325             }
2326             else
2327             {
2328                 Store (23, WRD) //  pass -- just do something
2329             }
2330
2331             //  Test If (LAnd ()) with no save of LAnd result
2332             If (LAnd (0, 0))
2333             {
2334                 Return (24)     //  fail
2335             }
2336             else
2337             {
2338                 Store (24, WRD) //  pass -- just do something
2339             }
2340
2341
2342             //  Test If (LEqual ()) with no save of LEqual result
2343             If (LEqual (3, 3))
2344             {
2345                 Store (31, WRD) //  pass -- just do something
2346             }
2347             else
2348             {
2349                 Return (31)     //  fail
2350             }
2351
2352             //  Test If (LEqual ()) with no save of LEqual result
2353             If (LEqual (1, 3))
2354             {
2355                 Return (32)     //  fail
2356             }
2357             else
2358             {
2359                 Store (32, WRD) //  pass -- just do something
2360             }
2361
2362
2363             //  Test If (LGreater ()) with no save of LGreater result
2364             If (LGreater (3, 1))
2365             {
2366                 Store (41, WRD) //  pass -- just do something
2367             }
2368             else
2369             {
2370                 Return (41)     //  fail
2371             }
2372
2373             //  Test If (LGreater ()) with no save of LGreater result
2374             If (LGreater (4, 4))
2375             {
2376                 Return (42)     //  fail
2377             }
2378             else
2379             {
2380                 Store (42, WRD) //  pass -- just do something
2381             }
2382
2383             //  Test If (LGreater ()) with no save of LGreater result
2384             If (LGreater (1, 4))
2385             {
2386                 Return (43)     //  fail
2387             }
2388             else
2389             {
2390                 Store (43, WRD) //  pass -- just do something
2391             }
2392
2393             //  Test If (LGreaterEqual ()) with no save of LGreaterEqual result
2394             If (LGreaterEqual (3, 1))
2395             {
2396                 Store (44, WRD) //  pass -- just do something
2397             }
2398             else
2399             {
2400                 Return (44)     //  fail
2401             }
2402
2403             //  Test If (LGreaterEqual ()) with no save of LGreaterEqual result
2404             If (LGreaterEqual (3, 3))
2405             {
2406                 Store (45, WRD) //  pass -- just do something
2407             }
2408             else
2409             {
2410                 Return (45)     //  fail
2411             }
2412
2413             //  Test If (LGreaterEqual ()) with no save of LGreaterEqual result
2414             If (LGreaterEqual (3, 4))
2415             {
2416                 Return (46)     //  fail
2417             }
2418             else
2419             {
2420                 Store (46, WRD) //  pass -- just do something
2421             }
2422
2423
2424             //  Test If (LLess ()) with no save of LLess result
2425             If (LLess (1, 3))
2426             {
2427                 Store (51, WRD) //  pass -- just do something
2428             }
2429             else
2430             {
2431                 Return (51)     //  fail
2432             }
2433
2434             //  Test If (LLess ()) with no save of LLess result
2435             If (LLess (2, 2))
2436             {
2437                 Return (52)     //  fail
2438             }
2439             else
2440             {
2441                 Store (52, WRD) //  pass -- just do something
2442             }
2443
2444             //  Test If (LLess ()) with no save of LLess result
2445             If (LLess (4, 2))
2446             {
2447                 Return (53)     //  fail
2448             }
2449             else
2450             {
2451                 Store (53, WRD) //  pass -- just do something
2452             }
2453
2454
2455             //  Test If (LLessEqual ()) with no save of LLessEqual result
2456             If (LLessEqual (1, 3))
2457             {
2458                 Store (54, WRD) //  pass -- just do something
2459             }
2460             else
2461             {
2462                 Return (54)     //  fail
2463             }
2464
2465             //  Test If (LLessEqual ()) with no save of LLessEqual result
2466             If (LLessEqual (2, 2))
2467             {
2468                 Store (55, WRD) //  pass -- just do something
2469             }
2470             else
2471             {
2472                 Return (55)     //  fail
2473             }
2474
2475             //  Test If (LLessEqual ()) with no save of LLessEqual result
2476             If (LLessEqual (4, 2))
2477             {
2478                 Return (56)     //  fail
2479             }
2480             else
2481             {
2482                 Store (56, WRD) //  pass -- just do something
2483             }
2484
2485
2486             //  Test If (LNot ()) with no save of LNot result
2487             If (LNot (0))
2488             {
2489                 Store (61, WRD) //  pass -- just do something
2490             }
2491             else
2492             {
2493                 Return (61)     //  fail
2494             }
2495
2496             //  Test If (LNot ()) with no save of LNot result
2497             If (LNot (1))
2498             {
2499                 Return (62)     //  fail
2500             }
2501             else
2502             {
2503                 Store (62, WRD) //  pass -- just do something
2504             }
2505
2506
2507             //  Test If (LNotEqual ()) with no save of LNotEqual result
2508             If (LNotEqual (3, 3))
2509             {
2510                 Return (63)     //  fail
2511             }
2512             else
2513             {
2514                 Store (63, WRD) //  pass -- just do something
2515             }
2516
2517             //  Test If (LNotEqual ()) with no save of LNotEqual result
2518             If (LNotEqual (1, 3))
2519             {
2520                 Store (64, WRD) //  pass -- just do something
2521             }
2522             else
2523             {
2524                 Return (64)     //  fail
2525             }
2526
2527
2528             //  Test If (LOr ()) with no save of LOr result
2529             If (LOr (3, 1))
2530             {
2531                 Store (71, WRD) //  pass -- just do something
2532             }
2533             else
2534             {
2535                 Return (71)     //  fail
2536             }
2537
2538             //  Test If (LOr ()) with no save of LOr result
2539             If (LOr (0, 1))
2540             {
2541                 Store (72, WRD) //  pass -- just do something
2542             }
2543             else
2544             {
2545                 Return (72)     //  fail
2546             }
2547
2548             //  Test If (LOr ()) with no save of LOr result
2549             If (LOr (3, 0))
2550             {
2551                 Store (73, WRD) //  pass -- just do something
2552             }
2553             else
2554             {
2555                 Return (73)     //  fail
2556             }
2557
2558             //  Test If (LOr ()) with no save of LOr result
2559             If (LOr (0, 0))
2560             {
2561                 Return (74)     //  fail
2562             }
2563             else
2564             {
2565                 Store (74, WRD) //  pass -- just do something
2566             }
2567
2568             Return (0)
2569         }   //  TEST
2570     }   //  NOSV
2571
2572
2573 //
2574 // test IndxFld.asl
2575 //
2576 //  IndexFld test
2577 //      This is just a subset of the many RegionOp/Index Field test cases.
2578 //      Tests index field element AccessAs macro.
2579 //
2580     Device (IDXF)
2581     {   //  Test device name
2582
2583         OperationRegion (SIO, SystemIO, 0x100, 2)
2584         Field (SIO, ByteAcc, NoLock, Preserve)
2585         {
2586             INDX,   8,
2587             DATA,   8
2588         }
2589         IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
2590         {
2591             AccessAs (ByteAcc, 0),
2592             IFE0,   8,
2593             IFE1,   8,
2594             IFE2,   8,
2595             IFE3,   8,
2596             IFE4,   8,
2597             IFE5,   8,
2598             IFE6,   8,
2599             IFE7,   8,
2600             IFE8,   8,
2601             IFE9,   8,
2602         }
2603
2604         Method (TEST)
2605         {
2606             Store ("++++++++ IndxFld Test", Debug)
2607
2608             Store (IFE0, Local0)
2609             Store (IFE1, Local1)
2610             Store (IFE2, Local2)
2611
2612             Return (0)
2613         }   //  TEST
2614     }   //  IDXF
2615
2616 //
2617 // test NestdLor.asl
2618 //
2619     Scope (\_SB)    //  System Bus
2620     {   //  _SB system bus
2621
2622         Name (ZER0, 0)
2623         Name (ZER1, 0)
2624         Name (ZER2, 0)
2625         Name (ONE0, 1)
2626
2627         Device (NSTL)
2628         {
2629             Method (TEST)
2630             {
2631                 Store ("++++++++ NestdLor Test", Debug)
2632
2633                 If (Lor (ZER0, Lor (ZER1, Lor (ZER2, ONE0))))
2634                 {   //  Indicate Pass
2635                     Store (0x00, Local0)
2636                 }
2637
2638                 Else
2639                 {   //  Indicate Fail
2640                     Store (0x01, Local0)
2641                 }
2642
2643                 Return (Local0)
2644             }   //  End Method TEST
2645         }   //  Device NSTL
2646     }   //  _SB system bus
2647
2648 //
2649 // test RetBuf.asl
2650 //
2651 //  Test ReturnOp(Buffer)
2652 //      This is required to support Control Method Batteries on
2653 //          Dell Latitude Laptops (e.g., CP1-A)
2654 //
2655     Device (RTBF)
2656     {
2657         Method (SUBR, 1)
2658         {
2659             Return (Arg0)
2660         }
2661
2662         Method (RBUF,, Serialized)
2663         {   //  RBUF: Return Buffer from local variable
2664             Name (ABUF, Buffer() {"ARBITRARY_BUFFER"})
2665
2666             //  store local buffer ABUF into Local0
2667             Store (ABUF, Local0)
2668
2669             //  save Local0 object type value into Local1
2670             Store (ObjectType (Local0), Local1)
2671
2672             //  validate Local0 is a Buffer
2673             If (LNotEqual (Local1, 3))  //  Buffer type is 3
2674             {
2675                 Return (1)      //  failure
2676             }
2677
2678             //  store value returned by control method SUBR into Local0
2679             Store (SUBR (ABUF), Local0)
2680
2681             //  save Local0 object type value into Local1
2682             Store (ObjectType (Local0), Local1)
2683
2684             //  validate Local0 is a Buffer
2685             If (LNotEqual (Local1, 3))  //  Buffer type is 3
2686             {
2687                 Return (2)      //  failure
2688             }
2689
2690             //  allocate buffer using Local1 as buffer size (run-time evaluation)
2691             Store (5, Local1)
2692             Name (BUFR, Buffer(Local1) {})
2693
2694             //  store value returned by control method SUBR into Local0
2695             Store (SUBR (BUFR), Local0)
2696
2697             //  save Local0 object type value into Local1
2698             Store (ObjectType (Local0), Local1)
2699
2700             //  validate Local0 is a Buffer
2701             If (LNotEqual (Local1, 3))  //  Buffer type is 3
2702             {
2703                 Return (3)      //  failure
2704             }
2705
2706             //  store BUFR Buffer into Local0
2707             Store (BUFR, Local0)
2708
2709             //  save Local0 object type value into Local1
2710             Store (ObjectType (Local0), Local1)
2711
2712             //  validate Local0 is a Buffer
2713             If (LNotEqual (Local1, 3))  //  Buffer type is 3
2714             {
2715                 Return (4)      //  failure
2716             }
2717
2718
2719             //  return Local0 Buffer
2720             Return (Local0)
2721         }   //  RBUF
2722
2723         Method (TEST)
2724         {
2725             Store ("++++++++ RetBuf Test", Debug)
2726
2727             //  store RBUF Buffer return value into Local0
2728             Store (RBUF, Local0)
2729
2730             //  save Local0 object type value into Local1
2731             Store (ObjectType (Local0), Local1)
2732
2733             //  validate Local0 is a Buffer
2734             If (LNotEqual (Local1, 3))  //  Buffer type is 3
2735             {
2736                 Return (10)     //  failure
2737             }
2738             Else
2739             {
2740                 Return (0)      //  success
2741             }
2742         }   //  TEST
2743     }   //  RTBF
2744
2745 //
2746 // test RetLVal.asl
2747 //
2748 //  Test ReturnOp(Lvalue)
2749 //      This is required to support _PSR on IBM ThinkPad 560D and
2750 //      _DCK on Toshiba Tecra 8000.
2751 //
2752
2753     Device (GPE2)
2754     {
2755         Method (_L03)
2756         {
2757             Store ("Method GPE2._L03 invoked", Debug)
2758             Return ()
2759         }
2760
2761         Method (_E05)
2762         {
2763             Store ("Method GPE2._E05 invoked", Debug)
2764             Return ()
2765         }
2766     }
2767
2768     Device (PRW2)
2769     {
2770         Name (_PRW, Package(2) {Package(2){\GPE2, 0x05}, 3})
2771     }
2772
2773
2774     Scope (\_GPE)
2775     {
2776         Name (ACST, 0xFF)
2777
2778         Method (_L08)
2779         {
2780             Store ("Method _GPE._L08 invoked", Debug)
2781             Return ()
2782         }
2783
2784         Method (_E09)
2785         {
2786             Store ("Method _GPE._E09 invoked", Debug)
2787             Return ()
2788         }
2789
2790         Method (_E11)
2791         {
2792             Store ("Method _GPE._E11 invoked", Debug)
2793             Notify (\PRW1, 2)
2794         }
2795
2796         Method (_L22)
2797         {
2798             Store ("Method _GPE._L22 invoked", Debug)
2799             Return ()
2800         }
2801
2802         Method (_L33)
2803         {
2804             Store ("Method _GPE._L33 invoked", Debug)
2805             Return ()
2806         }
2807
2808         Method (_E64)
2809         {
2810             Store ("Method _GPE._E64 invoked", Debug)
2811             Return ()
2812         }
2813
2814     }   //  _GPE
2815
2816     Device (PRW1)
2817     {
2818         Name (_PRW, Package(2) {0x11, 3})
2819     }
2820
2821     Device (PWRB)
2822     {
2823         Name (_HID, EISAID("PNP0C0C"))
2824         Name (_PRW, Package(2) {0x33, 3})
2825     }
2826
2827
2828     Scope (\_SB)    //  System Bus
2829     {   //  _SB system bus
2830
2831         Device (ACAD)
2832         {   //  ACAD:   AC adapter device
2833             Name (_HID, "ACPI0003") //  AC adapter device
2834
2835             Name (_PCL, Package () {\_SB})
2836
2837             OperationRegion (AREG, SystemIO, 0x0372, 2)
2838             Field (AREG, ByteAcc, NoLock, Preserve)
2839             {
2840                 AIDX,   8,
2841                 ADAT,   8
2842             }
2843             IndexField (AIDX, ADAT, ByteAcc, NoLock, Preserve)
2844             {
2845                      ,  1,  //  skips
2846                 ACIN,   1,
2847                      ,  2,  //  skips
2848                 CHAG,   1,
2849                      ,  3,  //  skips
2850                      ,  7,  //  skips
2851                 ABAT,   1,
2852             }   //  IndexField
2853
2854             Method (_PSR)
2855             {
2856                 Store (\_GPE.ACST, Local0)
2857                 Store (ACIN, Local1)
2858                 If (LNotEqual (\_GPE.ACST, Local1))
2859                 {
2860                     Store (Local1, \_GPE.ACST)
2861                     // This Notify is commented because it causes a
2862                     //  method error when running on a system without the
2863                     //  specific device.
2864                     // Notify (\_SB_.ACAD, 0)
2865                 }
2866                 Return (Local0)
2867             }   //  _PSR
2868
2869             Method (_STA)
2870             {
2871                 Return (0x0F)
2872             }
2873
2874             Method (_INI)
2875             {
2876                 Store (ACIN, \_GPE.ACST)
2877             }
2878         }   //  ACAD:   AC adapter device
2879
2880         //  test implicit return from control method
2881         Method (DIS_, 1)
2882         {
2883             Store (Arg0, Local0)
2884         }
2885
2886         Device (RTLV)
2887         {
2888             //  test implicit return inside nested if with explicit return of Lvalue
2889             Method (_DCK, 1)
2890             //  Arg0:   1 == dock, 0 == undock
2891             {
2892                 If (Arg0)
2893                 {   //  dock
2894                     Store (0x87, Local0)
2895
2896                     If (Local0)
2897                     {
2898                         DIS_ (0x23)
2899                         Return (1)
2900                     }
2901
2902                     Return (0)
2903                 }   //  dock
2904                 Else
2905                 {   //  undock
2906                     Store (Arg0, Local0)
2907
2908                     If (Local0)
2909                     {
2910                         DIS_ (0x23)
2911                         Return (1)
2912                     }
2913
2914                     Return (0)
2915                 }   //  undock
2916             }   //  _DCK control method
2917
2918             Method (TEST)
2919             {
2920                 Store ("++++++++ RetLVal Test", Debug)
2921
2922                 //  store _PSR return value into Local0
2923                 Store (\_SB_.ACAD._PSR, Local0)
2924
2925                 //  save Local0 object type value into Local1
2926                 Store (ObjectType (Local0), Local1)
2927
2928                 //  validate Local0 is a Number
2929                 If (LNotEqual (Local1, 1))  //  Number/Integer type is 1
2930                 {
2931                     Return (1)      //  failure
2932                 }
2933
2934                 //  test implicit return inside nested if with explicit return of Lvalue
2935                 Store (_DCK (1), Local2)
2936
2937                 //  save Local2 object type value into Local3
2938                 Store (ObjectType (Local2), Local3)
2939
2940                 //  validate Local2 is a Number
2941                 If (LNotEqual (Local3, 1))  //  Number/Integer type is 1
2942                 {
2943                     Return (2)      //  failure
2944                 }
2945
2946                 If (LNotEqual (Local2, 1))
2947                 {
2948                     Return (3)      //  failure
2949                 }
2950
2951                 Return (0)  //  success
2952             }   //  TEST
2953         }   //  RTLV
2954     }   //  _SB system bus
2955
2956 //
2957 // test RetPkg.asl
2958 //
2959 //  Test ReturnOp(Package)
2960 //      This is required to support _PRT on Dell Optiplex Workstations (e.g. GX1)
2961 //
2962
2963     Scope (\_SB)    //  System Bus
2964     {   //  _SB system bus
2965         Device(LNKA)
2966         {
2967             Name (_HID, EISAID("PNP0C0F"))  //  PCI interrupt link
2968             Name (_UID, 1)
2969         }
2970         Device(LNKB)
2971         {
2972             Name (_HID, EISAID("PNP0C0F"))  //  PCI interrupt link
2973             Name (_UID, 2)
2974         }
2975         Device(LNKC)
2976         {
2977             Name (_HID, EISAID("PNP0C0F"))  //  PCI interrupt link
2978             Name (_UID, 3)
2979         }
2980         Device(LNKD)
2981         {
2982             Name (_HID, EISAID("PNP0C0F"))  //  PCI interrupt link
2983             Name (_UID, 4)
2984         }
2985
2986         Device (PCI1)
2987         {   //  PCI1:   Root PCI Bus
2988             Name (_HID, "PNP0A03")  //  Need _HID for root device (String format)
2989             Name (_ADR,0x00000000)
2990             Name (_CRS,0)
2991
2992             Name (_PRT, Package ()
2993             {
2994                 Package () {0x0004ffff, 0, LNKA, 0},            //  Slot 1, INTA
2995                 Package () {0x0004ffff, 1, LNKB, 0},            //  Slot 1, INTB
2996                 Package () {0x0004ffff, 2, LNKC, 0},            //  Slot 1, INTC
2997                 Package () {0x0004ffff, 3, LNKD, 0},            //  Slot 1, INTD
2998                 Package () {0x0005ffff, 0, \_SB_.LNKB, 0},  //  Slot 2, INTA
2999                 Package () {0x0005ffff, 1, \_SB_.LNKC, 0},  //  Slot 2, INTB
3000                 Package () {0x0005ffff, 2, \_SB_.LNKD, 0},  //  Slot 2, INTC
3001                 Package () {0x0006ffff, 3, \_SB_.LNKA, 0},  //  Slot 2, INTD
3002                 Package () {0x0006ffff, 0, LNKC, 0},            //  Slot 3, INTA
3003                 Package () {0x0006ffff, 1, LNKD, 0},            //  Slot 3, INTB
3004                 Package () {0x0006ffff, 2, LNKA, 0},            //  Slot 3, INTC
3005                 Package () {0x0006ffff, 3, LNKB, 0},            //  Slot 3, INTD
3006             })
3007
3008             Device (PX40)
3009             {   // Map f0 space, Start PX40
3010                 Name (_ADR,0x00070000)  //  Address+function.
3011             }
3012         }   //  PCI0:   Root PCI Bus
3013
3014         Device (RETP)
3015         {
3016             Method (RPKG)
3017             {   //  RPKG: Return Package from local variable
3018
3019                 //  store _PRT package into Local0
3020                 Store (\_SB_.PCI1._PRT, Local0)
3021
3022                 //  return Local0 Package
3023                 Return (Local0)
3024             }   //  RPKG
3025
3026             Method (TEST)
3027             {
3028                 Store ("++++++++ RetPkg Test", Debug)
3029
3030                 //  store RPKG package return value into Local0
3031                 Store (RPKG, Local0)
3032
3033                 //  save Local0 object type value into Local1
3034                 Store (ObjectType (Local0), Local1)
3035
3036                 //  validate Local0 is a Package
3037                 If (LNotEqual (Local1, 4))  //  Package type is 4
3038                     {   Return (1)  }   //  failure
3039                 Else
3040                     {   Return (0)  }   //  success
3041             }   //  TEST
3042         }   //  RETP
3043     } // _SB_
3044
3045 //
3046 // test WhileRet.asl
3047 //
3048 //  WhileRet.asl tests a ReturnOp nested in a IfOp nested in a WhileOp.
3049 //
3050     Device (WHLR)
3051     {
3052         Name (LCNT, 0)
3053         Method (WIR)
3054         {   //  WIR:    control method that returns inside of IfOp inside of WhileOp
3055             While (LLess (LCNT, 4))
3056             {
3057                     If (LEqual (LCNT, 2))
3058                     {
3059                         Return (0)
3060                     }
3061
3062                 Increment (LCNT)
3063             }
3064
3065             Return (LCNT)
3066         }   //  WIR:    control method that returns inside of IfOp inside of WhileOp
3067
3068         Method (TEST)
3069         {
3070             Store ("++++++++ WhileRet Test", Debug)
3071
3072             Store (WIR, Local0)
3073
3074             Return (Local0)
3075         }   //  TEST
3076     }   //  WHLR
3077
3078 //
3079 // test AndOrOp.asl
3080 //
3081 //This code tests the bitwise AndOp and OrOp Operator terms
3082 //
3083 //Syntax of Andop term
3084 //And - Bitwise And
3085 //AndTerm   := And(
3086 //  Source1,    //TermArg=>Integer
3087 //  Source2,    //TermArg=>Integer
3088 //  Result  //Nothing | SuperName
3089 //) => Integer
3090 //Source1 and Source2 are evaluated as integer data types,
3091 // a bit-wise AND is performed, and the result is optionally
3092 //stored into Result.
3093 //
3094 //
3095 //Syntax of OrOp
3096 //Or - Bit-wise Or
3097 //OrTerm    := Or(
3098 //  Source1,    //TermArg=>Integer
3099 //  Source2 //TermArg=>Integer
3100 //  Result  //Nothing | SuperName
3101 //) => Integer
3102 //Source1 and Source2 are evaluated as integer data types,
3103 // a bit-wide OR is performed, and the result is optionally
3104 //stored in Result
3105 //
3106     Device (ANDO)
3107     {
3108         OperationRegion (TMEM, SystemMemory, 0xC4, 0x02)
3109         Field (TMEM, ByteAcc, NoLock, Preserve)
3110         {
3111                 ,   3,
3112             TOUD,   13
3113         }
3114
3115         //Create System Memory Operation Region and field overlays
3116         OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
3117         Field (RAM, AnyAcc, NoLock, Preserve)
3118         {
3119             SMDW,   32, //  32-bit DWORD
3120             SMWD,   16, //  16-bit WORD
3121             SMBY,   8,  //  8-bit BYTE
3122         }// Field(RAM)
3123
3124
3125         //And with Byte Data
3126         Name (BYT1, 0xff)
3127         Name (BYT2, 0xff)
3128         Name (BRSL, 0x00)
3129
3130         //And with Word Data
3131         Name (WRD1, 0xffff)
3132         Name (WRD2, 0xffff)
3133         Name (WRSL, 0x0000)
3134
3135         //And with DWord Data
3136         Name (DWD1, 0xffffffff)
3137         Name (DWD2, 0xffffffff)
3138         Name (DRSL, 0x00000000)
3139
3140         Method (ANDP)
3141         {
3142             //Check with 1 And 1 on byte data
3143             And(BYT1, BYT2, BRSL)
3144             if(LNotEqual(BRSL,0xff))
3145             {Return(1)}
3146
3147             //Check with 1 And 1 on Word data
3148             And(WRD1, WRD2, WRSL)
3149             if(LNotEqual(WRSL,0xffff))
3150             {
3151                 Return (1)      //  failure
3152             }
3153
3154             //Check with 1 And 1 Dword
3155             And(DWD1, DWD2, DRSL)
3156             if(LNotEqual(DRSL,0xffffffff))
3157             {
3158                 Return (1)      //  failure
3159             }
3160
3161             //Check with 0 And 0 on byte data
3162             Store(0x00,BYT1)
3163             Store(0x00,BYT2)
3164             Store(0x00,BRSL)
3165             And(BYT1, BYT2, BRSL)
3166             if(LNotEqual(BRSL,0x00))
3167             {
3168                 Return (1)      //  failure
3169             }
3170
3171             //Check with 0 And 0 on Word data
3172             Store (0x0000,WRD1)
3173             Store (0x0000,WRD2)
3174             Store (0x0000,WRSL)
3175             And(WRD1, WRD2, WRSL)
3176             if(LNotEqual(WRSL,0x0000))
3177             {
3178                 Return (1)      //  failure
3179             }
3180
3181             //Check with 0 And 0 Dword
3182             Store (0x00000000,DWD1)
3183             Store (0x00000000,DWD2)
3184             Store (0x00000000,DRSL)
3185             And(DWD1, DWD2, DRSL)
3186             if(LNotEqual(DRSL,0x00000000))
3187             {
3188                 Return (1)      //  failure
3189             }
3190
3191
3192             //Check with 1 And 0 on byte data
3193             Store(0x55,BYT1)
3194             Store(0xAA,BYT2)
3195             Store(0x00,BRSL)
3196             And(BYT1, BYT2, BRSL)
3197             if(LNotEqual(BRSL,0x00))
3198             {
3199                 Return (1)      //  failure
3200             }
3201
3202             //Check with 1 And 0 on Word data
3203             Store (0x5555,WRD1)
3204             Store (0xAAAA,WRD2)
3205             Store (0x0000,WRSL)
3206             And(WRD1, WRD2, WRSL)
3207             if(LNotEqual(WRSL,0x0000))
3208             {
3209                 Return (1)      //  failure
3210             }
3211
3212             //Check with 1 And 0 on Dword
3213             Store (0x55555555,DWD1)
3214             Store (0xAAAAAAAA,DWD2)
3215             Store (0x00000000,DRSL)
3216             And(DWD1, DWD2, DRSL)
3217             if(LNotEqual(DRSL,0x00000000))
3218             {
3219                 Return (1)      //  failure
3220             }
3221
3222             Store (0x1FFF, TOUD)
3223             Store (TOUD, Local0)
3224             if(LNotEqual(Local0,0x1FFF))
3225             {
3226                 Return (1)      //  failure
3227             }
3228
3229             //TBD- Do We need to check for system memory data also for each test case ??
3230
3231             Return(0)
3232
3233         }//ANDP
3234
3235         Method (OROP)
3236         {
3237
3238             //Check with 1 Ored with 1 on byte data
3239             Store(0xff,BYT1)
3240             Store(0xff,BYT2)
3241             Store(0x00,BRSL)
3242             Or(BYT1, BYT2, BRSL)
3243             if(LNotEqual(BRSL,0xff))
3244             {
3245                 Return (1)      //  failure
3246             }
3247
3248
3249             //Check with 1 Ored with 1 on Word data
3250             Store(0xffff,WRD1)
3251             Store(0xffff,WRD2)
3252             Store(0x0000,WRSL)
3253             Or(WRD1, WRD2, WRSL)
3254             if(LNotEqual(WRSL,0xffff))
3255             {
3256                 Return (1)      //  failure
3257             }
3258
3259             //Check with 1 Ored with 1 on Dword data
3260             Store(0xffffffff,DWD1)
3261             Store(0xffffffff,DWD2)
3262             Store(0x00000000,DRSL)
3263             Or(DWD1, DWD2, DRSL)
3264             if(LNotEqual(DRSL,0xffffffff))
3265             {
3266                 Return (1)      //  failure
3267             }
3268
3269             //Check with 0 Ored with 0 on byte data
3270             Store(0x00,BYT1)
3271             Store(0x00,BYT2)
3272             Store(0x00,BRSL)
3273             Or(BYT1, BYT2, BRSL)
3274             if(LNotEqual(BRSL,0x00))
3275             {
3276                 Return (1)      //  failure
3277             }
3278
3279             //Check with 0 Ored with 0 on Word data
3280             Store (0x0000,WRD1)
3281             Store (0x0000,WRD2)
3282             Store (0x0000,WRSL)
3283             Or(WRD1, WRD2, WRSL)
3284             if(LNotEqual(WRSL,0x0000))
3285             {
3286                 Return (1)      //  failure
3287             }
3288
3289             //Check with 0 Ored with  0 Dword data
3290             Store (0x00000000,DWD1)
3291             Store (0x00000000,DWD2)
3292             Store (0x00000000,DRSL)
3293             Or(DWD1, DWD2, DRSL)
3294             if(LNotEqual(DRSL,0x00000000))
3295             {
3296                 Return (1)      //  failure
3297             }
3298
3299
3300             //Check with 1 Ored with 0 on byte data
3301             Store(0x55,BYT1)
3302             Store(0xAA,BYT2)
3303             Store(0x00,BRSL)
3304             Or(BYT1, BYT2, BRSL)
3305             if(LNotEqual(BRSL,0xff))
3306             {
3307                 Return (1)      //  failure
3308             }
3309
3310             //Check with 1 Ored with 0 on Word data
3311             Store (0x5555,WRD1)
3312             Store (0xAAAA,WRD2)
3313             Store (0x0000,WRSL)
3314             Or(WRD1, WRD2, WRSL)
3315             if(LNotEqual(WRSL,0xffff))
3316             {
3317                 Return (1)      //  failure
3318             }
3319
3320             //Check with 1 Ored with 0 on Dword data
3321             Store (0x55555555,DWD1)
3322             Store (0xAAAAAAAA,DWD2)
3323             Store (0x00000000,DRSL)
3324             Or(DWD1, DWD2, DRSL)
3325             if(LNotEqual(DRSL,0xffffffff))
3326             {
3327                 Return (1)      //  failure
3328             }
3329
3330             //TBD - Do We need to check for system memory data also for each test case ??
3331
3332             Return(0)
3333
3334         }//OROP
3335
3336         Method(TEST,, Serialized)
3337         {
3338             Store ("++++++++ AndOrOp Test", Debug)
3339
3340             Name(RSLT,1)
3341             //Call Andop method
3342             Store(ANDP,RSLT)
3343             if(LEqual(RSLT,1))
3344             {
3345                 Return (RSLT)
3346             }
3347
3348             //Call OrOp Method
3349             Store(OROP,RSLT)
3350             if(LEqual(RSLT,1))
3351             {
3352                 Return(RSLT)
3353             }
3354
3355             //
3356             // Return original conditions to allow iterative execution
3357             //
3358             Store(0xff,BYT1)
3359             Store(0xff,BYT2)
3360             Store(0x00,BRSL)
3361             Store (0xffff,WRD1)
3362             Store (0xffff,WRD2)
3363             Store (0x0000,WRSL)
3364             Store (0xffffffff,DWD1)
3365             Store (0xffffffff,DWD2)
3366             Store (0x00000000,DRSL)
3367
3368             Return(0)
3369         }   //TEST
3370     }   //ANDO
3371
3372 //
3373 // test BreakPnt.asl
3374 //
3375 // This code tests the BreakPoint opcode term. The syntax of BreakPoint Term is
3376 // BreakPointTerm    := BreakPoint
3377 // Used for debugging, the Breakpoint opcode stops the execution and enters the AML debugger.
3378 // In the non-debug version of the interpreter, BreakPoint is equivalent to Noop.
3379 //
3380     Device (BRKP)
3381     {
3382         Name(CNT0,0)
3383
3384         Method (BK1)
3385         {
3386             BreakPoint
3387             Return(0)
3388         }
3389
3390         Method (TEST)
3391         {
3392             Store ("++++++++ BreakPnt Test", Debug)
3393
3394             Store(0,CNT0)
3395
3396             //Check BreakPoint statement
3397             While(LLess(CNT0,10))
3398             {
3399                 Increment(CNT0)
3400             }
3401
3402             //Check the BreakPoint statement
3403             If(LEqual(CNT0,10))
3404             {
3405     //            BreakPoint
3406                 Return(0)
3407             }
3408
3409             //failed
3410             Return(1)
3411         }
3412     }
3413
3414 //
3415 // test AddSubOp.asl
3416 //
3417     Device (ADSU)
3418     {
3419         //  create System Memory Operation Region and field overlays
3420         OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
3421         Field (RAM, AnyAcc, NoLock, Preserve)
3422         {
3423             SMDW,   32, //  32-bit DWORD
3424             SMWD,   16, //  16-bit WORD
3425             SMBY,   8,  //  8-bit BYTE
3426         }   //  Field(RAM)
3427
3428         Method (TEST,, Serialized)
3429         {
3430             Store ("++++++++ AddSubOp Test", Debug)
3431
3432             Name (DWRD, 0x12345678)
3433             Name (WRD, 0x1234)
3434             Name (BYT, 0x12)
3435
3436             //  Test AddOp with DWORD data
3437             Store (0x12345678, DWRD)
3438             Add (DWRD, 7, DWRD)
3439             If (LNotEqual (DWRD, 0x1234567F))
3440                 {   Return (DWRD)   }
3441
3442             //  Test AddOp with WORD data
3443             Add (WRD, 5, WRD)
3444             If (LNotEqual (WRD, 0x1239))
3445                 {   Return (WRD)    }
3446
3447             //  Test AddOp with BYTE data
3448             Add (BYT, 3, BYT)
3449             If (LNotEqual (BYT, 0x15))
3450                 {   Return (BYT)    }
3451
3452             //  Test SubtractOp with DWORD data
3453             Subtract (DWRD, 7, DWRD)
3454             If (LNotEqual (DWRD, 0x12345678))
3455                 {   Return (DWRD)   }
3456
3457             //  Test SubtractOp with WORD data
3458             Subtract (WRD, 3, WRD)
3459             If (LNotEqual (WRD, 0x1236))
3460                 {   Return (WRD)    }
3461
3462             //  Test SubtractOp with BYTE data
3463             Subtract (BYT, 3, BYT)
3464             If (LNotEqual (BYT, 0x12))
3465                 {   Return (BYT)    }
3466
3467
3468             //  test AddOp with DWORD SystemMemory OpRegion
3469             Store (0x01234567, SMDW)
3470             Add (SMDW, 8, SMDW)
3471             If (LNotEqual (SMDW, 0x0123456F))
3472                 {   Return (SMDW)   }
3473
3474             //  test SubtractOp with DWORD SystemMemory OpRegion
3475             Subtract (SMDW, 7, SMDW)
3476             If (LNotEqual (SMDW, 0x01234568))
3477                 {   Return (SMDW)   }
3478
3479
3480             //  test AddOp with WORD SystemMemory OpRegion
3481             Store (0x0123, SMWD)
3482             Add (SMWD, 6, SMWD)
3483             If (LNotEqual (SMWD, 0x0129))
3484                 {   Return (SMWD)   }
3485
3486             //  test SubtractOp with WORD SystemMemory OpRegion
3487             Subtract (SMWD, 5, SMWD)
3488             If (LNotEqual (SMWD, 0x0124))
3489                 {   Return (SMWD)   }
3490
3491
3492             //  test AddOp with BYTE SystemMemory OpRegion
3493             Store (0x01, SMBY)
3494             Add (SMBY, 4, SMBY)
3495             If (LNotEqual (SMBY, 0x05))
3496                 {   Return (SMBY)   }
3497
3498             //  test SubtractOp with BYTE SystemMemory OpRegion
3499             Subtract (SMBY, 3, SMBY)
3500             If (LNotEqual (SMBY, 0x02))
3501                 {   Return (SMBY)   }
3502
3503             Return (0)
3504         }   //  TEST
3505     }   //  ADSU
3506
3507 //
3508 // test IncDecOp.asl
3509 //
3510     Device (INDC)
3511     {
3512         //  create System Memory Operation Region and field overlays
3513         OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
3514         Field (RAM, AnyAcc, NoLock, Preserve)
3515         {
3516             SMDW,   32, //  32-bit DWORD
3517             SMWD,   16, //  16-bit WORD
3518             SMBY,   8,  //  8-bit BYTE
3519         }   //  Field(RAM)
3520
3521         Method (TEST,, Serialized)
3522         {
3523             Store ("++++++++ IncDecOp Test", Debug)
3524
3525             Name (DWRD, 0x12345678)
3526             Name (WRD, 0x1234)
3527             Name (BYT, 0x12)
3528
3529             //  Test IncrementOp with DWORD data
3530             Store (0x12345678, DWRD)
3531             Increment (DWRD)
3532             If (LNotEqual (DWRD, 0x12345679))
3533                 {   Return (DWRD)   }
3534
3535             //  Test IncrementOp with WORD data
3536             Increment (WRD)
3537             If (LNotEqual (WRD, 0x1235))
3538                 {   Return (WRD)    }
3539
3540             //  Test IncrementOp with BYTE data
3541             Increment (BYT)
3542             If (LNotEqual (BYT, 0x13))
3543                 {   Return (BYT)    }
3544
3545             //  Test DecrementOp with DWORD data
3546             Decrement (DWRD)
3547             If (LNotEqual (DWRD, 0x12345678))
3548                 {   Return (DWRD)   }
3549
3550             //  Test DecrementOp with WORD data
3551             Decrement (WRD)
3552             If (LNotEqual (WRD, 0x1234))
3553                 {   Return (WRD)    }
3554
3555             //  Test DecrementOp with BYTE data
3556             Decrement (BYT)
3557             If (LNotEqual (BYT, 0x12))
3558                 {   Return (BYT)    }
3559
3560
3561             //  test IncrementOp with DWORD SystemMemory OpRegion
3562             Store (0x01234567, SMDW)
3563             Increment (SMDW)
3564             If (LNotEqual (SMDW, 0x01234568))
3565                 {   Return (SMDW)   }
3566
3567             //  test DecrementOp with DWORD SystemMemory OpRegion
3568             Decrement (SMDW)
3569             If (LNotEqual (SMDW, 0x01234567))
3570                 {   Return (SMDW)   }
3571
3572
3573             //  test IncrementOp with WORD SystemMemory OpRegion
3574             Store (0x0123, SMWD)
3575             Increment (SMWD)
3576             If (LNotEqual (SMWD, 0x0124))
3577                 {   Return (SMWD)   }
3578
3579             //  test DecrementOp with WORD SystemMemory OpRegion
3580             Decrement (SMWD)
3581             If (LNotEqual (SMWD, 0x0123))
3582                 {   Return (SMWD)   }
3583
3584
3585             //  test IncrementOp with BYTE SystemMemory OpRegion
3586             Store (0x01, SMBY)
3587             Increment (SMBY)
3588             If (LNotEqual (SMBY, 0x02))
3589                 {   Return (SMBY)   }
3590
3591             //  test DecrementOp with BYTE SystemMemory OpRegion
3592             Decrement (SMBY)
3593             If (LNotEqual (SMBY, 0x01))
3594                 {   Return (SMBY)   }
3595
3596             Return (0)
3597         }   //  TEST
3598     }   //  INDC
3599
3600 //
3601 // test LOps.asl
3602 //
3603 //This source tests all the logical operators. Logical operators in ASL are as follows.
3604 //LAnd, LEqual, LGreater, LLess, LNot, LNotEqual, LOr.
3605 // Success will return 0 and failure will return a non zero number. Check the source code for
3606 // non zero number to find where the test failed
3607
3608     Device (LOPS)
3609     {
3610         //Create System Memory Operation Region and field overlays
3611         OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
3612         Field (RAM, AnyAcc, NoLock, Preserve)
3613         {
3614             SMDW,   32, //  32-bit DWORD
3615             SMWD,   16, //  16-bit WORD
3616             SMBY,   8,  //  8-bit BYTE
3617         }// Field(RAM)
3618
3619         //And with Byte Data
3620         Name (BYT1, 0xff)
3621         Name (BYT2, 0xff)
3622         Name (BRSL, 0x00)
3623
3624         //And with Word Data
3625         Name (WRD1, 0xffff)
3626         Name (WRD2, 0xffff)
3627         Name (WRSL, 0x0000)
3628
3629         //And with DWord Data
3630         Name (DWD1, 0xffffffff)
3631         Name (DWD2, 0xffffffff)
3632         Name (DRSL, 0x00000000)
3633
3634         Name(RSLT,1)
3635
3636         Method (ANDL,2) // Test Logical And
3637         {
3638             //test with the arguments passed
3639             if(LEqual(Arg0,Arg1))
3640             { Store(LAnd(Arg0,Arg1),RSLT)
3641                 if(LNotEqual(Ones,RSLT))
3642                 {Return(11)}
3643             }
3644
3645             //test with he locals
3646             Store(Arg0,Local0)
3647             Store(Arg1,Local1)
3648
3649             if(LEqual(Local0,Local1))
3650             {
3651                 Store(LAnd(Local0,Local1),RSLT)
3652                 if(LNotEqual(Ones,RSLT))
3653                     {Return(12)}
3654             }
3655
3656             //test with BYTE data
3657             if(LEqual(BYT1,BYT2))
3658             { Store(LAnd(BYT1,BYT2),BRSL)
3659                 if(LNotEqual(Ones,BRSL))
3660                 {Return(13)}
3661             }
3662
3663             //test with WORD data
3664             if(LEqual(WRD1,WRD2))
3665             { Store(LAnd(WRD1,WRD2),WRSL)
3666                 if(LNotEqual(Ones,WRSL))
3667                 {Return(14)}
3668             }
3669
3670             //test with DWORD data
3671             if(LEqual(DWD1,DWD2))
3672             { Store(LAnd(DWD1,DWD2),DRSL)
3673                 if(LNotEqual(Ones,DRSL))
3674                 {Return(15)}
3675             }
3676
3677             //Test for system memory data for each test case.
3678
3679                 Store(0xff,BYT1)
3680                 Store(0xff,SMBY)
3681                 Store(0x00,BRSL)
3682
3683             //test with BYTE system memory data
3684             if(LEqual(BYT1,SMBY))
3685             { Store(LAnd(BYT1,SMBY),BRSL)
3686                 if(LNotEqual(Ones,BRSL))
3687                 {Return(16)}
3688             }
3689
3690             Store (0xffff,WRD1)
3691             Store(0xffff,SMWD)
3692             Store(0x0000,WRSL)
3693             //test with WORD system memory data
3694             if(LEqual(WRD1,SMWD))
3695             { Store(LAnd(WRD1,SMWD),WRSL)
3696                 if(LNotEqual(Ones,WRSL))
3697                 {Return(17)}
3698             }
3699
3700             Store(0x000000,DRSL)
3701             Store (0xffffff,DWD1)
3702             Store(0xffffff,SMDW)
3703
3704             //test with DWORD system memory data
3705             if(LEqual(DWD1,SMDW))
3706             { Store(LAnd(DWD1,SMDW),DRSL)
3707                 if(LNotEqual(Ones,DRSL))
3708                 {Return(18)}
3709             }
3710
3711             Return(0)
3712
3713         }//ANDL
3714
3715         //Test the LOr Operator
3716
3717         Method (ORL_,2)
3718         {//ORL_
3719
3720             //test with the arguments passed
3721             if(LEqual(Arg0,Arg1))
3722             {
3723                 Store(LOr(Arg0,Arg1),RSLT)
3724                 if(LNotEqual(Ones,RSLT))
3725                 {
3726                     Return(21)
3727                 }
3728             }
3729
3730             //test with he locals
3731             Store(Arg0,Local0)
3732             Store(Arg1,Local1)
3733
3734             if(LEqual(Local0,Local1))
3735             {
3736                 Store(LOr(Local0,Local1),RSLT)
3737                 if(LNotEqual(Ones,RSLT))
3738                     {Return(22)}
3739             }
3740
3741             //Check with 1 LOred with 0 on byte data
3742             Store(0xff,BYT1)
3743             Store(0x00,BYT2)
3744             Store(0x00,BRSL)
3745
3746             if(LNotEqual(BYT1, BYT2))
3747             {
3748                 Store(LOr(BYT1, BYT2), BRSL)
3749                 if(LNotEqual(Ones,BRSL))
3750                 {Return(23)}
3751             }
3752
3753             //Check with 1 LOred with 0 on WORD data
3754             Store(0xffff,WRD1)
3755             Store(0x0000,WRD2)
3756             Store(0x0000,WRSL)
3757
3758             if(LNotEqual(WRD1, WRD2))
3759             {
3760                 Store(LOr(WRD1, WRD2), WRSL)
3761                 if(LNotEqual(Ones,WRSL))
3762                 {Return(24)}
3763             }
3764
3765             //Check with 1 LOred with 0 on DWORD data
3766             Store(0xffffffff,DWD1)
3767             Store(0x00000000,DWD2)
3768             Store(0x00000000,DRSL)
3769
3770             if(LNotEqual(DWD1, DWD2))
3771             {
3772                 Store(LOr(DWD1, DWD2), DRSL)
3773                 if(LNotEqual(Ones,DRSL))
3774                 {Return(25)}
3775             }
3776
3777             Store(0x00,BYT1)
3778             Store(0xff,SMBY)
3779             Store(0x00,BRSL)
3780
3781             //test with BYTE system memory data
3782             if(LEqual(BYT1,SMBY))
3783             { Store(LOr(BYT1,SMBY),BRSL)
3784                 if(LNotEqual(Ones,BRSL))
3785                 {Return(26)}
3786             }
3787
3788             Store (0x0000,WRD1)
3789             Store(0xffff,SMWD)
3790             Store(0x0000,WRSL)
3791
3792             //test with WORD system memory data
3793             if(LEqual(WRD1,SMWD))
3794             { Store(LOr(WRD1,SMWD),WRSL)
3795                 if(LNotEqual(Ones,WRSL))
3796                 {Return(27)}
3797             }
3798
3799
3800             Store(0x00000000,DWD1)
3801             Store(0xffffffff,SMDW)
3802             Store(0x00000000,DRSL)
3803
3804             //test with DWORD system memory data
3805             if(LEqual(DWD1,SMDW))
3806             { Store(LAnd(DWD1,SMDW),DRSL)
3807                 if(LNotEqual(Ones,DRSL))
3808                 {Return(28)}
3809             }
3810             Return(0)
3811
3812         }//ORL_
3813
3814         //This method tests LGreater and LNot operator
3815         Method(LSGR,2)
3816         {//LSGR
3817
3818             //Test on arguements passed
3819
3820             //in test data, Arg1 > Arg0
3821             if(LEqual(Ones,LNot(LGreater(Arg1,Arg0))))
3822             {Return(31)}
3823
3824             //test LLessEqual
3825             if(LEqual(Ones,LNot(LGreaterEqual(Arg1,Arg0))))
3826             {Return(32)}
3827
3828             if(LEqual(Ones,LLess(Arg1,Arg0)))
3829             {Return(33)}
3830
3831             //test LLessEqual
3832             if(LEqual(Ones,LLessEqual(Arg1,Arg0)))
3833             {Return(34)}
3834
3835             Store(Arg0,Local0)
3836             Store(Arg1,Local1)
3837
3838             //test with the locals
3839             if(LNot(LGreater(Local1,Local0)))
3840                 {Return(35)}
3841
3842             //test on Byte data
3843             Store(0x12,BYT1)
3844             Store(0x21,BYT2)
3845
3846             if(LNot(LGreater(BYT2,BYT1)))
3847                 {Return(36)}
3848
3849             if(LNot(LLess(BYT1,BYT2)))
3850                 {Return(37)}
3851
3852             //test LGreaterEqual with byte data
3853             if(LNot(LGreaterEqual(BYT2,BYT1)))
3854                 {Return(38)}
3855
3856             //test LLessEqual byte data
3857             if(LNot(LLessEqual(BYT1,BYT2)))
3858                 {Return(39)}
3859
3860
3861             //test on Word data
3862             Store(0x1212,WRD1)
3863             Store(0x2121,WRD2)
3864
3865             if(LNot(LGreater(WRD2,WRD1)))
3866                 {Return(310)}
3867
3868             if(LNot(LLess(WRD1,WRD2)))
3869                 {Return(311)}
3870
3871             //Test LGreaterEqual with Word Data
3872             if(LNot(LGreaterEqual(WRD2,WRD1)))
3873                 {Return(312)}
3874
3875
3876             //Test LLessEqual with Word Data
3877             if(LNot(LLessEqual(WRD1,WRD2)))
3878                 {Return(313)}
3879
3880             //test on DWord data
3881             Store(0x12121212,DWD1)
3882             Store(0x21212121,DWD2)
3883
3884             if(LNot(LGreater(DWD2,DWD1)))
3885                 {Return(314)}
3886
3887             if(LNot(LLess(DWD1,DWD2)))
3888                 {Return(315)}
3889
3890
3891             //Test LGreaterEqual with Dword
3892             if(LNot(LGreaterEqual(DWD2,DWD1)))
3893                 {Return(316)}
3894
3895             //Test LLessEqual DWord
3896             if(LNot(LLessEqual(DWD1,DWD2)))
3897                 {Return(317)}
3898
3899             Return(0)
3900         }//LSGR
3901
3902         //The test method
3903         Method(TEST)
3904         {
3905             Store ("++++++++ LOps Test", Debug)
3906
3907             Store(0,RSLT)
3908             //Call LAndOp method
3909             Store(ANDL(2,2),RSLT)
3910             if(LNotEqual(RSLT,0))
3911              {Return(RSLT)}
3912
3913             //Call LOrOp Method
3914             Store(ORL_(5,5),RSLT)
3915             if(LNotEqual(RSLT,0))
3916             {Return(RSLT)}
3917
3918             //Call LSGR Method
3919             Store(LSGR(5,7),RSLT)
3920             if(LNotEqual(RSLT,0))
3921             {Return(RSLT)}
3922
3923             Return(0)
3924         }//TEST
3925     }//LOPS
3926
3927 //
3928 // test FdSetOps.asl
3929 //
3930 //  FindSetLeftBit - Find Set Left Bit
3931 //  FindSetLeftBitTerm  := FindSetLeftBit
3932 //  (   Source, //TermArg=>Integer
3933 //      Result  //Nothing | SuperName
3934 //  ) => Integer
3935 //  Source is evaluated as integer data type, and the one-based bit location of
3936 //  the first MSb (most significant set bit) is optionally stored into Result.
3937 //  The result of 0 means no bit was set, 1 means the left-most bit set is the
3938 //  first bit, 2 means the left-most bit set is the second bit, and so on.
3939 //  FindSetRightBit - Find Set Right Bit
3940
3941 //  FindSetRightBitTerm := FindSetRightBit
3942 //  (   Source, //TermArg=>Integer
3943 //      Result  //Nothing | SuperName
3944 //  ) => Integer
3945 //  Source is evaluated as integer data type, and the one-based bit location of
3946 //  the most LSb (least significant set bit) is optionally stored in Result.
3947 //  The result of 0 means no bit was set, 32 means the first bit set is the
3948 //  32nd bit, 31 means the first bit set is the 31st bit, and so on.
3949
3950 //  If the Control method is success Zero is returned. Otherwise a non-zero
3951 //  number is returned.
3952 //
3953     Device (FDSO)
3954     {   //  FDSO
3955
3956         //  Create System Memory Operation Region and field overlays
3957         OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
3958         Field (RAM, AnyAcc, NoLock, Preserve)
3959         {
3960             SMDW,   32, //  32-bit DWORD
3961             SMWD,   16, //  16-bit WORD
3962             SMBY,   8,      //  8-bit BYTE
3963         }   //  Field(RAM)
3964
3965         //  Byte Data
3966         Name (BYT1, 1)
3967         Name (BRSL, 0x00)
3968
3969         //  Word Data
3970         Name (WRD1, 0x100)
3971         Name (WRSL, 0x0000)
3972
3973         //  DWord Data
3974         Name (DWD1, 0x10000)
3975         Name (DRSL, 0x00000000)
3976         Name (RSLT, 1)
3977         Name (CNTR, 1)
3978
3979         Method (SHFT,2)
3980         //  Arg0 is the actual data and Arg1 is the bit position
3981         {   //  SHFT
3982             Store (Arg0, Local0)
3983             Store (Arg1, Local1)
3984
3985             FindSetLeftBit (Arg0, BRSL)
3986             If (LNotEqual (BRSL, Arg1))
3987                 {   Return (0x11)   }
3988             If (LNotEqual (Arg0, Local0))
3989                 {   Return (0x12)   }
3990
3991             FindSetLeftBit (Local0, BRSL)
3992             If (LNotEqual (BRSL, Local1))
3993                 {   Return (0x13)   }
3994             If (LNotEqual (Arg0, Local0))
3995                 {   Return (0x14)   }
3996
3997             //  test the byte value for SetLeftBit
3998             Store (7, BYT1)
3999             FindSetLeftBit (BYT1, BRSL)
4000             If (LNotEqual (BRSL, 3))
4001                 {   Return (0x15)   }
4002             If (LNotEqual (BYT1, 7))
4003                 {   Return (0x16)   }
4004
4005             Store (1, BYT1)
4006             Store (1, CNTR)
4007             While (LLessEqual (CNTR, 8))
4008             {   //  FindSetLeftBit check loop for byte data
4009                 FindSetLeftBit (BYT1, BRSL)
4010                 If (LNotEqual (BRSL, CNTR))
4011                     {   Return (0x17)   }
4012
4013                 //  Shift the bits to check the same
4014                 ShiftLeft (BYT1, 1, BYT1)
4015                 Increment (CNTR)
4016             }   //  FindSetLeftBit check loop for byte data
4017
4018
4019             //  Check BYTE value for SetRightBit
4020             Store (7, BYT1)
4021             FindSetRightBit (BYT1, BRSL)
4022             If (LNotEqual (BRSL, 1))
4023                 {   Return (0x21)   }
4024             If (LNotEqual (BYT1, 7))
4025                 {   Return (0x22)   }
4026
4027             Store (1, CNTR)
4028             Store (0xFF, BYT1)
4029             While (LLessEqual (CNTR, 8))
4030             {   //  FindSetRightBit check loop for byte data
4031                 FindSetRightBit (BYT1, BRSL)
4032                 If (LNotEqual (BRSL, CNTR))
4033                     {   Return (0x23)   }
4034
4035                 ShiftLeft (BYT1, 1, BYT1)
4036                 Increment (CNTR)
4037             }   //  FindSetRightBit check loop for byte data
4038
4039
4040             //  Test Word value for SetLeftBit
4041             Store (9, CNTR)
4042             Store (0x100, WRD1)
4043             While (LLessEqual (CNTR, 16))
4044             {
4045                 //  FindSetLeftBit check loop for Word data
4046                 FindSetLeftBit (WRD1, WRSL)
4047                 If (LNotEqual (WRSL, CNTR))
4048                     {   Return (0x31)   }
4049
4050                 //  Shift the bits to check the same
4051                 ShiftLeft (WRD1, 1, WRD1)
4052                 Increment (CNTR)
4053             }   //  FindSetLeftBit check loop for Word data
4054
4055             //  Check Word value for SetRightBit
4056             Store (9, CNTR)
4057             Store (0xFF00, WRD1)
4058             While (LLessEqual (CNTR, 16))
4059             {
4060                 //  FindSetRightBit check loop for Word data
4061                 FindSetRightBit (WRD1, WRSL)
4062                 If (LNotEqual (WRSL, CNTR))
4063                     {   Return (0x32)   }
4064
4065                 ShiftLeft (WRD1, 1, WRD1)
4066                 Increment (CNTR)
4067             }   //  FindSetRightBit check loop for Word data
4068
4069             //  Test the DWord value for SetLeftBit
4070             Store (17, CNTR)
4071             Store (0x10000, DWD1)
4072             While (LLessEqual (CNTR, 32))
4073             {
4074                 //  FindSetLeftBit check loop for Dword
4075                 FindSetLeftBit (DWD1, DRSL)
4076                 If (LNotEqual (DRSL, CNTR))
4077                     {   Return (0x41)   }
4078
4079                 //  Shift the bits to check the same
4080                 ShiftLeft (DWD1, 1, DWD1)
4081                 Increment (CNTR)
4082             }   //  FindSetLeftBit check loop for Dword
4083
4084             //  Check DWord value for SetRightBit
4085             Store (17, CNTR)
4086             Store (0xFFFF0000, DWD1)
4087             While (LLessEqual (CNTR, 32))
4088             {   //  FindSetRightBit Check loop for DWORD
4089                 FindSetRightBit (DWD1, DRSL)
4090                 If (LNotEqual (DRSL, CNTR))
4091                     {   Return (0x42)   }
4092
4093                 ShiftLeft (DWD1, 1, DWD1)
4094                 Increment (CNTR)
4095             }   //  FindSetRightBit Check loop for DWORD
4096
4097             Return (0)
4098         }   //  SHFT
4099
4100         //  Test method called from amlexec
4101         Method (TEST)
4102         {   //  TEST
4103
4104             Store ("++++++++ FdSetOps Test", Debug)
4105
4106             Store (SHFT (0x80, 8), RSLT)
4107             If (LNotEqual (RSLT, 0))
4108                 {   Return (RSLT)   }
4109
4110             Return (0)  //  pass
4111         }   //  TEST
4112     }   //  Device FDSO
4113
4114 //
4115 // test MulDivOp.asl
4116 //
4117     Device (MLDV)
4118     {
4119         //  create System Memory Operation Region and field overlays
4120         OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
4121         Field (RAM, AnyAcc, NoLock, Preserve)
4122         {
4123             SMDW,   32, //  32-bit DWORD
4124             SMWD,   16, //  16-bit WORD
4125             SMBY,   8,  //  8-bit BYTE
4126         }   //  Field(RAM)
4127
4128         Method (TEST,, Serialized)
4129         {
4130             Store ("++++++++ MulDivOp Test", Debug)
4131
4132             Name (RMDR, 0)
4133             Name (DWRD, 0x12345678)
4134             Name (WRD, 0x1234)
4135             Name (BYT, 0x12)
4136
4137             //  Test MultiplyOp with DWORD data
4138             Store (0x12345678, DWRD)
4139             Multiply (DWRD, 3, DWRD)
4140             If (LNotEqual (DWRD, 0x369D0368))
4141                 {   Return (DWRD)   }
4142
4143             //  Test MultiplyOp with WORD data
4144             Multiply (WRD, 4, WRD)
4145             If (LNotEqual (WRD, 0x48D0))
4146                 {   Return (WRD)    }
4147
4148             //  Test MultiplyOp with BYTE data
4149             Multiply (BYT, 5, BYT)
4150             If (LNotEqual (BYT, 0x5A))
4151                 {   Return (BYT)    }
4152
4153             //  Test DivideOp with DWORD data
4154             Divide (DWRD, 3, DWRD, RMDR)
4155             If (LNotEqual (DWRD, 0x12345678))
4156                 {   Return (DWRD)   }
4157             If (LNotEqual (RMDR, 0))
4158                 {   Return (RMDR)   }
4159
4160             //  Test DivideOp with WORD data
4161             Divide (WRD, 4, WRD, RMDR)
4162             If (LNotEqual (WRD, 0x1234))
4163                 {   Return (WRD)    }
4164             If (LNotEqual (RMDR, 0))
4165                 {   Return (RMDR)   }
4166
4167             //  Test DivideOp with BYTE data
4168             Divide (BYT, 5, BYT, RMDR)
4169             If (LNotEqual (BYT, 0x12))
4170                 {   Return (BYT)    }
4171             If (LNotEqual (RMDR, 0))
4172                 {   Return (RMDR)   }
4173
4174
4175             //  test MultiplyOp with DWORD SystemMemory OpRegion
4176             Store (0x01234567, SMDW)
4177             Multiply (SMDW, 2, SMDW)
4178             If (LNotEqual (SMDW, 0x02468ACE))
4179                 {   Return (SMDW)   }
4180
4181             //  test DivideOp with DWORD SystemMemory OpRegion
4182             Divide (SMDW, 3, SMDW, RMDR)
4183             If (LNotEqual (SMDW, 0x00C22E44))
4184                 {   Return (SMDW)   }
4185             If (LNotEqual (RMDR, 2))
4186                 {   Return (RMDR)   }
4187
4188
4189             //  test MultiplyOp with WORD SystemMemory OpRegion
4190             Store (0x0123, SMWD)
4191             Multiply (SMWD, 3, SMWD)
4192             If (LNotEqual (SMWD, 0x369))
4193                 {   Return (SMWD)   }
4194
4195             //  test DivideOp with WORD SystemMemory OpRegion
4196             Divide (SMWD, 2, SMWD, RMDR)
4197             If (LNotEqual (SMWD, 0x01B4))
4198                 {   Return (SMWD)   }
4199             If (LNotEqual (RMDR, 1))
4200                 {   Return (RMDR)   }
4201
4202
4203             //  test MultiplyOp with BYTE SystemMemory OpRegion
4204             Store (0x01, SMBY)
4205             Multiply (SMBY, 7, SMBY)
4206             If (LNotEqual (SMBY, 0x07))
4207                 {   Return (SMBY)   }
4208
4209             //  test DivideOp with BYTE SystemMemory OpRegion
4210             Divide (SMBY, 4, SMBY, RMDR)
4211             If (LNotEqual (SMBY, 0x01))
4212                 {   Return (SMBY)   }
4213             If (LNotEqual (RMDR, 3))
4214                 {   Return (RMDR)   }
4215
4216             Return (0)
4217         }   //  TEST
4218     }   //  MLDV
4219
4220 //
4221 // test NBitOps.asl
4222 //
4223 //NAnd - Bit-wise NAnd
4224 //NAndTerm  := NAnd(
4225 //  Source1,    //TermArg=>Integer
4226 //  Source2 //TermArg=>Integer
4227 //  Result  //Nothing | SuperName
4228 //) => Integer
4229 //Source1 and Source2 are evaluated as integer data types, a bit-wise NAND is performed, and the result is optionally
4230 //stored in Result.
4231
4232 //NOr - Bitwise NOr
4233 //NOrTerm   := NOr(
4234 //  Source1,    //TermArg=>Integer
4235 //  Source2 //TermArg=>Integer
4236 //  Result  //Nothing | SuperName
4237 //) => Integer
4238 //Source1 and Source2 are evaluated as integer data types, a bit-wise NOR is performed, and the result is optionally
4239 //stored in Result.
4240 // Not - Not
4241 //NotTerm   := Not(
4242 //  Source, //TermArg=>Integer
4243 //  Result  //Nothing | SuperName
4244 //) => Integer
4245 //Source1 is evaluated as an integer data type, a bit-wise NOT is performed, and the result is optionally stored in
4246 //Result.
4247
4248 //If the Control method is success Zero is returned else a non-zero number is returned
4249
4250     Device (NBIT)
4251     {//NBIT
4252
4253         //Create System Memory Operation Region and field overlays
4254         OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
4255         Field (RAM, AnyAcc, NoLock, Preserve)
4256         {
4257             SMDW,   32, //  32-bit DWORD
4258             SMWD,   16, //  16-bit WORD
4259             SMBY,   8,  //  8-bit BYTE
4260         }// Field(RAM)
4261
4262
4263         //And with Byte Data
4264         Name (BYT1, 0xff)
4265         Name (BYT2, 0xff)
4266         Name (BRSL, 0x00)
4267
4268         //And with Word Data
4269         Name (WRD1, 0xffff)
4270         Name (WRD2, 0xffff)
4271         Name (WRSL, 0x0000)
4272
4273         //And with DWord Data
4274         Name (DWD1, 0xffffffff)
4275         Name (DWD2, 0xffffffff)
4276         Name (DRSL, 0x00000000)
4277         Name(RSLT,1)
4278
4279
4280         Name(ARSL,0x00)
4281         Name(LRSL,0x00)
4282
4283         Method(NNDB,2)
4284         {//NNDB
4285
4286             Store(0xffffffff,SMDW)
4287             Store(0xffff,SMWD)
4288             Store(0xff,SMBY)
4289
4290
4291             NAnd(Arg0,Arg1,ARSL)
4292             if(LNotEqual(ARSL,0xfffffffd))
4293              {Return(11)}
4294
4295              Store(Arg0,local0)
4296              Store(Arg1,Local1)
4297
4298              NAnd(Local0,Local1,LRSL)
4299                 if(LNotEqual(LRSL,0xfffffffd))
4300              {Return(12)}
4301
4302
4303             //Byte data
4304             NAnd(BYT1,BYT2,BRSL)
4305             if(LNotEqual(BRSL,0xffffff00))
4306              {Return(13)}
4307
4308             //Word Data
4309              NAnd(WRD1,WRD2,WRSL)
4310             if(LNotEqual(WRSL,0xffff0000))
4311              {Return(14)}
4312
4313              //DWord Data
4314              NAnd(DWD1,DWD2,DRSL)
4315             if(LNotEqual(DRSL,0x00000000))
4316              {Return(15)}
4317
4318              //Byte data
4319             NAnd(SMBY,0xff,BRSL)
4320             if(LNotEqual(BRSL,0xffffff00))
4321              {Return(16)}
4322
4323             //Word Data
4324              NAnd(SMWD,0xffff,WRSL)
4325             if(LNotEqual(WRSL,0xffff0000))
4326              {Return(17)}
4327
4328              //DWord Data
4329              NAnd(SMDW,0xffffffff,DRSL)
4330             if(LNotEqual(DRSL,0x00000000))
4331              {Return(18)}
4332
4333             Return(0)
4334
4335         }//NNDB
4336
4337         Method(NNOR,2)
4338         {//NNOR
4339
4340             NOr(Arg0,Arg1,ARSL)
4341             if(LNotEqual(ARSL,0xfffffffd))
4342              {Return(21)}
4343
4344             Store(Arg0,local0)
4345             Store(Arg1,Local1)
4346
4347             NOr(Local0,Local1,LRSL)
4348             if(LNotEqual(LRSL,0xfffffffd))
4349              {Return(22)}
4350
4351
4352             //Byte data
4353             NOr(BYT1,BYT2,BRSL)
4354             if(LNotEqual(BRSL,0xffffff00))
4355              {Return(23)}
4356
4357             //Word Data
4358             NOr(WRD1,WRD2,WRSL)
4359             if(LNotEqual(WRSL,0xffff0000))
4360              {Return(24)}
4361
4362             //DWord Data
4363             NOr(DWD1,DWD2,DRSL)
4364             if(LNotEqual(DRSL,0x00000000))
4365              {Return(25)}
4366
4367              //System Memory Byte data
4368             NOr(SMBY,0xff,BRSL)
4369             if(LNotEqual(BRSL,0xffffff00))
4370              {Return(26)}
4371
4372             //System Memory Word Data
4373             NOr(SMWD,0xffff,WRSL)
4374             if(LNotEqual(WRSL,0xffff0000))
4375              {Return(27)}
4376
4377             //System Memory DWord Data
4378             NOr(SMDW,0xffffffff,DRSL)
4379             if(LNotEqual(DRSL,0x00000000))
4380              {Return(28)}
4381
4382             Return(0)
4383
4384         }//NNOR
4385
4386         Method(NNOT,2)
4387         {//NNOT
4388
4389             Or(Arg0,Arg1,ARSL)
4390             Not(ARSL,ARSL)
4391             if(LNotEqual(ARSL,0xfffffffd))
4392              {Return(31)}
4393
4394             Store(Arg0,local0)
4395             Store(Arg1,Local1)
4396
4397             Or(Local0,Local1,LRSL)
4398             Not(LRSL,LRSL)
4399             if(LNotEqual(LRSL,0xfffffffd))
4400              {Return(32)}
4401
4402
4403             //Byte data
4404             Or(BYT1,BYT2,BRSL)
4405             Not(BRSL,BRSL)
4406             if(LNotEqual(BRSL,0xffffff00))
4407              {Return(33)}
4408
4409             //Word Data
4410             Or(WRD1,WRD2,WRSL)
4411             Not(WRSL,WRSL)
4412             if(LNotEqual(WRSL,0xffff0000))
4413              {Return(34)}
4414
4415             //DWord Data
4416             Or(DWD1,DWD2,DRSL)
4417             Not(DRSL,DRSL)
4418             if(LNotEqual(DRSL,0x00000000))
4419              {Return(35)}
4420
4421              //System Memory Byte data
4422             Or(SMBY,0xff,BRSL)
4423             Not(BRSL,BRSL)
4424             if(LNotEqual(BRSL,0xffffff00))
4425              {Return(36)}
4426
4427             //System Memory Word Data
4428             Or(SMWD,0xffff,WRSL)
4429             Not(WRSL,WRSL)
4430             if(LNotEqual(WRSL,0xffff0000))
4431              {Return(37)}
4432
4433             //System Memory DWord Data
4434             Or(SMDW,0xffffffff,DRSL)
4435             Not(DRSL,DRSL)
4436             if(LNotEqual(DRSL,0x00000000))
4437              {Return(38)}
4438
4439             Return(0)
4440         }//NNOT
4441
4442
4443         Method(TEST)
4444         {
4445
4446             Store ("++++++++ NBitOps Test", Debug)
4447
4448             Store(NNDB(2,2),RSLT)
4449             if(LNotEqual(RSLT,0))
4450                 {Return(RSLT)}
4451
4452             Store(NNOR(2,2),RSLT)
4453             if(LNotEqual(RSLT,0))
4454                 {Return(RSLT)}
4455
4456             Store(NNOT(2,2),RSLT)
4457             if(LNotEqual(RSLT,0))
4458                 {Return(RSLT)}
4459
4460
4461            Return(0)
4462         }
4463
4464     }//Device NBIT
4465
4466 //
4467 // test ShftOp.asl
4468 //
4469 //ShiftRightTerm    := ShiftRight(
4470 //  Source, //TermArg=>Integer
4471 //  ShiftCount  //TermArg=>Integer
4472 //  Result  //Nothing | SuperName
4473 //) => Integer
4474 //Source and ShiftCount are evaluated as integer data types. Source is shifted right with the most significant bit
4475 //zeroed ShiftCount times.  The result is optionally stored into Result.
4476
4477 //ShiftLeft(
4478 //  Source, //TermArg=>Integer
4479 //  ShiftCount  //TermArg=>Integer
4480 //  Result  //Nothing | SuperName
4481 //) => Integer
4482 //Source and ShiftCount are evaluated as integer data types. Source is shifted left with the least significant
4483 //bit zeroed ShiftCount times. The result is optionally stored into Result.
4484
4485 //If the Control method is success Zero is returned else a non-zero number is returned
4486     Device (SHFT)
4487     {//SHFT
4488
4489         //Create System Memory Operation Region and field overlays
4490         OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
4491         Field (RAM, AnyAcc, NoLock, Preserve)
4492         {
4493             SMDW,   32, //  32-bit DWORD
4494             SMWD,   16, //  16-bit WORD
4495             SMBY,   8,  //  8-bit BYTE
4496         }// Field(RAM)
4497
4498
4499         Name(SHFC,0x00)
4500
4501         //And with Byte Data
4502         Name (BYT1, 0xff)
4503         Name (BRSL, 0x00)
4504
4505         //And with Word Data
4506         Name (WRD1, 0xffff)
4507         Name (WRSL, 0x0000)
4508
4509         //And with DWord Data
4510         Name (DWD1, 0xffffffff)
4511         Name (DRSL, 0x00000000)
4512
4513         Name(RSLT,1)
4514
4515         Name(ARSL,0x00)
4516         Name(LRSL,0x00)
4517
4518         Method(SLFT,2)
4519         {//SLFT
4520
4521             Store(0xffffffff,SMDW)
4522             Store(0xffff,SMWD)
4523             Store(0xff,SMBY)
4524
4525
4526             //Arg0-> 2 & Arg1->2
4527             ShiftLeft(Arg0,Arg1,ARSL)
4528             if(LNotEqual(ARSL,8))
4529             {Return(11)}
4530
4531              Store(Arg0,local0)
4532              Store(Arg1,Local1)
4533
4534              //Local0->8 and Local1->2
4535              ShiftLeft(Local0,Local1,LRSL)
4536                 if(LNotEqual(LRSL,8))
4537              {Return(12)}
4538
4539             Store(2,SHFC)
4540             //Byte data
4541             ShiftLeft(BYT1,SHFC,BRSL)
4542             if(LNotEqual(BRSL,0x3FC))
4543              {Return(13)}
4544
4545             Store(4,SHFC)
4546             //Word Data
4547              ShiftLeft(WRD1,SHFC,WRSL)
4548             if(LNotEqual(WRSL,0xFFFF0))
4549              {Return(14)}
4550
4551             Store(8,SHFC)
4552             //DWord Data
4553             ShiftLeft(DWD1,SHFC,DRSL)
4554             if(LNotEqual(DRSL,0xFFFFFF00))
4555              {Return(15)}
4556
4557
4558              //System Memory Byte data
4559             Store(4,SHFC)
4560             ShiftLeft(SMBY,SHFC,BRSL)
4561             if(LNotEqual(BRSL,0xFF0))
4562             {Return(16)}
4563
4564             //Word Data
4565             Store(4,SHFC)
4566             ShiftLeft(SMWD,SHFC,WRSL)
4567             if(LNotEqual(WRSL,0xffff0))
4568              {Return(17)}
4569
4570             //DWord Data
4571             Store(8,SHFC)
4572             ShiftLeft(SMDW,SHFC,DRSL)
4573             if(LNotEqual(DRSL,0xFFFFFF00))
4574                 {Return(18)}
4575
4576             Return(0)
4577
4578         }//SLFT
4579
4580         Method(SRGT,2)
4581         {//SRGT
4582             //And with Byte Data
4583             Store (0xff,BYT1)
4584             Store (0x00,BRSL)
4585
4586             //And with Word Data
4587             Store (0xffff,WRD1)
4588             Store (0x0000,WRSL)
4589
4590             //And with DWord Data
4591             Store(0xffffffff,DWD1)
4592             Store (0x00000000,DRSL)
4593
4594             //Reinitialize the result objects
4595             Store(0x00,ARSL)
4596             Store(0x00,LRSL)
4597
4598             Store(0xffffffff,SMDW)
4599             Store(0xffff,SMWD)
4600             Store(0xff,SMBY)
4601
4602             //Arg0-> 2 & Arg1->2
4603             ShiftRight(Arg0,Arg1,ARSL)
4604             if(LNotEqual(ARSL,0))
4605             {Return(21)}
4606
4607              Store(Arg0,local0)
4608              Store(Arg1,Local1)
4609
4610              //Local0->8 and Local1->2
4611              ShiftRight(Local0,Local1,LRSL)
4612                 if(LNotEqual(LRSL,0))
4613              {Return(22)}
4614
4615             Store(2,SHFC)
4616             //Byte data
4617             ShiftRight(BYT1,SHFC,BRSL)
4618             if(LNotEqual(BRSL,0x3F))
4619              {Return(23)}
4620
4621             Store(4,SHFC)
4622             //Word Data
4623              ShiftRight(WRD1,SHFC,WRSL)
4624             if(LNotEqual(WRSL,0xFFF))
4625              {Return(24)}
4626
4627             Store(8,SHFC)
4628             //DWord Data
4629             ShiftRight(DWD1,SHFC,DRSL)
4630             if(LNotEqual(DRSL,0xFFFFFF))
4631              {Return(25)}
4632
4633             //System Memory Byte data
4634             Store(4,SHFC)
4635             ShiftRight(SMBY,SHFC,BRSL)
4636             if(LNotEqual(BRSL,0xF))
4637             {Return(26)}
4638
4639             //Word Data
4640             Store(4,SHFC)
4641             ShiftRight(SMWD,SHFC,WRSL)
4642             if(LNotEqual(WRSL,0xFFF))
4643              {Return(27)}
4644
4645             //DWord Data
4646             Store(8,SHFC)
4647             ShiftRight(SMDW,SHFC,DRSL)
4648             if(LNotEqual(DRSL,0xFFFFFF))
4649                 {Return(28)}
4650
4651             Return(0)
4652         }//SRGT
4653
4654         //Test method called from amlexec
4655         Method(TEST)
4656         {
4657             Store ("++++++++ ShftOp Test", Debug)
4658
4659             Store(SLFT(2,2),RSLT)
4660             if(LNotEqual(RSLT,0))
4661                 {Return(RSLT)}
4662             Store(SRGT(2,2),RSLT)
4663             if(LNotEqual(RSLT,0))
4664                 {Return(RSLT)}
4665            Return(0)
4666         }
4667
4668     }//Device SHFT
4669
4670 //
4671 // test Xor.asl and slightly modified
4672 //
4673 //This code tests the XOR opcode term
4674 //Syntax of XOR term
4675 //          XOr(
4676 //                  Source1  //TermArg=>BufferTerm
4677 //                  Source2  //TermArg=>Integer
4678 //                  Result //NameString
4679 //              )
4680 //"Source1" and "Source2" are evaluated as integers, a bit-wise XOR is performed, and the result is optionally stored in
4681 // Result
4682     Device (XORD)
4683     {
4684         //This Method tests XOr operator for all the data types i.e. BYTE, WORD and DWORD
4685         Method (TEST,, Serialized)
4686         {
4687             Store ("++++++++ Xor Test", Debug)
4688
4689             //Overlay in system memory
4690             OperationRegion (RAM, SystemMemory, 0x800000, 256)
4691             Field (RAM, ByteAcc, NoLock, Preserve)
4692             {
4693                 RES1,   1,  //Offset
4694                 BYT1,   8,  //First BYTE
4695                 BYT2,   8,  //Second BYTE
4696                 RBYT,   8,  //Result Byte
4697                 RES2,   1,  //Offset
4698                 WRD1,   16, //First WORD field
4699                 WRD2,   16, //Second WORD field
4700                 RWRD,   16, //RSLT WORD field
4701                 RES3,   1,  //Offset
4702                 DWD1,   32, //First Dword
4703                 DWD2,   32, //Second Dword
4704                 RDWD,   32, //Result Dword
4705                 RES4,   1,  //Offset
4706             }
4707
4708             // Store bits in the single bit fields for checking
4709             //  at the end
4710             Store(1, RES1)
4711             Store(1, RES2)
4712             Store(1, RES3)
4713             Store(1, RES4)
4714
4715             // Check the stored single bits
4716             if(LNotEqual(RES1, 1))
4717             {
4718                 Return(1)
4719             }
4720
4721             if(LNotEqual(RES2, 1))
4722             {
4723                 Return(1)
4724             }
4725
4726             if(LNotEqual(RES3, 1))
4727             {
4728                 Return(1)
4729             }
4730
4731             if(LNotEqual(RES4, 1))
4732             {
4733                 Return(1)
4734             }
4735
4736             //************************************************
4737             // (BYT1) Bit1 ->0 and (BYT2)Bit2 -> 0 condition
4738             Store(0x00,BYT1)
4739             Store(0x00,BYT2)
4740             XOr(BYT1,BYT2,Local0)
4741             Store (Local0, RBYT)
4742             if(LNotEqual(RBYT,0))
4743             {   Return(1)}
4744
4745             // (BYT1) Bit1 ->1 and (BYT2)Bit2 -> 1 condition
4746             Store(0xff,BYT1)
4747             Store(0xff,BYT2)
4748             XOr(BYT1,BYT2,Local0)
4749             Store (Local0, RBYT)
4750             if(LNotEqual(RBYT,0))
4751             {   Return(1)}
4752
4753             // (BYT1) Bit1 ->1 and (BYT)Bit2 -> 0 condition
4754             Store(0x55,BYT1)
4755             Store(0xAA,BYT2)
4756             XOr(BYT1,BYT2,Local0)
4757             Store (Local0, RBYT)
4758             if(LNotEqual(RBYT,0xFF))
4759             {   Return(1)}
4760
4761             //(BYT1) Bit1 ->0 and (BYT2)Bit2 -> 1 condition
4762             Store(0xAA,BYT1)
4763             Store(0x55,BYT2)
4764             XOr(BYT1,BYT2,Local0)
4765             Store (Local0, RBYT)
4766             if(LNotEqual(RBYT,0xFF))
4767             {   Return(1)}
4768
4769             Store(0x12,BYT1)
4770             Store(0xED,BYT2)
4771
4772             XOr(BYT1,BYT2,Local0)
4773             Store (Local0, RBYT)
4774             if(LNotEqual(RBYT,0xFF))
4775             {
4776                 Return(1)
4777             }
4778
4779             // Store known values for checking later
4780             Store(0x12, BYT1)
4781             if(LNotEqual(BYT1, 0x12))
4782             {
4783                 Return(1)
4784             }
4785
4786             Store(0xFE, BYT2)
4787             if(LNotEqual(BYT2, 0xFE))
4788             {
4789                 Return(1)
4790             }
4791
4792             Store(0xAB, RBYT)
4793             if(LNotEqual(RBYT, 0xAB))
4794             {
4795                 Return(1)
4796             }
4797
4798             //***********************************************
4799             // (WRD1) Bit1 ->0 and (WRD2)Bit2 -> 0 condition
4800             Store(0x0000,WRD1)
4801             Store(0x0000,WRD2)
4802             XOr(WRD1,WRD2,RWRD)
4803             if(LNotEqual(RWRD,0))
4804             {   Return(1)}
4805
4806             // (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 1 condition
4807             Store(0xffff,WRD1)
4808             Store(0xffff,WRD2)
4809             XOr(WRD1,WRD2,RWRD)
4810             if(LNotEqual(RWRD,0))
4811             {   Return(1)}
4812
4813             // (WRD1) Bit1 ->1 and (WRD2)Bit2 -> 0 condition
4814             Store(0x5555,WRD1)
4815             Store(0xAAAA,WRD2)
4816             XOr(WRD1,WRD2,RWRD)
4817             if(LNotEqual(RWRD,0xFFFF))
4818             {   Return(1)}
4819
4820             //(WRD1) Bit1 ->0 and (WRD2)Bit2 -> 1 condition
4821             Store(0xAAAA,WRD1)
4822             Store(0x5555,WRD2)
4823             XOr(WRD1,WRD2,RWRD)
4824             if(LNotEqual(RWRD,0xFFFF))
4825             {   Return(1)}
4826
4827             Store(0x1234,WRD1)
4828             Store(0xEDCB,WRD2)
4829             XOr(WRD1,WRD2,RWRD)
4830             if(LNotEqual(RWRD,0xFFFF))
4831             {   Return(1)}
4832
4833             // Store known values for checking later
4834             Store(0x1234, WRD1)
4835             if(LNotEqual(WRD1, 0x1234))
4836             {
4837                 Return(1)
4838             }
4839
4840             Store(0xFEDC, WRD2)
4841             if(LNotEqual(WRD2, 0xFEDC))
4842             {
4843                 Return(1)
4844             }
4845
4846             Store(0x87AB, RWRD)
4847             if(LNotEqual(RWRD, 0x87AB))
4848             {
4849                 Return(1)
4850             }
4851
4852
4853             //**************************************************
4854             // (DWD1) Bit1 ->0 and (DWD2)Bit2 -> 0 condition
4855             Store(0x00000000,DWD1)
4856             Store(0x00000000,DWD2)
4857             XOr(DWD1,DWD2,RDWD)
4858             if(LNotEqual(RDWD,0))
4859             {   Return(1)}
4860
4861             // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 1 condition
4862             Store(0xffffffff,DWD1)
4863             Store(0xffffffff,DWD2)
4864             XOr(DWD1,DWD2,RDWD)
4865             if(LNotEqual(RDWD,0))
4866             {   Return(1)}
4867
4868             // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition
4869             Store(0x55555555,DWD1)
4870             Store(0xAAAAAAAA,DWD2)
4871             XOr(DWD1,DWD2,RDWD)
4872             if(LNotEqual(RDWD,0xFFFFFFFF))
4873             {   Return(1)}
4874
4875             //(DWD1) Bit1 ->0 and (DWD2)Bit2 -> 1 condition
4876             Store(0xAAAAAAAA,DWD1)
4877             Store(0x55555555,DWD2)
4878             XOr(DWD1,DWD2,RDWD)
4879             if(LNotEqual(RDWD,0xFFFFFFFF))
4880             {   Return(1)}
4881
4882             // (DWD1) Bit1 ->1 and (DWD2)Bit2 -> 0 condition
4883             Store(0x12345678,DWD1)
4884             Store(0xEDCBA987,DWD2)
4885             XOr(DWD1,DWD2,RDWD)
4886             if(LNotEqual(RDWD,0xFFFFFFFF))
4887             {   Return(1)}
4888
4889             Store(0x12345678,DWD1)
4890             if(LNotEqual(DWD1,0x12345678))
4891             {
4892                 Return(1)
4893             }
4894
4895             Store(0xFEDCBA98,DWD2)
4896             if(LNotEqual(DWD2,0xFEDCBA98))
4897             {
4898                 Return(1)
4899             }
4900
4901             Store(0x91827364,RDWD)
4902             if(LNotEqual(RDWD,0x91827364))
4903             {
4904                 Return(1)
4905             }
4906
4907             //****************************************************
4908             // Check the stored single bits
4909             if(LNotEqual(RES1, 1))
4910             {
4911                 Return(1)
4912             }
4913
4914             if(LNotEqual(RES2, 1))
4915             {
4916                 Return(1)
4917             }
4918
4919             if(LNotEqual(RES3, 1))
4920             {
4921                 Return(1)
4922             }
4923
4924             if(LNotEqual(RES4, 1))
4925             {
4926                 Return(1)
4927             }
4928
4929             // Change all of the single bit fields to zero
4930             Store(0, RES1)
4931             Store(0, RES2)
4932             Store(0, RES3)
4933             Store(0, RES4)
4934
4935             // Now, check all of the fields
4936
4937             // Byte
4938             if(LNotEqual(BYT1, 0x12))
4939             {
4940                 Return(1)
4941             }
4942
4943             if(LNotEqual(BYT2, 0xFE))
4944             {
4945                 Return(1)
4946             }
4947
4948             if(LNotEqual(RBYT, 0xAB))
4949             {
4950                 Return(1)
4951             }
4952
4953             // Word
4954             if(LNotEqual(WRD1, 0x1234))
4955             {
4956                 Return(1)
4957             }
4958
4959             if(LNotEqual(WRD2, 0xFEDC))
4960             {
4961                 Return(1)
4962             }
4963
4964             if(LNotEqual(RWRD, 0x87AB))
4965             {
4966                 Return(1)
4967             }
4968
4969             // Dword
4970             if(LNotEqual(DWD1, 0x12345678))
4971             {
4972                 Return(1)
4973             }
4974
4975             if(LNotEqual(DWD2, 0xFEDCBA98))
4976             {
4977                 Return(1)
4978             }
4979
4980             if(LNotEqual(RDWD, 0x91827364))
4981             {
4982                 Return(1)
4983             }
4984
4985             // Bits
4986             if(LNotEqual(RES1, 0))
4987             {
4988                 Return(1)
4989             }
4990
4991             if(LNotEqual(RES2, 0))
4992             {
4993                 Return(1)
4994             }
4995
4996             if(LNotEqual(RES3, 0))
4997             {
4998                 Return(1)
4999             }
5000
5001             if(LNotEqual(RES4, 0))
5002             {
5003                 Return(1)
5004             }
5005
5006
5007             Return(0)
5008         }   //  TEST
5009     }   //  XORD
5010
5011 //
5012 // test CrBytFld.asl
5013 //
5014 //  CrBytFld test
5015 //      Test for CreateByteField.
5016 //      Tests creating byte field overlay of buffer stored in Local0.
5017 //      Tests need to be added for Arg0 and Name buffers.
5018 //
5019     Device (CRBF)
5020     {   //  Test device name
5021         Method (TEST)
5022         {
5023             Store ("++++++++ CrBytFld Test", Debug)
5024
5025             //  Local0 is unitialized buffer with 4 elements
5026             Store (Buffer (4) {}, Local0)
5027
5028             //  create Byte Field named BF0 based on Local0 element 0
5029             CreateByteField (Local0, 0, BF0)
5030
5031             //  validate CreateByteField did not alter Local0
5032             Store (ObjectType (Local0), Local1) //  Local1 = Local0 object type
5033             If (LNotEqual (Local1, 3))  //  Buffer object type value is 3
5034                 {   Return (2)  }
5035
5036             //  store something into BF0
5037             Store (1, BF0)
5038
5039             //  validate Store did not alter Local0 object type
5040             Store (ObjectType (Local0), Local1) //  Local1 = Local0 object type
5041             If (LNotEqual (Local1, 3))  //  Buffer object type value is 3
5042                 {   Return (3)  }
5043
5044             //  verify that the Store into BF0 was successful
5045             If (LNotEqual (BF0, 1))
5046                 {   Return (4)  }
5047
5048
5049             //  create Byte Field named BF1 based on Local0 element 1
5050             CreateByteField (Local0, 1, BF1)
5051
5052             //  validate CreateByteField did not alter Local0
5053             Store (ObjectType (Local0), Local1) //  Local1 = Local0 object type
5054             If (LNotEqual (Local1, 3))  //  Buffer object type value is 3
5055                 {   Return (10) }
5056
5057             //  store something into BF1
5058             Store (5, BF1)
5059
5060             //  validate Store did not alter Local0 object type
5061             Store (ObjectType (Local0), Local1) //  Local1 = Local0 object type
5062             If (LNotEqual (Local1, 3))  //  Buffer object type value is 3
5063                 {   Return (11) }
5064
5065             //  verify that the Store into BF1 was successful
5066             If (LNotEqual (BF1, 5))
5067                 {   Return (12) }
5068
5069             //  verify that the Store into BF1 did not alter BF0
5070             If (LNotEqual (BF0, 1))
5071                 {   Return (13) }
5072
5073
5074             //  store something into BF0
5075             Store (0xFFFF, BF0)
5076
5077             //  verify that the Store into BF0 was successful
5078             If (LNotEqual (BF0, 0xFF))
5079                 {   Return (20) }
5080
5081             //  verify that the Store into BF0 did not alter BF1
5082             If (LNotEqual (BF1, 5))
5083                 {   Return (21) }
5084
5085
5086             Return (0)
5087         }   //  TEST
5088     }   //  CRBF
5089
5090 //
5091 // test IndexOp4.asl
5092 //
5093 //  IndexOp4 test
5094 //      This is just a subset of the many RegionOp/Index Field test cases.
5095 //      Tests access of index fields smaller than 8 bits.
5096 //
5097     Device (IDX4)
5098     {   //  Test device name
5099
5100         //  MADM:   Misaligned Dynamic RAM SystemMemory OperationRegion
5101         //          Tests OperationRegion memory access using misaligned BYTE,
5102         //          WORD, and DWORD field element accesses. Validation is performed
5103         //          using both misaligned field entries and aligned field entries.
5104         //
5105         //          MADM returns 0 if all test cases pass or non-zero identifying
5106         //          the failing test case for debug purposes. This non-zero numbers
5107         //          are not guaranteed to be in perfect sequence (i.e., test case
5108         //          index), but are guaranteed to be unique so the failing test
5109         //          case can be uniquely identified.
5110         //
5111         Method (MADM, 1, Serialized)    //  Misaligned Dynamic RAM SystemMemory OperationRegion
5112         //  Arg0    --  SystemMemory OperationRegion base address
5113         {   //  MADM:   Misaligned Dynamic RAM SystemMemory OperationRegion
5114             OperationRegion (RAM, SystemMemory, Arg0, 0x100)
5115             Field (RAM, DwordAcc, NoLock, Preserve)
5116             {   //  aligned field definition (for verification)
5117                 DWD0,   32, //  aligned DWORD field
5118                 DWD1,   32      //  aligned DWORD field
5119             }
5120             Field (RAM, ByteAcc, NoLock, Preserve)
5121             {   //  bit access field definition
5122                 BIT0,   1,      //  single bit field entry
5123                 BIT1,   1,      //  single bit field entry
5124                 BIT2,   1,      //  single bit field entry
5125                 BIT3,   1,      //  single bit field entry
5126                 BIT4,   1,      //  single bit field entry
5127                 BIT5,   1,      //  single bit field entry
5128                 BIT6,   1,      //  single bit field entry
5129                 BIT7,   1,      //  single bit field entry
5130                 BIT8,   1,      //  single bit field entry
5131                 BIT9,   1,      //  single bit field entry
5132                 BITA,   1,      //  single bit field entry
5133                 BITB,   1,      //  single bit field entry
5134                 BITC,   1,      //  single bit field entry
5135                 BITD,   1,      //  single bit field entry
5136                 BITE,   1,      //  single bit field entry
5137                 BITF,   1,      //  single bit field entry
5138                 BI10,   1,      //  single bit field entry
5139                 BI11,   1,      //  single bit field entry
5140                 BI12,   1,      //  single bit field entry
5141                 BI13,   1,      //  single bit field entry
5142                 BI14,   1,      //  single bit field entry
5143                 BI15,   1,      //  single bit field entry
5144                 BI16,   1,      //  single bit field entry
5145                 BI17,   1,      //  single bit field entry
5146                 BI18,   1,      //  single bit field entry
5147                 BI19,   1,      //  single bit field entry
5148                 BI1A,   1,      //  single bit field entry
5149                 BI1B,   1,      //  single bit field entry
5150                 BI1C,   1,      //  single bit field entry
5151                 BI1D,   1,      //  single bit field entry
5152                 BI1E,   1,      //  single bit field entry
5153                 BI1F,   1       //  single bit field entry
5154             }   //  bit access field definition
5155
5156             Field (RAM, ByteAcc, NoLock, Preserve)
5157             {   //  two-bit access field definition
5158                 B2_0,   2,      //  single bit field entry
5159                 B2_1,   2,      //  single bit field entry
5160                 B2_2,   2,      //  single bit field entry
5161                 B2_3,   2,      //  single bit field entry
5162                 B2_4,   2,      //  single bit field entry
5163                 B2_5,   2,      //  single bit field entry
5164                 B2_6,   2,      //  single bit field entry
5165                 B2_7,   2,      //  single bit field entry
5166                 B2_8,   2,      //  single bit field entry
5167                 B2_9,   2,      //  single bit field entry
5168                 B2_A,   2,      //  single bit field entry
5169                 B2_B,   2,      //  single bit field entry
5170                 B2_C,   2,      //  single bit field entry
5171                 B2_D,   2,      //  single bit field entry
5172                 B2_E,   2,      //  single bit field entry
5173                 B2_F,   2       //  single bit field entry
5174             }   //  bit access field definition
5175
5176             //  initialize memory contents using aligned field entries
5177             Store (0x5AA55AA5, DWD0)
5178             Store (0x5AA55AA5, DWD1)
5179
5180             //  set memory contents to known values using misaligned field entries
5181             Store (0, BIT0)
5182                 //  verify memory contents using misaligned field entries
5183                 If (LNotEqual (BIT0, 0))
5184                     {   Return (1)  }
5185                 //  verify memory contents using aligned field entries
5186                 If (LNotEqual (DWD0, 0x5AA55AA4))
5187                     {   Return (2)  }
5188
5189             //  set memory contents to known values using misaligned field entries
5190             Store (1, BIT1)
5191                 //  verify memory contents using misaligned field entries
5192                 If (LNotEqual (BIT1, 1))
5193                     {   Return (3)  }
5194                 //  verify memory contents using aligned field entries
5195                 If (LNotEqual (DWD0, 0x5AA55AA6))
5196                     {   Return (4)  }
5197
5198             //  set memory contents to known values using misaligned field entries
5199             Store (0, BIT2)
5200                 //  verify memory contents using misaligned field entries
5201                 If (LNotEqual (BIT2, 0))
5202                     {   Return (5)  }
5203                 //  verify memory contents using aligned field entries
5204                 If (LNotEqual (DWD0, 0x5AA55AA2))
5205                     {   Return (6)  }
5206
5207             //  set memory contents to known values using misaligned field entries
5208             Store (1, BIT3)
5209                 //  verify memory contents using misaligned field entries
5210                 If (LNotEqual (BIT3, 1))
5211                     {   Return (7)  }
5212                 //  verify memory contents using aligned field entries
5213                 If (LNotEqual (DWD0, 0x5AA55AAA))
5214                     {   Return (8)  }
5215
5216             //  set memory contents to known values using misaligned field entries
5217             Store (1, BIT4)
5218                 //  verify memory contents using misaligned field entries
5219                 If (LNotEqual (BIT4, 1))
5220                     {   Return (9)  }
5221                 //  verify memory contents using aligned field entries
5222                 If (LNotEqual (DWD0, 0x5AA55ABA))
5223                     {   Return (10) }
5224
5225             //  set memory contents to known values using misaligned field entries
5226             Store (0, BIT5)
5227                 //  verify memory contents using misaligned field entries
5228                 If (LNotEqual (BIT5, 0))
5229                     {   Return (11) }
5230                 //  verify memory contents using aligned field entries
5231                 If (LNotEqual (DWD0, 0x5AA55A9A))
5232                     {   Return (12) }
5233
5234             //  set memory contents to known values using misaligned field entries
5235             Store (1, BIT6)
5236                 //  verify memory contents using misaligned field entries
5237                 If (LNotEqual (BIT6, 1))
5238                     {   Return (13) }
5239                 //  verify memory contents using aligned field entries
5240                 If (LNotEqual (DWD0, 0x5AA55ADA))
5241                     {   Return (14) }
5242
5243             //  set memory contents to known values using misaligned field entries
5244             Store (0, BIT7)
5245                 //  verify memory contents using misaligned field entries
5246                 If (LNotEqual (BIT7, 0))
5247                     {   Return (15) }
5248                 //  verify memory contents using aligned field entries
5249                 If (LNotEqual (DWD0, 0x5AA55A5A))
5250                     {   Return (16) }
5251
5252             //  set memory contents to known values using misaligned field entries
5253             Store (1, BIT8)
5254                 //  verify memory contents using misaligned field entries
5255                 If (LNotEqual (BIT8, 1))
5256                     {   Return (17) }
5257                 //  verify memory contents using aligned field entries
5258                 If (LNotEqual (DWD0, 0x5AA55B5A))
5259                     {   Return (18) }
5260
5261             //  set memory contents to known values using misaligned field entries
5262             Store (0, BIT9)
5263                 //  verify memory contents using misaligned field entries
5264                 If (LNotEqual (BIT9, 0))
5265                     {   Return (19) }
5266                 //  verify memory contents using aligned field entries
5267                 If (LNotEqual (DWD0, 0x5AA5595A))
5268                     {   Return (20) }
5269
5270             //  set memory contents to known values using misaligned field entries
5271             Store (1, BITA)
5272                 //  verify memory contents using misaligned field entries
5273                 If (LNotEqual (BITA, 1))
5274                     {   Return (21) }
5275                 //  verify memory contents using aligned field entries
5276                 If (LNotEqual (DWD0, 0x5AA55D5A))
5277                     {   Return (22) }
5278
5279             //  set memory contents to known values using misaligned field entries
5280             Store (0, BITB)
5281                 //  verify memory contents using misaligned field entries
5282                 If (LNotEqual (BITB, 0))
5283                     {   Return (23) }
5284                 //  verify memory contents using aligned field entries
5285                 If (LNotEqual (DWD0, 0x5AA5555A))
5286                     {   Return (24) }
5287
5288             //  set memory contents to known values using misaligned field entries
5289             Store (0, BITC)
5290                 //  verify memory contents using misaligned field entries
5291                 If (LNotEqual (BITC, 0))
5292                     {   Return (25) }
5293                 //  verify memory contents using aligned field entries
5294                 If (LNotEqual (DWD0, 0x5AA5455A))
5295                     {   Return (26) }
5296
5297             //  set memory contents to known values using misaligned field entries
5298             Store (1, BITD)
5299                 //  verify memory contents using misaligned field entries
5300                 If (LNotEqual (BITD, 1))
5301                     {   Return (27) }
5302                 //  verify memory contents using aligned field entries
5303                 If (LNotEqual (DWD0, 0x5AA5655A))
5304                     {   Return (28) }
5305
5306             //  set memory contents to known values using misaligned field entries
5307             Store (0, BITE)
5308                 //  verify memory contents using misaligned field entries
5309                 If (LNotEqual (BITE, 0))
5310                     {   Return (29) }
5311                 //  verify memory contents using aligned field entries
5312                 If (LNotEqual (DWD0, 0x5AA5255A))
5313                     {   Return (30) }
5314
5315             //  set memory contents to known values using misaligned field entries
5316             Store (1, BITF)
5317                 //  verify memory contents using misaligned field entries
5318                 If (LNotEqual (BITF, 1))
5319                     {   Return (31) }
5320                 //  verify memory contents using aligned field entries
5321                 If (LNotEqual (DWD0, 0x5AA5A55A))
5322                     {   Return (32) }
5323
5324             //  set memory contents to known values using misaligned field entries
5325             Store (0, BI10)
5326                 //  verify memory contents using misaligned field entries
5327                 If (LNotEqual (BI10, 0))
5328                     {   Return (33) }
5329                 //  verify memory contents using aligned field entries
5330                 If (LNotEqual (DWD0, 0x5AA4A55A))
5331                     {   Return (34) }
5332
5333             //  set memory contents to known values using misaligned field entries
5334             Store (1, BI11)
5335                 //  verify memory contents using misaligned field entries
5336                 If (LNotEqual (BI11, 1))
5337                     {   Return (35) }
5338                 //  verify memory contents using aligned field entries
5339                 If (LNotEqual (DWD0, 0x5AA6A55A))
5340                     {   Return (36) }
5341
5342             //  set memory contents to known values using misaligned field entries
5343             Store (0, BI12)
5344                 //  verify memory contents using misaligned field entries
5345                 If (LNotEqual (BI12, 0))
5346                     {   Return (37) }
5347                 //  verify memory contents using aligned field entries
5348                 If (LNotEqual (DWD0, 0x5AA2A55A))
5349                     {   Return (38) }
5350
5351             //  set memory contents to known values using misaligned field entries
5352             Store (1, BI13)
5353                 //  verify memory contents using misaligned field entries
5354                 If (LNotEqual (BI13, 1))
5355                     {   Return (39) }
5356                 //  verify memory contents using aligned field entries
5357                 If (LNotEqual (DWD0, 0x5AAAA55A))
5358                     {   Return (40) }
5359
5360             //  set memory contents to known values using misaligned field entries
5361             Store (1, BI14)
5362                 //  verify memory contents using misaligned field entries
5363                 If (LNotEqual (BI14, 1))
5364                     {   Return (41) }
5365                 //  verify memory contents using aligned field entries
5366                 If (LNotEqual (DWD0, 0x5ABAA55A))
5367                     {   Return (42) }
5368
5369             //  set memory contents to known values using misaligned field entries
5370             Store (0, BI15)
5371                 //  verify memory contents using misaligned field entries
5372                 If (LNotEqual (BI15, 0))
5373                     {   Return (43) }
5374                 //  verify memory contents using aligned field entries
5375                 If (LNotEqual (DWD0, 0x5A9AA55A))
5376                     {   Return (44) }
5377
5378             //  set memory contents to known values using misaligned field entries
5379             Store (1, BI16)
5380                 //  verify memory contents using misaligned field entries
5381                 If (LNotEqual (BI16, 1))
5382                     {   Return (45) }
5383                 //  verify memory contents using aligned field entries
5384                 If (LNotEqual (DWD0, 0x5ADAA55A))
5385                     {   Return (46) }
5386
5387             //  set memory contents to known values using misaligned field entries
5388             Store (0, BI17)
5389                 //  verify memory contents using misaligned field entries
5390                 If (LNotEqual (BI17, 0))
5391                     {   Return (47) }
5392                 //  verify memory contents using aligned field entries
5393                 If (LNotEqual (DWD0, 0x5A5AA55A))
5394                     {   Return (48) }
5395
5396             //  set memory contents to known values using misaligned field entries
5397             Store (1, BI18)
5398                 //  verify memory contents using misaligned field entries
5399                 If (LNotEqual (BI18, 1))
5400                     {   Return (49) }
5401                 //  verify memory contents using aligned field entries
5402                 If (LNotEqual (DWD0, 0x5B5AA55A))
5403                     {   Return (50) }
5404
5405             //  set memory contents to known values using misaligned field entries
5406             Store (0, BI19)
5407                 //  verify memory contents using misaligned field entries
5408                 If (LNotEqual (BI19, 0))
5409                     {   Return (51) }
5410                 //  verify memory contents using aligned field entries
5411                 If (LNotEqual (DWD0, 0x595AA55A))
5412                     {   Return (52) }
5413
5414             //  set memory contents to known values using misaligned field entries
5415             Store (1, BI1A)
5416                 //  verify memory contents using misaligned field entries
5417                 If (LNotEqual (BI1A, 1))
5418                     {   Return (53) }
5419                 //  verify memory contents using aligned field entries
5420                 If (LNotEqual (DWD0, 0x5D5AA55A))
5421                     {   Return (54) }
5422
5423             //  set memory contents to known values using misaligned field entries
5424             Store (0, BI1B)
5425                 //  verify memory contents using misaligned field entries
5426                 If (LNotEqual (BI1B, 0))
5427                     {   Return (55) }
5428                 //  verify memory contents using aligned field entries
5429                 If (LNotEqual (DWD0, 0x555AA55A))
5430                     {   Return (56) }
5431
5432             //  set memory contents to known values using misaligned field entries
5433             Store (0, BI1C)
5434                 //  verify memory contents using misaligned field entries
5435                 If (LNotEqual (BI1C, 0))
5436                     {   Return (57) }
5437                 //  verify memory contents using aligned field entries
5438                 If (LNotEqual (DWD0, 0x455AA55A))
5439                     {   Return (58) }
5440
5441             //  set memory contents to known values using misaligned field entries
5442             Store (1, BI1D)
5443                 //  verify memory contents using misaligned field entries
5444                 If (LNotEqual (BI1D, 1))
5445                     {   Return (59) }
5446                 //  verify memory contents using aligned field entries
5447                 If (LNotEqual (DWD0, 0x655AA55A))
5448                     {   Return (60) }
5449
5450             //  set memory contents to known values using misaligned field entries
5451             Store (0, BI1E)
5452                 //  verify memory contents using misaligned field entries
5453                 If (LNotEqual (BI1E, 0))
5454                     {   Return (61) }
5455                 //  verify memory contents using aligned field entries
5456                 If (LNotEqual (DWD0, 0x255AA55A))
5457                     {   Return (62) }
5458
5459             //  set memory contents to known values using misaligned field entries
5460             Store (1, BI1F)
5461                 //  verify memory contents using misaligned field entries
5462                 If (LNotEqual (BI1F, 1))
5463                     {   Return (63) }
5464                 //  verify memory contents using aligned field entries
5465                 If (LNotEqual (DWD0, 0xA55AA55A))
5466                     {   Return (64) }
5467
5468
5469             //  set memory contents to known values using misaligned field entries
5470             Store (3, B2_0)
5471                 //  verify memory contents using misaligned field entries
5472                 If (LNotEqual (B2_0, 3))
5473                     {   Return (65) }
5474                 //  verify memory contents using aligned field entries
5475                 If (LNotEqual (DWD0, 0xA55AA55B))
5476                     {   Return (66) }
5477
5478             //  set memory contents to known values using misaligned field entries
5479             Store (1, B2_1)
5480                 //  verify memory contents using misaligned field entries
5481                 If (LNotEqual (B2_1, 1))
5482                     {   Return (67) }
5483                 //  verify memory contents using aligned field entries
5484                 If (LNotEqual (DWD0, 0xA55AA557))
5485                     {   Return (68) }
5486
5487             //  set memory contents to known values using misaligned field entries
5488             Store (0, B2_2)
5489                 //  verify memory contents using misaligned field entries
5490                 If (LNotEqual (B2_2, 0))
5491                     {   Return (69) }
5492                 //  verify memory contents using aligned field entries
5493                 If (LNotEqual (DWD0, 0xA55AA547))
5494                     {   Return (70) }
5495
5496             //  set memory contents to known values using misaligned field entries
5497             Store (3, B2_3)
5498                 //  verify memory contents using misaligned field entries
5499                 If (LNotEqual (B2_3, 3))
5500                     {   Return (71) }
5501                 //  verify memory contents using aligned field entries
5502                 If (LNotEqual (DWD0, 0xA55AA5C7))
5503                     {   Return (72) }
5504
5505             //  set memory contents to known values using misaligned field entries
5506             Store (3, B2_4)
5507                 //  verify memory contents using misaligned field entries
5508                 If (LNotEqual (B2_4, 3))
5509                     {   Return (73) }
5510                 //  verify memory contents using aligned field entries
5511                 If (LNotEqual (DWD0, 0xA55AA7C7))
5512                     {   Return (74) }
5513
5514             //  set memory contents to known values using misaligned field entries
5515             Store (0, B2_5)
5516                 //  verify memory contents using misaligned field entries
5517                 If (LNotEqual (B2_5, 0))
5518                     {   Return (75) }
5519                 //  verify memory contents using aligned field entries
5520                 If (LNotEqual (DWD0, 0xA55AA3C7))
5521                     {   Return (76) }
5522
5523             //  set memory contents to known values using misaligned field entries
5524             Store (1, B2_6)
5525                 //  verify memory contents using misaligned field entries
5526                 If (LNotEqual (B2_6, 1))
5527                     {   Return (77) }
5528                 //  verify memory contents using aligned field entries
5529                 If (LNotEqual (DWD0, 0xA55A93C7))
5530                     {   Return (78) }
5531
5532             //  set memory contents to known values using misaligned field entries
5533             Store (1, B2_7)
5534                 //  verify memory contents using misaligned field entries
5535                 If (LNotEqual (B2_7, 1))
5536                     {   Return (79) }
5537                 //  verify memory contents using aligned field entries
5538                 If (LNotEqual (DWD0, 0xA55A53C7))
5539                     {   Return (80) }
5540
5541             //  set memory contents to known values using misaligned field entries
5542             Store (0, B2_8)
5543                 //  verify memory contents using misaligned field entries
5544                 If (LNotEqual (B2_8, 0))
5545                     {   Return (81) }
5546                 //  verify memory contents using aligned field entries
5547                 If (LNotEqual (DWD0, 0xA55853C7))
5548                     {   Return (82) }
5549
5550             //  set memory contents to known values using misaligned field entries
5551             Store (1, B2_9)
5552                 //  verify memory contents using misaligned field entries
5553                 If (LNotEqual (B2_9, 1))
5554                     {   Return (83) }
5555                 //  verify memory contents using aligned field entries
5556                 If (LNotEqual (DWD0, 0xA55453C7))
5557                     {   Return (84) }
5558
5559             //  set memory contents to known values using misaligned field entries
5560             Store (2, B2_A)
5561                 //  verify memory contents using misaligned field entries
5562                 If (LNotEqual (B2_A, 2))
5563                     {   Return (85) }
5564                 //  verify memory contents using aligned field entries
5565                 If (LNotEqual (DWD0, 0xA56453C7))
5566                     {   Return (86) }
5567
5568             //  set memory contents to known values using misaligned field entries
5569             Store (2, B2_B)
5570                 //  verify memory contents using misaligned field entries
5571                 If (LNotEqual (B2_B, 2))
5572                     {   Return (87) }
5573                 //  verify memory contents using aligned field entries
5574                 If (LNotEqual (DWD0, 0xA5A453C7))
5575                     {   Return (88) }
5576
5577             //  set memory contents to known values using misaligned field entries
5578             Store (3, B2_C)
5579                 //  verify memory contents using misaligned field entries
5580                 If (LNotEqual (B2_C, 3))
5581                     {   Return (89) }
5582                 //  verify memory contents using aligned field entries
5583                 If (LNotEqual (DWD0, 0xA7A453C7))
5584                     {   Return (90) }
5585
5586             //  set memory contents to known values using misaligned field entries
5587             Store (3, B2_D)
5588                 //  verify memory contents using misaligned field entries
5589                 If (LNotEqual (B2_D, 3))
5590                     {   Return (91) }
5591                 //  verify memory contents using aligned field entries
5592                 If (LNotEqual (DWD0, 0xAFA453C7))
5593                     {   Return (92) }
5594
5595             //  set memory contents to known values using misaligned field entries
5596             Store (1, B2_E)
5597                 //  verify memory contents using misaligned field entries
5598                 If (LNotEqual (B2_E, 1))
5599                     {   Return (93) }
5600                 //  verify memory contents using aligned field entries
5601                 If (LNotEqual (DWD0, 0x9FA453C7))
5602                     {   Return (94) }
5603
5604             //  set memory contents to known values using misaligned field entries
5605             Store (0, B2_F)
5606                 //  verify memory contents using misaligned field entries
5607                 If (LNotEqual (B2_F, 0))
5608                     {   Return (95) }
5609                 //  verify memory contents using aligned field entries
5610                 If (LNotEqual (DWD0, 0x1FA453C7))
5611                     {   Return (96) }
5612
5613
5614             Return (0)  //  pass
5615         }   //  MADM:   Misaligned Dynamic RAM SystemMemory OperationRegion
5616
5617         Method (TEST)
5618         {
5619             Store ("++++++++ IndexOp4 Test", Debug)
5620
5621             //  MADM (Misaligned Dynamic RAM SystemMemory OperationRegion) arguments:
5622             //      Arg0    --  SystemMemory OperationRegion base address
5623             Store (MADM (0x800000), Local0)
5624             If (LNotEqual (Local0, 0))      //  MADM returns zero if successful
5625                 {   Return (Local0) }       //  failure:    return MADM error code
5626
5627             Return (Local0)
5628         }   //  TEST
5629     }   //  IDX4
5630
5631 //
5632 // test Event.asl
5633 //
5634 //  EventOp, ResetOp, SignalOp, and WaitOp test cases.
5635 //
5636     Device (EVNT)
5637     {
5638         Event (EVNT)    //  event synchronization object
5639
5640         Method (TEVN, 1)
5641         //  Arg0:   time to Wait for event in milliseconds
5642         {   //  TEVN control method to test ResetOp, SignalOp, and WaitOp
5643             //  reset EVNT to initialization (zero) state
5644             Reset (EVNT)
5645
5646             //  prime EVNT with two outstanding signals
5647             Signal (EVNT)
5648             Signal (EVNT)
5649
5650
5651             //  acquire existing signal
5652             Store (Wait (EVNT, Arg0), Local0)
5653
5654             //  validate Local0 is a Number
5655             Store (ObjectType (Local0), Local1)
5656             If (LNotEqual (Local1, 1))  //  Number is type 1
5657                 {   Return (0x21)   }       //  Local1 indicates Local0 is not a Number
5658
5659             If (LNotEqual (Local0, 0))  //  Number is type 1
5660                 {   Return (0x22)   }       //  timeout occurred without acquiring signal
5661
5662             Store ("Acquire 1st existing signal PASS", Debug)
5663
5664
5665             //  acquire existing signal
5666             Store (Wait (EVNT, Arg0), Local0)
5667
5668             //  validate Local0 is a Number
5669             Store (ObjectType (Local0), Local1)
5670             If (LNotEqual (Local1, 1))  //  Number is type 1
5671                 {   Return (0x31)   }       //  Local1 indicates Local0 is not a Number
5672
5673             If (LNotEqual (Local0, 0))  //  Number is type 1
5674                 {   Return (0x32)   }       //  timeout occurred without acquiring signal
5675
5676             Store ("Acquire 2nd existing signal PASS", Debug)
5677
5678
5679             //  ensure WaitOp timeout test cases do not hang
5680             if (LEqual (Arg0, 0xFFFF))
5681                 {   Store (0xFFFE, Arg0)    }
5682
5683             //  acquire non-existing signal
5684             Store (Wait (EVNT, Arg0), Local0)
5685
5686             //  validate Local0 is a Number
5687             Store (ObjectType (Local0), Local1)
5688             If (LNotEqual (Local1, 1))  //  Number is type 1
5689                 {   Return (0x41)   }       //  Local1 indicates Local0 is not a Number
5690
5691             If (LEqual (Local0, 0))     //  Number is type 1
5692                 {   Return (0x42)   }       //  non-existant signal was acquired
5693
5694             Store ("Acquire signal timeout PASS", Debug)
5695
5696
5697             //  prime EVNT with two outstanding signals
5698             Signal (EVNT)
5699             Signal (EVNT)
5700
5701             //  reset EVNT to initialization (zero) state
5702             Reset (EVNT)
5703
5704             //  acquire non-existing signal
5705             Store (Wait (EVNT, Arg0), Local0)
5706
5707             //  validate Local0 is a Number
5708             Store (ObjectType (Local0), Local1)
5709             If (LNotEqual (Local1, 1))  //  Number is type 1
5710                 {   Return (0x51)   }       //  Local1 indicates Local0 is not a Number
5711
5712             If (LEqual (Local0, 0))     //  Number is type 1
5713                 {   Return (0x52)   }       //  non-existant signal was acquired
5714
5715             Store ("Reset signal PASS", Debug)
5716
5717
5718             //  acquire non-existing signal using Lvalue timeout
5719             Store (Wait (EVNT, Zero), Local0)
5720
5721             //  validate Local0 is a Number
5722             Store (ObjectType (Local0), Local1)
5723             If (LNotEqual (Local1, 1))  //  Number is type 1
5724                 {   Return (0x61)   }       //  Local1 indicates Local0 is not a Number
5725
5726             If (LEqual (Local0, 0))     //  Number is type 1
5727                 {   Return (0x62)   }       //  non-existant signal was acquired
5728
5729             Store ("Zero Lvalue PASS", Debug)
5730
5731
5732             //  acquire non-existing signal using Lvalue timeout
5733             Store (Wait (EVNT, One), Local0)
5734
5735             //  validate Local0 is a Number
5736             Store (ObjectType (Local0), Local1)
5737             If (LNotEqual (Local1, 1))  //  Number is type 1
5738                 {   Return (0x71)   }       //  Local1 indicates Local0 is not a Number
5739
5740             If (LEqual (Local0, 0))     //  Number is type 1
5741                 {   Return (0x72)   }       //  non-existant signal was acquired
5742
5743             Store ("One Lvalue PASS", Debug)
5744
5745             //  Lvalue Event test cases
5746     // ILLEGAL SOURCE OPERAND        Store (EVNT, Local2)
5747
5748             //  validate Local2 is an Event
5749             Store (ObjectType (EVNT), Local1)
5750             If (LNotEqual (Local1, 7))  //  Event is type 7
5751                 {   Return (0x81)   }       //  Local1 indicates Local0 is not a Number
5752
5753             //  reset EVNT to initialization (zero) state
5754             Reset (EVNT)
5755
5756             //  prime EVNT with two outstanding signals
5757             Signal (EVNT)
5758
5759             //  acquire existing signal
5760             Store (Wait (EVNT, Arg0), Local0)
5761
5762             //  validate Local0 is a Number
5763             Store (ObjectType (Local0), Local1)
5764             If (LNotEqual (Local1, 1))  //  Number is type 1
5765                 {   Return (0x82)   }       //  Local1 indicates Local0 is not a Number
5766
5767             If (LNotEqual (Local0, 0))  //  Number is type 1
5768                 {   Return (0x83)   }       //  timeout occurred without acquiring signal
5769
5770             Store ("Acquire Lvalue existing signal PASS", Debug)
5771
5772
5773             //  acquire non-existing signal
5774             Store (Wait (EVNT, Arg0), Local0)
5775
5776             //  validate Local0 is a Number
5777             Store (ObjectType (Local0), Local1)
5778             If (LNotEqual (Local1, 1))  //  Number is type 1
5779                 {   Return (0x84)   }       //  Local1 indicates Local0 is not a Number
5780
5781             If (LEqual (Local0, 0))     //  Number is type 1
5782                 {   Return (0x85)   }       //  non-existant signal was acquired
5783
5784             Store ("Acquire Lvalue signal timeout PASS", Debug)
5785
5786
5787             Return (0)  //  success
5788         }   //  TEVN control method to test ResetOp, SignalOp, and WaitOp
5789
5790         Method (TEST)
5791         {
5792             Store ("++++++++ Event Test", Debug)
5793
5794             Store (TEVN (100), Local0)
5795
5796             Return (Local0)
5797         }   //  TEST
5798     }   //  EVNT
5799
5800 //
5801 // test SizeOfLv.asl
5802 //
5803 //  Test for SizeOf (Lvalue)
5804 //
5805 //  This next section will contain the packages that the SizeOfOp will be
5806 //  exercised on.  The first one, PKG0, is a regular package of 3 elements.
5807 //  The 2nd one, PKG1, is a nested package with 3 packages inside it, each
5808 //  with 3 elements.  It is expected that SizeOf operator will return the
5809 //  same value for these two packages since they both have 3 elements.  The
5810 //  final package, PKG2, has 4 elements and the SizeOf operator is expected
5811 //  to return different results for this package.
5812
5813     Name (PKG0,
5814         Package (3)
5815         {0x0123, 0x4567, 0x89AB}
5816     )   //  PKG0
5817
5818     Name (PKG1,
5819         Package (3)
5820         {
5821             Package (3) {0x0123, 0x4567, 0x89AB},
5822             Package (3) {0xCDEF, 0xFEDC, 0xBA98},
5823             Package (3) {0x7654, 0x3210, 0x1234}
5824         }
5825     )   //  PKG1
5826
5827     Name (PKG2,
5828         Package (4)
5829         {0x0123, 0x4567, 0x89AB, 0x8888}
5830     )   //  PKG2
5831
5832     Name (PKG3,
5833         Package (5)
5834         {0x0123, 0x4567, 0x89AB, 0x8888, 0x7777}
5835     )   //  PKG3
5836
5837 //  End Packages    **********************************************************
5838
5839 //  The following section will declare the data strings that will be used to
5840 //  exercise the SizeOf operator.  STR0 and STR1 are expected to be equal,
5841 //  STR2 is expected to have a different SizeOf value than STR0 and STR1.
5842
5843     Name (STR0, "ACPI permits very flexible methods of expressing a system")
5844
5845     Name (STR1, "MIKE permits very flexible methods of expressing a system")
5846
5847     Name (STR2, "Needless to say, Mike and ACPI are frequently at odds")
5848
5849 //  This string is being made in case we want to do a SizeOf comparison
5850 //  between strings and packages or buffers
5851     Name (STR3, "12345")
5852
5853 //  End Strings     **********************************************************
5854
5855 //  The following section will declare the buffers that will be used to exercise
5856 //  the SizeOf operator.
5857
5858     Name (BUF0, Buffer (10) {})
5859     Name (BUF1, Buffer (10) {})
5860     Name (BUF2, Buffer (8)  {})
5861     Name (BUF3, Buffer (5)  {})
5862
5863 //  End Buffers     **********************************************************
5864     Device (SZLV)
5865     {
5866
5867         Method (CMPR, 2)
5868         {
5869             //  CMPR is passed two arguments.  If unequal, return 1 to indicate
5870             //  that, otherwise return 0 to indicate SizeOf each is equal.
5871
5872             Store (0x01, Local0)
5873
5874             if (LEqual (SizeOf(Arg0), SizeOf(Arg1)))
5875             {
5876                 Store (0x00, Local0)
5877             }
5878
5879             return (Local0)
5880         }   //  CMPR
5881
5882
5883         Method (TEST)
5884         {
5885
5886             Store ("++++++++ SizeOfLv Test", Debug)
5887
5888             //  TBD:    SizeOf ("string")
5889             //          SizeOf (Buffer)
5890             //          SizeOf (Package)
5891             //          SizeOf (String)
5892             //          SizeOf (STR0)   --  where Name (STR0,...) -- lot's of cases
5893             //              buffer, string, package,
5894             //          SizeOf (METH) -- where METH control method returns
5895             //              buffer, string, package,
5896
5897             //  TBD:    SLOC [SizeOf (Local0)] -- dup SARG
5898
5899             //  Compare the elements that we expect to be the same.  Exit out with an error
5900             //  code on the first failure.
5901             if (LNotEqual (0x00, CMPR (STR0, STR1)))
5902             {
5903                 Return (0x01)
5904             }
5905
5906             if (LNotEqual (0x00, CMPR (STR3, BUF3)))
5907             {
5908                 Return (0x02)
5909             }
5910
5911             if (LNotEqual (0x00, CMPR (STR3, PKG3)))
5912             {
5913                 Return (0x03)
5914             }
5915
5916             //  In the following section, this test will cover the SizeOf
5917             //  operator for Local values.
5918             //  In this case, both Local0 and Local1 should have the same Size
5919             Store (STR0, Local0)
5920             Store (STR1, Local1)
5921
5922             if (LNotEqual (SizeOf (Local0), SizeOf (Local1)))
5923             {
5924                 Return (0x04)
5925             }
5926
5927             //  Now create a case where Local0 and Local1 are different
5928             Store (STR2, Local1)
5929
5930             if (LEqual (SizeOf (Local0), SizeOf (Local1)))
5931             {
5932                 Return (0x05)
5933             }
5934
5935             //  Finally, check for the return of SizeOf for a known Buffer.  Just
5936             //  in case we magically pass above cases due to all Buffers being Zero
5937             //  bytes in size, or Infinity, etc.
5938             if (LNotEqual (0x05, SizeOf (BUF3)))
5939             {
5940                 Return (0x06)
5941             }
5942
5943             Return (0)
5944         }   //  TEST
5945     }   //  SZLV
5946
5947
5948 //
5949 // test BytField.asl
5950 //
5951 //  BytField test
5952 //      This is just a subset of the many RegionOp/Index Field test cases.
5953 //      Tests access of TBD.
5954 //
5955     Scope (\_SB)    //  System Bus
5956     {   //  _SB system bus
5957         Device (BYTF)
5958         {   //  Test device name
5959             Method (TEST)
5960             {
5961                 Store ("++++++++ BytField Test", Debug)
5962
5963                 Return (\_TZ.C19B.RSLT)
5964             }   //  TEST
5965         }   //  BYTF
5966
5967         Device (C005)
5968         {   //  Device C005
5969             Device (C013)
5970             {   //  Device C013
5971             }   //  Device C013
5972         }   //  Device C005
5973
5974         Method (C115)
5975         {   //  C115 control method
5976             Acquire (\_GL, 0xFFFF)
5977             Store (\_SB.C005.C013.C058.C07E, Local0)
5978             Release (\_GL)
5979             And (Local0, 16, Local0)
5980             Store (ShiftRight (Local0, 4, ), Local1)
5981             If (LEqual (Local1, 0))
5982                 {   Return (1)  }
5983             Else
5984                 {   Return (0)  }
5985         }   //  C115 control method
5986     }   //  _SB system bus
5987
5988     OperationRegion (C018, SystemIO, 0x5028, 4)
5989     Field (C018, AnyAcc, NoLock, Preserve)
5990     {   //  Field overlaying C018
5991         C019,   32
5992     }   //  Field overlaying C018
5993
5994     OperationRegion (C01A, SystemIO, 0x5030, 4)
5995     Field (C01A, ByteAcc, NoLock, Preserve)
5996     {   //  Field overlaying C01A
5997         C01B,   8,
5998         C01C,   8,
5999         C01D,   8,
6000         C01E,   8
6001     }   //  Field overlaying C01A
6002
6003     Mutex (\C01F, 0)
6004     Name (\C020, 0)
6005     Name (\C021, 0)
6006
6007     Method (\C022, 0)
6008     {   //  \C022 control method
6009         Acquire (\C01F, 0xFFFF)
6010         If (LEqual (\C021, 0))
6011         {
6012             Store (C019, Local0)
6013             And (Local0, 0xFFFEFFFE, Local0)
6014             Store (Local0, C019)
6015             Increment (\C021)
6016         }
6017         Release (\C01F)
6018     }   //  \C022 control method
6019
6020     Scope (\_SB.C005.C013)
6021     {   //  Scope \_SB.C005.C013
6022         Device (C058)
6023         {   //  Device C058
6024             Name (_HID, "*PNP0A06")
6025
6026             OperationRegion (C059, SystemIO, 0xE0, 2)
6027             Field (C059, ByteAcc, NoLock, Preserve)
6028             {   //  Field overlaying C059
6029                 C05A,   8,
6030                 C05B,   8
6031             }   //  Field overlaying C059
6032
6033             OperationRegion (C05C, SystemIO, 0xE2, 2)
6034             Field (C05C, ByteAcc, NoLock, Preserve)
6035             {   //  Field overlaying C05C
6036                 C05D,   8,
6037                 C05E,   8
6038             }   //  Field overlaying C05C
6039             IndexField (C05D, C05E, ByteAcc, NoLock, Preserve)
6040             {   //  IndexField overlaying C05D/C05E
6041                 ,       0x410,  //  skip
6042                 C05F,   8,
6043                 C060,   8,
6044                 C061,   8,
6045                 C062,   8,
6046                 C063,   8,
6047                 C064,   8,
6048                 C065,   8,
6049                 C066,   8,
6050                 C067,   8,
6051                 C068,   8,
6052                 C069,   8,
6053                 C06A,   8,
6054                 C06B,   8,
6055                 C06C,   8,
6056                 C06D,   8,
6057                 C06E,   8,
6058                 ,       0x70,       //  skip
6059                 C06F,   8,
6060                 C070,   8,
6061                 C071,   8,
6062                 C072,   8,
6063                 C073,   8,
6064                 C074,   8,
6065                 C075,   8,
6066                 C076,   8,
6067                 C077,   8,
6068                 C078,   8,
6069                 C079,   8,
6070                 C07A,   8,
6071                 C07B,   8,
6072                 C07C,   8,
6073                 C07D,   8,
6074                 C07E,   8
6075             }   //  IndexField overlaying C05D/C05E
6076
6077             OperationRegion (C07F, SystemIO, 0xE4, 2)
6078             Field (C07F, ByteAcc, NoLock, Preserve)
6079             {   //  Field overlaying C07F
6080                 C080,   8,
6081                 C081,   8
6082             }   //  Field overlaying C07F
6083
6084             OperationRegion (C082, SystemIO, 0xE0, 1)
6085             Field (C082, ByteAcc, NoLock, Preserve)
6086             {   //  Field overlaying C082
6087                 C083,   8
6088             }   //  Field overlaying C082
6089
6090             OperationRegion (C084, SystemIO, 0xFF, 1)
6091             Field (C084, ByteAcc, NoLock, Preserve)
6092             {   //  Field overlaying C084
6093                 C085,   8
6094             }   //  Field overlaying C084
6095
6096             OperationRegion (C086, SystemIO, 0xFD, 1)
6097             Field (C086, ByteAcc, NoLock, Preserve)
6098             {   //  Field overlaying C086
6099                 C087,   8
6100             }   //  Field overlaying C086
6101
6102             Mutex (C088, 0)
6103             Mutex (C089, 0)
6104             Mutex (C08A, 0)
6105             Mutex (C08B, 0)
6106             Mutex (C08C, 0)
6107             Mutex (C08D, 0)
6108
6109             Name (C08E, 0xFFFFFFFD)
6110             Name (C08F, 0)
6111
6112             Method (C0AA, 4)
6113             {   //  C0AA control method
6114                 Store (Buffer (4) {}, Local7)
6115                 CreateByteField (Local7, 0, C0AB)
6116                 CreateByteField (Local7, 1, C0AC)
6117                 CreateByteField (Local7, 2, C0AD)
6118                 CreateByteField (Local7, 3, C0AE)
6119                 Acquire (^C08B, 0xFFFF)
6120                 Acquire (\_GL, 0xFFFF)
6121                 \C022 ()
6122                 Store (1, \_SB.C005.C013.C058.C06B)
6123                 While (LNot (LEqual (0, \_SB.C005.C013.C058.C06B)))
6124                     {   Stall (100) }
6125                 Store (Arg3, \_SB.C005.C013.C058.C06E)
6126                 Store (Arg2, \_SB.C005.C013.C058.C06D)
6127                 Store (Arg1, \_SB.C005.C013.C058.C06C)
6128                 Store (Arg0, \_SB.C005.C013.C058.C06B)
6129                 While (LNot (LEqual (0, \_SB.C005.C013.C058.C06B)))
6130                     {   Stall (100) }
6131                 Store (\_SB.C005.C013.C058.C06E, C0AB)
6132                 Store (\_SB.C005.C013.C058.C06D, C0AC)
6133                 Store (\_SB.C005.C013.C058.C06C, C0AD)
6134                 Store (\_SB.C005.C013.C058.C06B, C0AE)
6135                 If (LNot (LEqual (Arg0, 23)))
6136                 {
6137                     Store (2, \_SB.C005.C013.C058.C06B)
6138                     Stall (100)
6139                 }
6140                 Release (\_GL)
6141                 Release (^C08B)
6142                 Return (Local7)
6143             }   //  C0AA control method
6144         }   //  Device C058
6145     }   //  Scope \_SB.C005.C013
6146
6147     Scope (\_TZ)
6148     {   //  \_TZ thermal zone scope
6149         Name (C18B, Package (2)
6150         {
6151             Package (2)
6152             {
6153                 Package (5) {0x05AC, 0x0CD2, 0x0D68, 0x0DE0, 0x0E4E},
6154                 Package (5) {0x0D04, 0x0D9A, 0x0DFE, 0x0E80, 0x0FA2}
6155             },
6156             Package (2)
6157             {
6158                 Package (5) {0x05AC, 0x0CD2, 0x0D68, 0x0DE0, 0x0E4E},
6159                 Package (5) {0x0D04, 0x0D9A, 0x0DFE, 0x0E80, 0x0FA2}
6160             }
6161         })  //  C18B
6162
6163         Name (C18C, Package (2)
6164         {
6165             Package (2)
6166             {
6167                 Package (3) {0x64, 0x4B, 0x32},
6168                 Package (3) {0x64, 0x4B, 0x32}
6169             }
6170         })  //  C81C
6171
6172         Name (C18D, 0)
6173         Name (C18E, 0)
6174         Name (C18F, 0)
6175         Name (C190, 0)
6176         Name (C191, 3)
6177         Name (C192, 0)
6178         Name (C193, 1)
6179         Name (C194, 2)
6180         Mutex (C195, 0)
6181         Name (C196, 1)
6182         Name (C197, 0x0B9C)
6183         Name (C198, 0x0B9C)
6184         Name (C199, 0xFFFFFFFD)
6185         Name (C19A, 0)
6186
6187         Device (C19B)
6188         {   //  Device C19B
6189             Name (RSLT, 0)  //  default to zero
6190
6191             Method (XINI)
6192             {   //  _INI control method (Uses Global Lock -- can't run under AcpiExec)
6193                 Store (\_SB.C115, C19A)
6194                 \_TZ.C19C._SCP (0)
6195                 Subtract (0x0EB2, 0x0AAC, Local1)   //  Local1 = AACh - EB2h
6196                 Divide (Local1, 10, Local0, Local2) //  Local0 = Local1 / 10
6197                                                                 //  Local2 = Local1 % 10
6198                 \_SB.C005.C013.C058.C0AA (14, Local2, 0, 0)
6199                 Store
6200                     (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 0, )), C18D)
6201                 Store
6202                     (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 1, )), C18E)
6203                 Store
6204                     (DerefOf (Index (DerefOf (Index (\_TZ.C18C, C19A, )), 2, )), C18F)
6205
6206                 Store (1, RSLT) //  set RSLT to 1 if _INI control method completes
6207             }   //  _INI control method
6208
6209             //  PowerResource (C19D) {...}
6210         }   //  Device C19B
6211
6212         ThermalZone (C19C)
6213         {
6214             Method (_SCP, 1)
6215             {   //  _SCP control method
6216                 Store (Arg0, Local0)
6217                 If (LEqual (Local0, 0))
6218                 {
6219                     Store (0, \_TZ.C192)
6220                     Store (1, \_TZ.C193)
6221                     Store (2, \_TZ.C194)
6222                     Store (3, \_TZ.C191)
6223                 }
6224                 Else
6225                 {
6226                     Store (0, \_TZ.C191)
6227                     Store (1, \_TZ.C192)
6228                     Store (2, \_TZ.C193)
6229                     Store (3, \_TZ.C194)
6230                 }
6231             }   //  _SCP control method
6232         }   //  ThermalZone C19C
6233     }   //  \_TZ thermal zone scope
6234
6235
6236 //
6237 // test DwrdFld.asl
6238 //
6239     Name (BUFR, buffer(10) {0,0,0,0,0,0,0,0,0,0} )
6240
6241     Device (DWDF)
6242     {
6243         Method (TEST)
6244         {
6245             Store ("++++++++ DwrdFld Test", Debug)
6246
6247             CreateByteField (BUFR, 0, BYTE)
6248             Store (0xAA, BYTE)
6249
6250             CreateWordField (BUFR, 1, WORD)
6251             Store (0xBBCC, WORD)
6252
6253             CreateDWordField (BUFR, 3, DWRD)
6254             Store (0xDDEEFF00, DWRD)
6255
6256             CreateByteField (BUFR, 7, BYT2)
6257             Store (0x11, BYT2)
6258
6259             CreateWordField (BUFR, 8, WRD2)
6260             Store (0x2233, WRD2)
6261
6262             Return (0)
6263
6264         }   //  End Method TEST
6265     }   //  Device DWDF
6266
6267     //
6268     // test DivAddx.asl
6269     //
6270     Name (B1LO, 0xAA)
6271     Name (B1HI, 0xBB)
6272
6273     Method (MKW_, 2)
6274     {   //  This control method will take two bytes and make them into a WORD
6275
6276         Multiply (B1HI, 256, Local0)    //  Make high byte.....high
6277         Or (Local0, B1LO, Local0)       //  OR in the low byte
6278         Return (Local0)                 //  Return the WORD
6279
6280     }   //  MKW_
6281
6282     Device (DVAX)
6283     {
6284         Method (TEST)
6285         {
6286
6287             Store ("++++++++ DivAddx Test", Debug)
6288
6289             Store (25, B1LO)
6290             Store (0, B1HI)
6291
6292             //  We'll multiply 25 * 3 to get 75, add 99 to it then divide
6293             //  by 100.  We expect to get 74 for the remainder and 1 for
6294             //  the quotient.
6295             Divide(
6296                 Add (Multiply (3, MKW_ (B1LO, B1HI)), 0x63),
6297                             //  Dividend,
6298                 100,        //  Divisor
6299                 Local4,     //  Remainder
6300                 Local2)     //  Quotient
6301
6302             If (LAnd (LEqual (74, Local4), LEqual (1, Local2)))
6303             {   //  Indicate Pass
6304                 Store (0x00, Local0)
6305             }
6306
6307             Else
6308             {   //  Indicate Fail
6309                 Store (0x01, Local0)
6310             }
6311
6312             Return (Local0)
6313         }   //  End Method TEST
6314     }   //  Device DVAX
6315
6316 //
6317 // test IndexFld.asl (IndexOp6.asl)
6318 //
6319 //  IndexFld test
6320 //      This is just a subset of the many RegionOp/Index Field test cases.
6321 //      Tests index field element AccessAs macro.
6322 //      Also tests name resolution of index field elements with same names
6323 //      but different namespace scopes.
6324 //
6325     Device (IDX6)
6326     {   //  Test device name
6327
6328         OperationRegion (SIO, SystemIO, 0x100, 2)
6329         Field (SIO, ByteAcc, NoLock, Preserve)
6330         {
6331             INDX,   8,
6332             DATA,   8
6333         }
6334         IndexField (INDX, DATA, AnyAcc, NoLock, WriteAsOnes)
6335         {
6336             AccessAs (ByteAcc, 0),
6337             IFE0,   8,
6338             IFE1,   8,
6339             IFE2,   8,
6340             IFE3,   8,
6341             IFE4,   8,
6342             IFE5,   8,
6343             IFE6,   8,
6344             IFE7,   8,
6345             IFE8,   8,
6346             IFE9,   8,
6347         }
6348
6349         Device (TST_)
6350         {   //  TST_:   provides a different namespace scope for IFE0 and IFE1
6351             OperationRegion (SIO2, SystemIO, 0x100, 2)
6352             Field (SIO2, ByteAcc, NoLock, Preserve)
6353             {
6354                 IND2,   8,
6355                 DAT2,   8
6356             }
6357             IndexField (IND2, DAT2, AnyAcc, NoLock, WriteAsOnes)
6358             {
6359                 IFE0,   8,  //  duplicate IndexField name with different scope
6360                 IFE1,   8
6361             }
6362         }   //  TST_:   provides a different namespace scope for IFE0 and IFE1
6363
6364         Method (TEST)
6365         {
6366             Store ("++++++++ IndexOp6 Test", Debug)
6367
6368             Store (IFE0, Local0)
6369             Store (IFE1, Local1)
6370             Store (IFE2, Local2)
6371
6372             //  validate name resolution of IndexFields with different scopes
6373             Store (\IDX6.IFE0, Local3)
6374             Store (\IDX6.IFE1, Local4)
6375             //  verioading of namespace can resolve following names
6376             Store (\IDX6.TST_.IFE0, Local5)
6377             Store (\IDX6.TST_.IFE1, Local6)
6378
6379             Return (0)
6380         }   //  TEST
6381     }   //  IDX6
6382
6383 //
6384 // test IndexOp5.asl
6385 //
6386 //  IndexOp5 test
6387 //      This is just a subset of the many RegionOp/Index Field test cases.
6388 //      Tests copying string into buffer then performing IndexOp on result.
6389 //
6390     Device (IDX5)
6391     {   //  Test device name
6392
6393         Name (OSFL, 0)  //  0 == Windows 98, 1 == Windows NT
6394
6395         //  MCTH is a control method to compare two strings. It returns
6396         //  zero if the strings mismatch, or 1 if the strings match.
6397         //  This exercises the test case of copying a string into a buffer
6398         //  and performing an IndexOp on the resulting buffer.
6399         Method (MCTH, 2, Serialized)    //  Control Method to compare two strings
6400         {   //  MCTH:   Control Method to compare two strings
6401             //  Arg0:       first string to compare
6402             //  Arg1:       second string to compare
6403             //  Return: zero if strings mismatch, 1 if strings match
6404
6405             //  check if first string's length is less than second string's length
6406             If (LLess (SizeOf (Arg0), SizeOf (Arg1)))
6407                 {   Return (0)  }
6408
6409             //  increment length to include NULL termination character
6410             Add (SizeOf (Arg0), 1, Local0)  //  Local0 = strlen(Arg0) + 1
6411
6412             //  create two buffers of size Local0 [strlen(Arg0)+1]
6413             Name (BUF0, Buffer (Local0) {})
6414             Name (BUF1, Buffer (Local0) {})
6415
6416             //  copy strings into buffers
6417             Store (Arg0, BUF0)
6418             Store (Arg1, BUF1)
6419
6420             //  validate BUF0 and BUF1 are still buffers
6421             Store (ObjectType (BUF0), Local1)
6422             If (LNotEqual (Local1, 3))  //  Buffer is type 3
6423                 {   Return (20) }
6424             Store (ObjectType (BUF1), Local1)
6425             If (LNotEqual (Local1, 3))  //  Buffer is type 3
6426                 {   Return (21) }
6427
6428             // Decrement because the Index base below is zero based
6429             //  while Local0 length is one based.
6430             Decrement (Local0)
6431
6432             While (Local0)
6433             {   //  loop through all BUF0 buffer elements
6434                 Decrement (Local0)
6435
6436                 //  check if BUF0[n] == BUF1[n]
6437                 If (LEqual (DerefOf (Index (BUF0, Local0, )),
6438                         DerefOf (Index (BUF1, Local0, ))))
6439                     {   }   //  this is how the code was really implemented
6440                 Else
6441                     {   Return (Zero)   }
6442             }   //  loop through all BUF0 buffer elements
6443
6444             Return (One)    //  strings / buffers match
6445         }   //  MCTH:   Control Method to compare two strings
6446
6447
6448         Method (TEST)
6449         {
6450             Store ("++++++++ IndexOp5 Test", Debug)
6451
6452             If (MCTH (\_OS, "Microsoft Windows NT"))
6453                 {   Store (1, OSFL) }
6454
6455             If (LNotEqual (OSFL, 1))
6456                 {   Return (11) }
6457
6458             Return (0)
6459         }   //  TEST
6460     }   //  IDX5
6461
6462 //
6463 // test IndexOp.asl
6464 //
6465     Scope (\_SB)    //  System Bus
6466     {   //  _SB system bus
6467
6468         Method (C097)
6469             {   Return (1)  }
6470
6471         Device (PCI2)
6472         {   //  Root PCI Bus
6473             Name (_HID, EISAID("PNP0A03"))
6474             Name (_ADR, 0x00000000)
6475             Name (_CRS, Buffer(26)  {"\_SB_.PCI2._CRS..........."})
6476             Method (_STA)   {Return (0x0F)}
6477
6478             Device (ISA)
6479             {   //  ISA bridge
6480                 Name (_ADR, 0x00030000)     //  ISA bus ID
6481
6482                 Device (EC0)
6483                 {   //  Embedded Controller
6484                     Name (_GPE, 0)              //  EC use GPE0
6485                     Name (_ADR, 0x0030000)  //  PCI address
6486
6487                     Method (_STA,0)         //  EC Status
6488                         {   Return(0xF) }       //  EC is functioning
6489
6490                     Name (_CRS, ResourceTemplate()
6491                         {
6492                             IO (Decode16, 0x62, 0x62, 1, 1)
6493                             IO (Decode16, 0x66, 0x66, 1, 1)
6494                         }
6495                     )
6496
6497                 //  create EC's region and field
6498                     OperationRegion (RAM, SystemMemory, 0x400000, 0x100)
6499                     Field (RAM, AnyAcc, NoLock, Preserve)
6500                     {
6501                         //  AC information
6502                         ADP,    1,      //  AC Adapter 1:On-line, 0:Off-line
6503                         AFLT,   1,      //  AC Adapter Fault  1:Fault  0:Normal
6504                         BAT0,   1,      //  BAT0  1:present, 0:not present
6505                         ,       1,      //  reserved
6506                         ,       28, //  filler to force DWORD alignment
6507
6508                         //  CMBatt information
6509                         BPU0,   32, //  Power Unit
6510                         BDC0,   32, //  Designed Capacity
6511                         BFC0,   32, //  Last Full Charge Capacity
6512                         BTC0,   32, //  Battery Technology
6513                         BDV0,   32, //  Design Voltage
6514                         BST0,   32, //  Battery State
6515                         BPR0,   32, //  Battery Present Rate
6516                                         //  (Designed Capacity)x(%)/{(h)x100}
6517                         BRC0,   32, //  Battery Remaining Capacity
6518                                         //  (Designed Capacity)(%)^100
6519                         BPV0,   32, //  Battery Present Voltage
6520                         BTP0,   32, //  Trip Point
6521                         BCW0,   32, //  Design capacity of Warning
6522                         BCL0,   32, //  Design capacity of Low
6523                         BCG0,   32, //  capacity granularity 1
6524                         BG20,   32, //  capacity granularity 2
6525                         BMO0,   32, //  Battery model number field
6526                         BIF0,   32, //  OEM Information(00h)
6527                         BSN0,   32, //  Battery Serial Number
6528                         BTY0,   32, //  Battery Type (e.g., "Li-Ion")
6529                         BTY1,   32      //  Battery Type (e.g., "Li-Ion")
6530                     }   //  Field
6531                 }   //  EC0: Embedded Controller
6532             }   //  ISA bridge
6533         }   //  PCI2 Root PCI Bus
6534
6535         Device (IDX0)
6536         {   //  Test device name
6537             Name (_HID, EISAID ("PNP0C0A"))     //  Control Method Battey ID
6538             Name (_PCL, Package() {\_SB})
6539             Method (_STA)
6540             {
6541                 //  _STA bits 0-3 indicate existence of battery slot
6542                 //  _STA bit 4 indicates battery (not) present
6543                 If (\_SB.PCI2.ISA.EC0.BAT0)
6544                     {   Return (0x1F)   }   //  Battery present
6545                 else
6546                     {   Return (0x0F)   }   //  Battery not present
6547             }   //  _STA
6548
6549             Method (_BIF,, Serialized)
6550             {
6551                 Name (BUFR, Package(13) {})
6552                 Store (\_SB.PCI2.ISA.EC0.BPU0, Index (BUFR,0))  //  Power Unit
6553                 Store (\_SB.PCI2.ISA.EC0.BDC0, Index (BUFR,1))  //  Designed Capacity
6554                 Store (\_SB.PCI2.ISA.EC0.BFC0, Index (BUFR,2))  //  Last Full Charge Capa.
6555                 Store (\_SB.PCI2.ISA.EC0.BTC0, Index (BUFR,3))  //  Battery Technology
6556                 Store (\_SB.PCI2.ISA.EC0.BDV0, Index (BUFR,4))  //  Designed Voltage
6557                 Store (\_SB.PCI2.ISA.EC0.BCW0, Index (BUFR,5))  //  Designed warning level
6558                 Store (\_SB.PCI2.ISA.EC0.BCL0, Index (BUFR,6))  //  Designed Low level
6559                 Store (\_SB.PCI2.ISA.EC0.BCG0, Index (BUFR,7))  //  Capacity granularity 1
6560                 Store (\_SB.PCI2.ISA.EC0.BG20, Index (BUFR,8))  //  Capacity granularity 2
6561
6562                 Store ("", Index (BUFR,9))                              //  Model Number
6563
6564                 Store ("", Index (BUFR,10))                         //  Serial Number
6565
6566                 Store ("LiOn", Index (BUFR,11))                     //  Battery Type
6567
6568                 Store ("Chicony", Index (BUFR,12))                  //  OEM Information
6569
6570                 Return (BUFR)
6571             }   //  _BIF
6572
6573             Method (_BST,, Serialized)
6574             {
6575                 Name (BUFR, Package(4) {1, 0x100, 0x76543210, 0x180})
6576                 Return (BUFR)
6577             }   //  _BST
6578
6579             Method (_BTP,1)
6580             {
6581                 Store (arg0, \_SB.PCI2.ISA.EC0.BTP0)    //  Set Battery Trip point
6582             }
6583
6584             Method (TEST,, Serialized)
6585             {
6586
6587                 Store ("++++++++ IndexOp Test", Debug)
6588
6589                 //  test storing into uninitialized package elements
6590                 Name (PBUF, Package(4) {})  //  leave unitialized
6591                 Store (0x01234567, Index (PBUF,0))
6592                 Store (0x89ABCDEF, Index (PBUF,1))
6593                 Store (0xFEDCBA98, Index (PBUF,2))
6594                 Store (0x76543210, Index (PBUF,3))
6595
6596                 //  verify values stored into uninitialized package elements
6597                 If (LNotEqual (DerefOf (Index (PBUF,0)), 0x01234567))
6598                     {   Return (0x10)   }
6599
6600                 If (LNotEqual (DerefOf (Index (PBUF,1)), 0x89ABCDEF))
6601                     {   Return (0x11)   }
6602
6603                 If (LNotEqual (DerefOf (Index (PBUF,2)), 0xFEDCBA98))
6604                     {   Return (0x12)   }
6605
6606                 If (LNotEqual (DerefOf (Index (PBUF,3)), 0x76543210))
6607                     {   Return (0x13)   }
6608
6609
6610                 //  store _BIF package return value into Local0
6611                 Store (_BIF, Local0)
6612
6613                 //  save Local0 object type value into Local1
6614                 Store (ObjectType (Local0), Local1)
6615
6616                 //  validate Local0 is a Package
6617                 If (LNotEqual (Local1, 4))  //  Package type is 4
6618                     {   Return (0x21)   }   //  failure
6619
6620
6621                 //  test storing into buffer field elements
6622                 Name (BUFR, Buffer(16)
6623                     {   //  initial values
6624                         00, 00, 00, 00, 00, 00, 00, 00,
6625                         00, 00, 00, 00, 00, 00, 00, 00,
6626                     }
6627                 )   //  BUFR
6628                 //  test storing into buffer field elements
6629                 Store (0x01234567, Index (BUFR,0))  //  should only store 0x67
6630                 Store (0x89ABCDEF, Index (BUFR,4))  //  should only store 0xEF
6631                 Store (0xFEDCBA98, Index (BUFR,8))  //  should only store 0x98
6632                 Store (0x76543210, Index (BUFR,12)) //  should only store 0x10
6633
6634                 //  verify storing into buffer field elements
6635                 If (LNotEqual (DerefOf (Index (BUFR,0)), 0x67))
6636                     {   Return (0x30)   }
6637
6638                 If (LNotEqual (DerefOf (Index (BUFR,1)), 0))
6639                     {   Return (0x31)   }
6640
6641                 If (LNotEqual (DerefOf (Index (BUFR,4)), 0xEF))
6642                     {   Return (0x34)   }
6643
6644                 If (LNotEqual (DerefOf (Index (BUFR,8)), 0x98))
6645                     {   Return (0x38)   }
6646
6647                 If (LNotEqual (DerefOf (Index (BUFR,12)), 0x10))
6648                     {   Return (0x3C)   }
6649
6650
6651                 Return (0)  //  pass
6652             }   //  TEST
6653         }   //  IDX0
6654     }   //  _SB system bus
6655
6656 //
6657 // test BitIndex.asl
6658 //
6659 //  BitIndex test
6660 //  This is a test case for accessing fields defined as single bits in
6661 //  memory.  This is done by creating two index fields that overlay the
6662 //  same DWORD in memory.  One field accesses the DWORD as a DWORD, the
6663 //  other accesses individual bits of the same DWORD field in memory.
6664 //
6665     Scope (\_SB)    //  System Bus
6666     {   //  _SB system bus
6667         OperationRegion (RAM, SystemMemory, 0x800000, 0x100)
6668         Field (RAM, AnyAcc, NoLock, Preserve)
6669         {   //  Any access
6670             TREE,   3,
6671             WRD0,   16,
6672             WRD1,   16,
6673             WRD2,   16,
6674             WRD3,   16,
6675             WRD4,   16,
6676             DWRD,   32, //  DWORD field
6677         }
6678         Field (RAM, AnyAcc, NoLock, Preserve)
6679         {   //  Any access
6680             THRE,   3,
6681             WD00,   16,
6682             WD01,   16,
6683             WD02,   16,
6684             WD03,   16,
6685             WD04,   16,
6686             BYT0,   8,  //  Start off with a BYTE
6687             BIT0,   1,  //  single-bit field
6688             BIT1,   1,  //  single-bit field
6689             BIT2,   1,  //  single-bit field
6690             BIT3,   1,  //  single-bit field
6691             BIT4,   1,  //  single-bit field
6692             BIT5,   1,  //  single-bit field
6693             BIT6,   1,  //  single-bit field
6694             BIT7,   1,  //  single-bit field
6695             BIT8,   1,  //  single-bit field
6696             BIT9,   1,  //  single-bit field
6697             BITA,   1,  //  single-bit field
6698             BITB,   1,  //  single-bit field
6699             BITC,   1,  //  single-bit field
6700             BITD,   1,  //  single-bit field
6701             BITE,   1,  //  single-bit field
6702             BITF,   1,  //  single-bit field
6703             BYTZ,   8,  //  End with a BYTE for a total of 32 bits
6704         }
6705
6706         Device (BITI)
6707         {   //  Test device name
6708
6709             Method (MBIT)   //  Test single bit memory accesses
6710             {
6711
6712                 If (LNotEqual (DWRD, 0x00))
6713                 {
6714                     Store (0xFF00, Local0)
6715                 }
6716                 Else
6717                 {
6718                     //  Prime Local0 with 0...assume passing condition
6719                     Store (0, Local0)
6720
6721                     //  set memory contents to known values using DWORD field
6722                     Store (0x5A5A5A5A, DWRD)
6723
6724                     //  Given the value programmed into DWRD, only the odd bits
6725                     //  of the lower nibble should be set. BIT1, BIT3 should be set.
6726                     //  BIT0 and BIT2 should be clear
6727
6728                     If (BIT0)
6729                     {
6730                         Or (Local0, 0x01, Local0)
6731                     }
6732
6733                     If (LNot (BIT1))
6734                     {
6735                         Or (Local0, 0x02, Local0)
6736                     }
6737
6738                     If (BIT2)
6739                     {
6740                         Or (Local0, 0x04, Local0)
6741                     }
6742
6743                     If (LNot (BIT3))
6744                     {
6745                         Or (Local0, 0x08, Local0)
6746                     }
6747
6748                     //  Now check the upper nibble.  Only the "even" bits should
6749                     //  be set.  BIT4, BIT6.  BIT5 and BIT7 should be clear.
6750                     If (LNot (BIT4))
6751                     {
6752                         Or (Local0, 0x10, Local0)
6753                     }
6754
6755                     If (BIT5)
6756                     {
6757                         Or (Local0, 0x20, Local0)
6758                     }
6759
6760                     If (LNot (BIT6))
6761                     {
6762                         Or (Local0, 0x40, Local0)
6763                     }
6764
6765                     If (BIT7)
6766                     {
6767                         Or (Local0, 0x80, Local0)
6768                     }
6769                 }   //  End Else DWRD zeroed out
6770
6771                 Return (Local0)
6772             }   //  MBIT:   Test single bit memory accesses
6773
6774             Method (TEST)
6775             {
6776
6777                 Store ("++++++++ BitIndex Test", Debug)
6778
6779                 //  Zero out DWRD
6780                 Store (0x00000000, DWRD)
6781
6782                 //  MBIT returns zero if successful
6783                 //  This may be causing problems -- Return (MBIT)
6784                 Store (MBIT, Local0)
6785
6786                 Return (Local0)
6787             }   //  TEST
6788         }   //  BITI
6789     }   //  _SB system bus
6790
6791 //
6792 // test IndexOp3.asl
6793 //
6794 //  Additional IndexOp test cases to support ACPICMB (control method battery
6795 //  test) on Compaq laptops. Test cases include storing a package into
6796 //  an IndexOp target and validating that changing source and destination
6797 //  package contents are independent of each other.
6798 //
6799     Scope (\_SB)    //  System Bus
6800     {   //  _SB system bus
6801
6802         Name (C174, 13)
6803         Name (C175, 8)
6804
6805         Device (C158)
6806         {   //  C158:   AC Adapter device
6807             Name (_HID, "ACPI0003") //  AC Adapter device
6808             Name (_PCL, Package (1) {\_SB})
6809
6810             Method (_PSR)
6811             {
6812                 Acquire (\_GL, 0xFFFF)
6813                 Release (\_GL)
6814                 And (Local0, 1, Local0) //  Local0 &= 1
6815                 Return (Local0)
6816             }   //  _PSR
6817         }   //  C158:   AC Adapter device
6818
6819         Name (C176, Package (4) {"Primary", "MultiBay", "DockRight", "DockLeft"})
6820
6821         Name (C177, Package (4) {0x99F5, 0x99F5, 0x995F, 0x995F})
6822
6823         Name (C178, Package (4)
6824         {
6825             Package (4) {0, 0, 0x966B, 0x4190},
6826             Package (4) {0, 0, 0x966B, 0x4190},
6827             Package (4) {0, 0, 0x966B, 0x4190},
6828             Package (4) {0, 0, 0x966B, 0x4190}
6829         })  //  C178
6830
6831         Name (C179, Package (4) {0, 0, 0x966B, 0x4190})
6832
6833         Name (C17A, Package (4)
6834         {
6835             Package (3) {0, 0, 0},
6836             Package (3) {0, 0, 0},
6837             Package (3) {0, 0, 0},
6838             Package (3) {0, 0, 0}
6839         })  //  C17A
6840
6841         Method (C17B, 1, Serialized)
6842         {   //  C17B:   _BIF implementation
6843             Name (C17C, Package (13)
6844             {   //  C17C:   _BIF control method return package
6845                 0,                  //  Power Unit (0 ==> mWh and mW)
6846                 0x99F5,         //  Design Capacity
6847                 0x99F5,         //  Last Full Charge Capacity
6848                 1,                  //  Battery Technology (1 ==> rechargeable)
6849                 0x3840,         //  Design Voltage
6850                 0x1280,         //  Design Capacity of Warning
6851                 0x0AC7,         //  Design Capacity of Low
6852                 1,                  //  Battery Capacity Granularity 1 (Low -- Warning)
6853                 1,                  //  Battery Capacity Granularity 2 (Warning -- Full)
6854                 "2891",         //  Model Number (ASCIIZ)
6855                 "(-Unknown-)",  //  Serial Number (ASCIIZ)
6856                 "LIon",         //  Battery Type (ASCIIZ)
6857                 0                   //  OEM Information (ASCIIZ)
6858             })  //  C17C:   _BIF control method return package
6859
6860             And (Arg0, 7, Local0)                       //  Local0 = Arg0 & 7
6861
6862             ShiftRight (Local0, 1, Local4)          //  Local4 = Local0 >> 1
6863
6864             Store (C179, Index (C178, Local4, ))    //  C178->Local4 = C179
6865
6866             //  verify source and destination packages can be altered independent
6867             //  of each other (i.e., changing one's contents does NOT change other's
6868             //  contents)
6869             Store (0x1234, Index (C179, 2, ))               //  C179[2] = 0x1234
6870             Store (DerefOf (Index (C179, 2, )), Local2) //  Local2 = C179[2]
6871             if (LNotEqual (Local2, 0x1234))
6872                 {   Return (0x1234) }
6873                                                                         //  Local2 = C178[0,2]
6874             Store (DerefOf (Index (DerefOf (Index (C178, 0, )), 2, )), Local2)
6875             if (LNotEqual (Local2, 0x966B))
6876                 {   Return (0x1234) }
6877
6878             // Restore data to allow iterative execution
6879             Store (0x966B, Index (C179, 2, ))               //  C179[2] = 0x966B
6880
6881                                                                         //  C178[0,3] = 0x5678
6882             Store (0x5678, Index (DerefOf (Index (C178, 0, )), 3, ))
6883                                                                         //  Local2 = C178[0,3]
6884             Store (DerefOf (Index (DerefOf (Index (C178, 0, )), 3, )), Local2)
6885             if (LNotEqual (Local2, 0x5678))
6886                 {   Return (0x5678) }
6887
6888             Store (DerefOf (Index (C179, 3, )), Local2) //  Local2 = C179[3]
6889             if (LNotEqual (Local2, 0x4190))
6890                 {   Return (0x5678) }
6891
6892             // Restore data to allow iterative execution
6893             Store (0x4190, Index (DerefOf (Index (C178, 0, )), 3, ))    //  C179[2] = 0x4190
6894
6895             Return (C17C)
6896         }   //  C17B:   _BIF implementation
6897
6898         Device (C154)
6899         {   //  C154:   Battery 0
6900             Name (_HID, "*PNP0C0A")     //  Control Method Battey ID
6901             Name (_UID, 0)                  //  first instance
6902
6903             Method (_BIF)
6904             {   //  _BIF
6905                 Return (C17B (48))
6906             }   //  _BIF
6907         }   //  C154:   Battery 0
6908
6909         Device (IDX3)
6910         {
6911             Method (LCLB,, Serialized)
6912             {   //  LCLB control method: test Index(Local#) where Local# is buffer
6913                 //  Local0 is index counter
6914                 //  Local1 is buffer
6915                 //  Local2 receives BUFR[Local0] via Deref(Index(Local1...))
6916                 //  Local3 is Local1 or Local2 object type
6917                 //  Local4 is return error code
6918
6919                 Name (BUFR, Buffer ()   {0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
6920
6921                 //  save PKG into Local1
6922                 Store (BUFR, Local1)
6923
6924                 //  save Local2 object type value into Local3
6925                 Store (ObjectType (Local1), Local3)
6926
6927                 //  validate Local1 is a Buffer
6928                 If (LNotEqual (Local3, 3))      //  Buffer type is 3
6929                     {   Return (0x9F)   }
6930
6931
6932                 Store (0, Local0)
6933                 While (LLess (Local0, 5))
6934                 {   //  While (Local0 < 5)
6935                     //  Local2 = Local1[Local0]
6936                     Store (DerefOf (Index (Local1, Local0, )), Local2)
6937
6938                     //  save Local2 object type value into Local3
6939                     Store (ObjectType (Local2), Local3)
6940
6941                     //  validate Local2 is a Number
6942                     If (LNotEqual (Local3, 1))      //  Number type is 1
6943                         {   Return (0x9E)   }
6944
6945                     //  validate Local1[Local0] value == Local0
6946                     If (LNotEqual (Local0, Local2))
6947                     {   //  Local0 != Local2 == PKG[Local0]
6948                         //  Local4 = 0x90 + loop index (Local0)
6949                         Add (0x90, Local0, Local4)
6950
6951                         //  return 0x90 + loop index
6952                         Return (Local4)
6953                     }
6954
6955                     Increment (Local0)
6956                 }   //  While (Local0 < 5)
6957
6958                 Store ("DerefOf(Index(LocalBuffer,,)) PASS", Debug)
6959
6960                 Return (0)  //  Pass
6961             }   //  LCLB control method: test Index(Local#) where Local# is buffer
6962
6963             Method (LCLP,, Serialized)
6964             {   //  LCLP control method: test Index(Local#) where Local# is package
6965                 //  Local0 is index counter
6966                 //  Local1 is package
6967                 //  Local2 receives PKG[Local0] via Deref(Index(Local1...))
6968                 //  Local3 is Local1 or Local2 object type
6969                 //  Local4 is return error code
6970
6971                 Name (PKG, Package ()   {0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
6972
6973                 //  save PKG into Local1
6974                 Store (PKG, Local1)
6975
6976                 //  save Local2 object type value into Local3
6977                 Store (ObjectType (Local1), Local3)
6978
6979                 //  validate Local1 is a Package
6980                 If (LNotEqual (Local3, 4))      //  Package type is 4
6981                     {   Return (0x8F)   }
6982
6983
6984                 Store (0, Local0)
6985                 While (LLess (Local0, 5))
6986                 {   //  While (Local0 < 5)
6987                     //  Local2 = Local1[Local0]
6988                     Store (DerefOf (Index (Local1, Local0, )), Local2)
6989
6990                     //  save Local2 object type value into Local3
6991                     Store (ObjectType (Local2), Local3)
6992
6993                     //  validate Local2 is a Number
6994                     If (LNotEqual (Local3, 1))      //  Number type is 1
6995                         {   Return (0x8E)   }
6996
6997                     //  validate Local1[Local0] value == Local0
6998                     If (LNotEqual (Local0, Local2))
6999                     {   //  Local0 != Local2 == PKG[Local0]
7000                         //  Local4 = 0x80 + loop index (Local0)
7001                         Add (0x80, Local0, Local4)
7002
7003                         //  return 0x80 + loop index
7004                         Return (Local4)
7005                     }
7006
7007                     Increment (Local0)
7008                 }   //  While (Local0 < 5)
7009
7010                 Store ("DerefOf(Index(LocalPackage,,)) PASS", Debug)
7011
7012                 Return (0)  //  Pass
7013             }   //  LCLP control method: test Index(Local#) where Local# is package
7014
7015             Method (TEST)
7016             {
7017
7018                 Store ("++++++++ IndexOp3 Test", Debug)
7019
7020                 //  store _BIF package return value into Local0
7021                 Store (\_SB.C154._BIF, Local0)
7022
7023                 //  save Local0 object type value into Local1
7024                 Store (ObjectType (Local0), Local1)
7025
7026                 //  validate Local0 is a Package
7027                 If (LNotEqual (Local1, 4))      //  Package type is 4
7028                 {   //  failure: did not return a Package (type 4)
7029                     //  if Local0 is a Number, it contains an error code
7030                     If (LEqual (Local1, 1))     //  Number type is 1
7031                         {   Return (Local0) }   //  return Local0 error code
7032                     Else                                //  Local0 is not a Number
7033                         {   Return (1)  }           //  return default error code
7034                 }   //  failure: did not return a Package (type 4)
7035
7036                 //  save LCLB control method return value into Local2
7037                 Store (LCLB, Local2)
7038                 If (LNotEqual (Local2, 0))
7039                     {   Return (Local2) }   //  return failure code
7040
7041                 //  save LCLP control method return value into Local2
7042                 Store (LCLP, Local2)
7043                 If (LNotEqual (Local2, 0))
7044                     {   Return (Local2) }   //  return failure code
7045
7046                 Return (0)  //  Pass
7047             }   //  TEST
7048         }   //  IDX3:   Test device name
7049     }   //  _SB system bus
7050
7051 //
7052 // MTL developed test to exercise Indexes into buffers
7053 //
7054     Device(IDX7)
7055     {
7056
7057         Name (PKG4, Package() {
7058                 0x2,
7059                 "A short string",
7060                 Buffer() {0xA, 0xB, 0xC, 0xD},
7061                 0x1234,
7062                 Package() {IDX7, 0x3}
7063                 })
7064
7065         //
7066         // Generic Test method
7067         //
7068         // This test returns 0xE (14) - ObjectType = Buffer Field
7069         Method(TST1,, Serialized)
7070         {
7071             Name (DEST, Buffer ()                           //  62 characters plus NULL
7072                 {"Destination buffer that is longer than the short source buffer"})
7073
7074             //  verify object type returned by Index(Buffer,Element,)
7075             Store (Index (DEST, 2, ), Local1)
7076             Store (ObjectType (Local1), Local2)
7077             If (LEqual(Local2, 14))
7078             {
7079                 Return(0)
7080             }
7081             Else
7082             {
7083                 Return(0x1)
7084             }
7085
7086         }
7087
7088         Method(TST2,, Serialized)
7089         {
7090             Name (BUF0, Buffer() {0x1, 0x2, 0x3, 0x4, 0x5})
7091             Store(0x55, Index(BUF0, 2))
7092             Store(DerefOf(Index(BUF0, 2)), Local0)
7093             If (LEqual(Local0, 0x55))
7094             {
7095                 Return(0)
7096             }
7097             Else
7098             {
7099                 Return(0x2)
7100             }
7101
7102
7103         }
7104
7105         Method(TST3,, Serialized)
7106         {
7107             Name (BUF1, Buffer() {0x1, 0x2, 0x3, 0x4, 0x5})
7108             Store(Index(BUF1, 1), Local0)
7109             Store(DerefOf(Local0), Local1)
7110             If (LEqual(Local1, 0x2))
7111             {
7112                 Return(0)
7113             }
7114             Else
7115             {
7116                 Return(0x3)
7117             }
7118
7119         }
7120
7121         Method(TST4)
7122         {
7123             // Index (PKG4, 0) is a Number
7124             Store (Index (PKG4, 0), Local0)
7125             Store (ObjectType(Local0), Local1)
7126             If (LEqual(Local1, 0x1))
7127             {
7128                 Return(0)
7129             }
7130             Else
7131             {
7132                 Return(0x4)
7133             }
7134
7135         }
7136
7137         Method(TST5)
7138         {
7139             // Index (PKG4, 1) is a String
7140             Store (Index (PKG4, 1), Local0)
7141             Store (ObjectType(Local0), Local1)
7142             If (LEqual(Local1, 0x2))
7143             {
7144                 Return(0)
7145             }
7146             Else
7147             {
7148                 Return(0x5)
7149             }
7150
7151         }
7152
7153         Method(TST6)
7154         {
7155             // Index (PKG4, 2) is a Buffer
7156             Store (Index (PKG4, 2), Local0)
7157             Store (ObjectType(Local0), Local1)
7158             If (LEqual(Local1, 0x3))
7159             {
7160                 Return(0)
7161             }
7162             Else
7163             {
7164                 Return(0x6)
7165             }
7166
7167         }
7168
7169         Method(TST7)
7170         {
7171             // Index (PKG4, 3) is a Number
7172             Store (Index (PKG4, 3), Local0)
7173             Store (ObjectType(Local0), Local1)
7174             If (LEqual(Local1, 0x1))
7175             {
7176                 Return(0)
7177             }
7178             Else
7179             {
7180                 Return(0x7)
7181             }
7182
7183         }
7184
7185         Method(TST8)
7186         {
7187             // Index (PKG4, 4) is a Package
7188             Store (Index (PKG4, 4), Local0)
7189             Store (ObjectType(Local0), Local1)
7190             If (LEqual(Local1, 0x4))
7191             {
7192                 Return(0)
7193             }
7194             Else
7195             {
7196                 Return(0x8)
7197             }
7198
7199         }
7200
7201         Method(TST9)
7202         {
7203             // DerefOf (Index (PKG4, 0)) is a Number
7204             Store (DerefOf (Index (PKG4, 0)), Local0)
7205             If (LEqual(Local0, 0x2))
7206             {
7207                 Return(0)
7208             }
7209             Else
7210             {
7211                 Return(0x9)
7212             }
7213
7214         }
7215
7216         Method(TSTA)
7217         {
7218             // DerefOf (Index (PKG4, 1)) is a String
7219             Store (DerefOf (Index (PKG4, 1)), Local0)
7220             Store (SizeOf(Local0), Local1)
7221             If (LEqual(Local1, 0xE))
7222             {
7223                 Return(0)
7224             }
7225             Else
7226             {
7227                 Return(0xA)
7228             }
7229
7230         }
7231
7232         Method(TSTB)
7233         {
7234             // DerefOf (Index (PKG4, 2)) is a Buffer
7235             Store (DerefOf (Index (PKG4, 2)), Local0)
7236             Store (SizeOf(Local0), Local1)
7237             If (LEqual(Local1, 0x4))
7238             {
7239                 Return(0)
7240             }
7241             Else
7242             {
7243                 Return(0xB)
7244             }
7245
7246         }
7247
7248         Method(TSTC)
7249         {
7250             // DerefOf (Index (PKG4, 3)) is a Number
7251             Store (DerefOf (Index (PKG4, 3)), Local0)
7252             If (LEqual(Local0, 0x1234))
7253             {
7254                 Return(0)
7255             }
7256             Else
7257             {
7258                 Return(0xC)
7259             }
7260
7261         }
7262
7263         Method(TSTD)
7264         {
7265             // DerefOf (Index (PKG4, 4)) is a Package
7266             Store (DerefOf (Index (PKG4, 4)), Local0)
7267             Store (SizeOf(Local0), Local1)
7268             If (LEqual(Local1, 0x2))
7269             {
7270                 Return(0)
7271             }
7272             Else
7273             {
7274                 Return(0xD)
7275             }
7276
7277         }
7278
7279         Method(TSTE)
7280         {
7281             // DerefOf (Index (PKG4, 2)) is a Buffer
7282             Store (DerefOf (Index (PKG4, 2)), Local0)
7283             // DerefOf (Index (Local0, 1)) is a Number
7284             Store (DerefOf (Index (Local0, 1)), Local1)
7285             If (LEqual(Local1, 0xB))
7286             {
7287                 Return(0)
7288             }
7289             Else
7290             {
7291                 Return(0xE)
7292             }
7293
7294         }
7295
7296         Method (TSTF,, Serialized)
7297         {
7298             Name (SRCB, Buffer (12) {}) //  12 characters
7299             Store ("Short Buffer", SRCB)
7300
7301             Name (DEST, Buffer ()                       //  62 characters plus NULL
7302                 {"Destination buffer that is longer than the short source buffer"})
7303
7304             //  overwrite DEST contents, starting at buffer position 2
7305             Store (SRCB, Index (DEST, 2))
7306
7307             //
7308             //  The DEST buffer element should be replaced with the last element of
7309             //      the SRCB element (i.e. 's'->'r')
7310             Store (DerefOf (Index (DEST, 2)), Local0)
7311
7312             If (LNotEqual (Local0, 0x72))       //  'r'
7313             {
7314                 //  DEST element does not match the value from SRCB
7315                 Return(Or(Local0, 0x1000))
7316             }
7317
7318             Return(0)
7319         }
7320
7321         Method (TSTG,, Serialized)
7322         {
7323
7324             Name (SRCB, Buffer (12) {}) //  12 characters
7325             Store ("Short Buffer", SRCB)
7326
7327             Name (DEST, Buffer ()                       //  62 characters plus NULL
7328                 {"Destination buffer that is longer than the short source buffer"})
7329
7330             //  overwrite DEST contents, starting at buffer position 2
7331             Store (SRCB, Index (DEST, 2))
7332
7333             //
7334             // The next element of DEST should be unchanged
7335             //
7336             Store (DerefOf (Index (DEST, 3)), Local0)
7337
7338             If (LNotEqual (Local0, 0x74))       //  't'
7339             {
7340                 //  DEST has been changed
7341                 Return(Or(Local0, 0x2000))
7342             }
7343
7344             //
7345             // The next element of DEST should be unchanged
7346             //
7347             Store (DerefOf (Index (DEST, 4)), Local0)
7348
7349             If (LNotEqual (Local0, 0x69))       //  'i'
7350             {
7351                 //  DEST has been changed
7352                 Return(Or(Local0, 0x2100))
7353             }
7354
7355             //
7356             // The next element of DEST should be unchanged
7357             //
7358             Store (DerefOf (Index (DEST, 5)), Local0)
7359
7360             If (LNotEqual (Local0, 0x6E))       //  'n'
7361             {
7362                 //  DEST has been changed
7363                 Return(Or(Local0, 0x2200))
7364             }
7365
7366             //
7367             // The next element of DEST should be unchanged
7368             //
7369             Store (DerefOf (Index (DEST, 6)), Local0)
7370
7371             If (LNotEqual (Local0, 0x61))       //  'a'
7372             {
7373                 //  DEST has been changed
7374                 Return(Or(Local0, 0x2300))
7375             }
7376
7377             //
7378             // The next element of DEST should be unchanged
7379             //
7380             Store (DerefOf (Index (DEST, 7)), Local0)
7381
7382             If (LNotEqual (Local0, 0x74))       //  't'
7383             {
7384                 //  DEST has been changed
7385                 Return(Or(Local0, 0x2400))
7386             }
7387
7388             //
7389             //  Verify DEST elements beyond end of SRCB buffer copy
7390             //  have not been changed
7391             Store (DerefOf (Index (DEST, 14)), Local0)
7392
7393             If (LNotEqual (Local0, 0x66))       // 'f'
7394             {
7395                 //  DEST has been changed
7396                 Return(Or(Local0, 0x2400))
7397             }
7398
7399             Return(0)
7400         }
7401
7402         //
7403         // This test shows that MS ACPI.SYS stores only the lower 8-bits of a 32-bit
7404         //  number into the index'ed buffer
7405         //
7406         Method (TSTH,, Serialized)
7407         {
7408             // Create a Destination Buffer
7409             Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
7410
7411             // Store a number > UINT8 into an index of the buffer
7412             Store (0x12345678, Index(DBUF, 2))
7413
7414             // Check the results
7415             Store (DerefOf (Index (DBUF, 2)), Local0)
7416             If (LNotEqual (Local0, 0x78))   // 0x78
7417             {
7418                 Return(Or(Local0, 0x3000))
7419             }
7420
7421             Store (DerefOf (Index (DBUF, 3)), Local0)
7422             If (LNotEqual (Local0, 0x64))   // 'd'
7423             {
7424                 Return(Or(Local0, 0x3100))
7425             }
7426
7427             Store (DerefOf (Index (DBUF, 4)), Local0)
7428             If (LNotEqual (Local0, 0x65))   // 'e'
7429             {
7430                 Return(Or(Local0, 0x3200))
7431             }
7432
7433             Store (DerefOf (Index (DBUF, 5)), Local0)
7434             If (LNotEqual (Local0, 0x66))   // 'f'
7435             {
7436                 Return(Or(Local0, 0x3300))
7437             }
7438
7439             Return(0)
7440         }
7441
7442         Method (TSTI,, Serialized)
7443         {
7444             // Create a Destination Buffer
7445             Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
7446
7447             // Store a String into an index of the buffer
7448             Store ("ABCDEFGH", Index(DBUF, 2))
7449
7450             // Check the results
7451             Store (DerefOf (Index (DBUF, 2)), Local0)
7452             If (LNotEqual (Local0, 0x48))   // 'H'
7453             {
7454                 Return(Or(Local0, 0x4000))
7455             }
7456
7457             Store (DerefOf (Index (DBUF, 3)), Local0)
7458             If (LNotEqual (Local0, 0x64))   // 'd'
7459             {
7460                 Return(Or(Local0, 0x4100))
7461             }
7462
7463             Store (DerefOf (Index (DBUF, 4)), Local0)
7464             If (LNotEqual (Local0, 0x65))   // 'e'
7465             {
7466                 Return(Or(Local0, 0x4200))
7467             }
7468
7469             Store (DerefOf (Index (DBUF, 5)), Local0)
7470             If (LNotEqual (Local0, 0x66))   // 'f'
7471             {
7472                 Return(Or(Local0, 0x4300))
7473             }
7474
7475             Return(0)
7476         }
7477
7478         Method(TSTJ,, Serialized)
7479         {
7480             // Create a Destination Buffer
7481             Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
7482
7483             // Store a number > UINT8 into an index of the buffer
7484             Store (0x1234, Index(DBUF, 2))
7485
7486             // Check the results
7487             Store (DerefOf (Index (DBUF, 2)), Local0)
7488             If (LNotEqual (Local0, 0x34))   // 0x34
7489             {
7490                 Return(Or(Local0, 0x3000))
7491             }
7492
7493             Store (DerefOf (Index (DBUF, 3)), Local0)
7494             If (LNotEqual (Local0, 0x64))   // 'd'
7495             {
7496                 Return(Or(Local0, 0x3100))
7497             }
7498
7499             Store (DerefOf (Index (DBUF, 4)), Local0)
7500             If (LNotEqual (Local0, 0x65))   // 'e'
7501             {
7502                 Return(Or(Local0, 0x3200))
7503             }
7504
7505             Store (DerefOf (Index (DBUF, 5)), Local0)
7506             If (LNotEqual (Local0, 0x66))   // 'f'
7507             {
7508                 Return(Or(Local0, 0x3300))
7509             }
7510
7511             Return(0)
7512         }
7513
7514         Method(TSTK,, Serialized)
7515         {
7516             // Create a Destination Buffer
7517             Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
7518
7519             // Store a number > UINT8 into an index of the buffer
7520             Store (0x123456, Index(DBUF, 2))
7521
7522             // Check the results
7523             Store (DerefOf (Index (DBUF, 2)), Local0)
7524             If (LNotEqual (Local0, 0x56))   // 0x56
7525             {
7526                 Return(Or(Local0, 0x3000))
7527             }
7528
7529             Store (DerefOf (Index (DBUF, 3)), Local0)
7530             If (LNotEqual (Local0, 0x64))   // 'd'
7531             {
7532                 Return(Or(Local0, 0x3100))
7533             }
7534
7535             Store (DerefOf (Index (DBUF, 4)), Local0)
7536             If (LNotEqual (Local0, 0x65))   // 'e'
7537             {
7538                 Return(Or(Local0, 0x3200))
7539             }
7540
7541             Store (DerefOf (Index (DBUF, 5)), Local0)
7542             If (LNotEqual (Local0, 0x66))   // 'f'
7543             {
7544                 Return(Or(Local0, 0x3300))
7545             }
7546
7547             Return(0)
7548         }
7549
7550         Method(TSTL,, Serialized)
7551         {
7552             // Create a Destination Buffer
7553             Name (DBUF, Buffer () {"abcdefghijklmnopqrstuvwxyz"})
7554
7555             // Store a number > UINT8 into an index of the buffer
7556             Store (0x12, Index(DBUF, 2))
7557
7558             // Check the results
7559             Store (DerefOf (Index (DBUF, 2)), Local0)
7560             If (LNotEqual (Local0, 0x12))   // 0x12
7561             {
7562                 Return(Or(Local0, 0x3000))
7563             }
7564
7565             Store (DerefOf (Index (DBUF, 3)), Local0)
7566             If (LNotEqual (Local0, 0x64))   // 'd'
7567             {
7568                 Return(Or(Local0, 0x3100))
7569             }
7570
7571             Store (DerefOf (Index (DBUF, 4)), Local0)
7572             If (LNotEqual (Local0, 0x65))   // 'e'
7573             {
7574                 Return(Or(Local0, 0x3200))
7575             }
7576
7577             Store (DerefOf (Index (DBUF, 5)), Local0)
7578             If (LNotEqual (Local0, 0x66))   // 'f'
7579             {
7580                 Return(Or(Local0, 0x3300))
7581             }
7582
7583             Return(0)
7584         }
7585
7586         Method(TEST)
7587         {
7588             Store ("++++++++ IndexOp7 Test", Debug)
7589
7590             Store(TST1(), Local0)
7591             if (LGreater (Local0, 0))
7592             {
7593                 Return(Local0)
7594             }
7595
7596             Store(TST2(), Local0)
7597             if (LGreater (Local0, 0))
7598             {
7599                 Return(Local0)
7600             }
7601
7602             Store(TST3(), Local0)
7603             if (LGreater (Local0, 0))
7604             {
7605                 Return(Local0)
7606             }
7607
7608             Store(TST4(), Local0)
7609             if (LGreater (Local0, 0))
7610             {
7611                 Return(Local0)
7612             }
7613
7614             Store(TST5(), Local0)
7615             if (LGreater (Local0, 0))
7616             {
7617                 Return(Local0)
7618             }
7619
7620             Store(TST6(), Local0)
7621             if (LGreater (Local0, 0))
7622             {
7623                 Return(Local0)
7624             }
7625
7626             Store(TST7(), Local0)
7627             if (LGreater (Local0, 0))
7628             {
7629                 Return(Local0)
7630             }
7631
7632             Store(TST8(), Local0)
7633             if (LGreater (Local0, 0))
7634             {
7635                 Return(Local0)
7636             }
7637
7638             Store(TST9(), Local0)
7639             if (LGreater (Local0, 0))
7640             {
7641                 Return(Local0)
7642             }
7643
7644             Store(TSTA(), Local0)
7645             if (LGreater (Local0, 0))
7646             {
7647                 Return(Local0)
7648             }
7649
7650             Store(TSTB(), Local0)
7651             if (LGreater (Local0, 0))
7652             {
7653                 Return(Local0)
7654             }
7655
7656             Store(TSTC(), Local0)
7657             if (LGreater (Local0, 0))
7658             {
7659                 Return(Local0)
7660             }
7661
7662             Store(TSTD(), Local0)
7663             if (LGreater (Local0, 0))
7664             {
7665                 Return(Local0)
7666             }
7667
7668             Store(TSTE(), Local0)
7669             if (LGreater (Local0, 0))
7670             {
7671                 Return(Local0)
7672             }
7673
7674     /* No longer ACPI compliant */
7675     /*
7676             Store(TSTF(), Local0)
7677             if (LGreater (Local0, 0))
7678             {
7679                 Return(Local0)
7680             }
7681     */
7682
7683             Store(TSTG(), Local0)
7684             if (LGreater (Local0, 0))
7685             {
7686                 Return(Local0)
7687             }
7688
7689             Store(TSTH(), Local0)
7690             if (LGreater (Local0, 0))
7691             {
7692                 Return(Local0)
7693             }
7694
7695     /* No longer ACPI compliant */
7696     /*
7697             Store(TSTI(), Local0)
7698             if (LGreater (Local0, 0))
7699             {
7700                 Return(Local0)
7701             }
7702     */
7703             Store(TSTJ(), Local0)
7704             if (LGreater (Local0, 0))
7705             {
7706                 Return(Local0)
7707             }
7708
7709             Store(TSTK(), Local0)
7710             if (LGreater (Local0, 0))
7711             {
7712                 Return(Local0)
7713             }
7714
7715             Store(TSTL(), Local0)
7716             if (LGreater (Local0, 0))
7717             {
7718                 Return(Local0)
7719             }
7720
7721             Return(Local0)
7722
7723         }
7724
7725     } // Device(IDX7)
7726
7727 //
7728 // test MatchOp.asl
7729 //
7730 //  MatchOp test cases that utilize nested DerefOf(Index(...)) to validate
7731 //  MatchOp, DerefOfOp, and IndexOp of nested packages.
7732 //
7733     Device (MTCH)
7734     {
7735
7736         Method (TEST,, Serialized)
7737         {
7738             Store ("++++++++ MatchOp Test", Debug)
7739
7740             Name (TIM0, Package ()
7741                 {
7742                     Package ()  {0x78, 0xB4, 0xF0, 0x0384},
7743                     Package ()  {0x23, 0x21, 0x10, 0},
7744                     Package ()  {0x0B, 9, 4, 0},
7745                     Package ()  {0x70, 0x49, 0x36, 0x27, 0x19},
7746                     Package ()  {0, 1, 2, 1, 2},
7747                     Package ()  {0, 0, 0, 1, 1},
7748                     Package ()  {4, 3, 2, 0},
7749                     Package ()  {2, 1, 0, 0}
7750                 })  //  TIM0
7751
7752             Name (TMD0, Buffer (20) {0xFF, 0xFF, 0xFF, 0xFF })
7753             CreateDWordField (TMD0, 0, PIO0)    //  0xFFFFFFFF
7754             CreateDWordField (TMD0, 4, DMA0)
7755             CreateDWordField (TMD0, 8, PIO1)
7756             CreateDWordField (TMD0, 12, DMA1)
7757             CreateDWordField (TMD0, 16, CHNF)
7758
7759
7760             //  validate PIO0 value
7761             Store (PIO0, Local3)
7762
7763             //  save Local3 object type value into Local2
7764             Store (ObjectType (Local3), Local2)
7765
7766             //  validate Local3 is a Number
7767             If (LNotEqual (Local2, 1))  //  Number type is 1
7768                 {   Return (2)  }   //  failure
7769
7770             //  validate Local3 Number value
7771             If (LNotEqual (Local3, 0xFFFFFFFF)) //  Number value 0xFFFFFFFF
7772                 {   Return (3)  }   //  failure
7773
7774             Store ("DWordField PASS", Debug)
7775
7776
7777             Store (0, Local5)
7778             Store (Match (DerefOf (Index (TIM0, 1, )), MLE, Local5, MTR, 0, 0), Local6)
7779
7780             //  save Local6 object type value into Local2
7781             Store (ObjectType (Local6), Local2)
7782
7783             //  validate Local6 is a Number
7784             If (LNotEqual (Local2, 1))  //  Number type is 1
7785                 {   Return (4)  }   //  failure
7786
7787             Store ("Match(DerefOf(Index(TIM0,1)),... PASS", Debug)
7788
7789
7790             //  validate following produces a nested package to validate
7791             //  that MatchOp did not corrupt SearchPackage (TIM0)
7792             Store (DerefOf (Index (TIM0, 1, )), Local4)
7793
7794             //  save Local4 object type value into Local2
7795             Store (ObjectType (Local4), Local2)
7796
7797             //  validate Local4 is a Package
7798             If (LNotEqual (Local2, 4))  //  Package type is 4
7799                 {   Return (5)  }   //  failure
7800
7801             Store ("DerefOf(Index(TIM0,1)),... PASS", Debug)
7802
7803
7804             And (Match (DerefOf (Index (TIM0, 0, )), MGE, PIO0, MTR, 0, 0), 3, Local0)
7805
7806             //  save Local0 object type value into Local2
7807             Store (ObjectType (Local0), Local2)
7808
7809             //  validate Local0 is a Number
7810             If (LNotEqual (Local2, 1))  //  Number type is 1
7811                 {   Return (6)  }   //  failure
7812
7813             //  validate Local0 Number value
7814             If (LNotEqual (Local0, 3))  //  Number value 3
7815                 {   Return (7)  }   //  failure
7816
7817             Store ("And(Match(DerefOf(Index(TIM0,0)),... PASS", Debug)
7818
7819
7820             //  again, validate following produces a nested package
7821             Store (DerefOf (Index (TIM0, 1, )), Local4)
7822
7823             //  save Local4 object type value into Local2
7824             Store (ObjectType (Local4), Local2)
7825
7826             //  validate Local4 is a Package
7827             If (LNotEqual (Local2, 4))  //  Package type is 4
7828                 {   Return (8)  }   //  failure
7829
7830             Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
7831
7832
7833             //  again, validate following produces a nested package
7834             Store (DerefOf (Index (TIM0, 1, )), Local4)
7835
7836             //  save Local4 object type value into Local2
7837             Store (ObjectType (Local4), Local2)
7838
7839             //  validate Local4 is a Package
7840             If (LNotEqual (Local2, 4))  //  Package type is 4
7841                 {   Return (9)  }   //  failure
7842
7843             Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
7844
7845
7846             //  test nested DerefOf(Index) operators
7847             Store (DerefOf (Index (DerefOf (Index (TIM0, 1, )), Local0, )), Local1)
7848
7849             //  save Local1 object type value into Local2
7850             Store (ObjectType (Local1), Local2)
7851
7852             //  validate Local1 is a Number
7853             If (LNotEqual (Local2, 1))  //  Number type is 1
7854                 {   Return (10) }   //  failure
7855
7856             //  zero indicates pass, non-zero is an error code
7857             If (LNotEqual (Local1, 0))
7858                 {   Return (11) }   //  failure
7859
7860             Store ("DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS", Debug)
7861
7862
7863             //  again, validate following produces a nested package
7864             Store (DerefOf (Index (TIM0, 1, )), Local4)
7865
7866             //  save Local4 object type value into Local2
7867             Store (ObjectType (Local4), Local2)
7868
7869             //  validate Local4 is a Package
7870             If (LNotEqual (Local2, 4))  //  Package type is 4
7871                 {   Return (12) }   //  failure
7872
7873             Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
7874
7875
7876             //  retest nested DerefOf(Index) operators
7877             Store (DerefOf (Index (DerefOf (Index (TIM0, 1, )), Local0, )), Local1)
7878
7879             //  save Local1 object type value into Local2
7880             Store (ObjectType (Local1), Local2)
7881
7882             //  validate Local1 is a Number
7883             If (LNotEqual (Local2, 1))  //  Number type is 1
7884                 {   Return (13) }   //  failure
7885
7886             //  zero indicates pass, non-zero is an error code
7887             If (LNotEqual (Local1, 0))
7888                 {   Return (14) }   //  failure
7889
7890             Store ("DerefOf(Index(DerefOf(Index(TIM0,1)),... PASS again", Debug)
7891
7892
7893             //  again, validate following produces a nested package
7894             Store (DerefOf (Index (TIM0, 1, )), Local4)
7895
7896             //  save Local4 object type value into Local2
7897             Store (ObjectType (Local4), Local2)
7898
7899             //  validate Local4 is a Package
7900             If (LNotEqual (Local2, 4))  //  Package type is 4
7901                 {   Return (15) }   //  failure
7902
7903             Store ("DerefOf(Index(TIM0,1)),... PASS again", Debug)
7904
7905
7906             Return (0)  //  pass
7907         }   //  TEST
7908     }   // MTCH
7909
7910 //
7911 // test WhileBrk.asl
7912 //
7913 //  This code tests the Break term and While term
7914 //
7915 //  Syntax of Break term
7916 //      BreakTerm := Break
7917 //  The break operation causes the current package execution to complete.
7918 //
7919 //  Syntax of While Term
7920 //      WhileTerm   := While(
7921 //          Predicate   //TermArg=>Integer
7922 //      ) {TermList}
7923 //  Predicate is evaluated as an integer.
7924 //  If the integer is non-zero, the list of terms in TermList is executed.
7925 //  The operation repeats until the Predicate evaluates to zero.
7926 //
7927 // MTL NOTE: This test has been modified to reflect ACPI 2.0 break
7928 // NOTE: This test, when run under the MS ACPI.SYS grinds the system to
7929 //  a halt.
7930 //
7931     Device (WHLB)
7932     {
7933         Name (CNT0, 0)
7934         Name (CNT1, 0)
7935
7936         Method (TEST)
7937         {
7938             //  Check Break statement nested in If nested in While nested in
7939             //  While only exits inner-most While loop
7940             Store (0, CNT0)
7941
7942             While (LLess (CNT0, 4))
7943             {
7944                 Store (0, CNT1)
7945                 While (LLess (CNT1, 10))
7946                 {
7947                     if (LEqual (CNT1, 1))
7948                     {
7949                         Break       //  exit encompassing loop
7950                     }
7951
7952                     Increment (CNT1)
7953                 }
7954
7955                 If (LNotEqual (CNT1, 1))
7956                 {
7957                     //  failure
7958                     Return (7)
7959                 }
7960
7961                 Increment (CNT0)
7962             }
7963
7964             //  Verify Break only exited inner-most While loop
7965
7966             If (LNotEqual (CNT0, 4))
7967             {
7968                 //  failure
7969                 Return (8)
7970             }
7971
7972             Store ("While/While/If/Break PASS", Debug)
7973
7974             Store ("++++++++ WhileBrk Test", Debug)
7975
7976             //  Check Break statement nested in While
7977             Store (0, CNT0)
7978
7979             While (LLess (CNT0, 10))
7980             {
7981                 Break       //  exit encompassing package
7982                 Increment (CNT0)
7983             }
7984
7985             If (LNotEqual (CNT0, 0))    //  instruction after Break executed
7986             {
7987                 Return (4)
7988             }
7989
7990
7991             Store (0, CNT0)
7992
7993             //  Test While Term
7994             While (LLess (CNT0, 10))
7995             {
7996                 Increment (CNT0)
7997             }
7998
7999             //  Check if the while loop was executed until the condition is satisfied.
8000             If (LNotEqual (CNT0, 10))
8001             {
8002                 Return (1)
8003             }
8004
8005
8006             //  While loop in a reverse order
8007             While (LGreater (CNT0, 0))
8008             {
8009                 Decrement (CNT0)
8010             }
8011
8012             //  Check if the while loop was executed until the condition is satisfied.
8013             If (LNotEqual (CNT0, 0))
8014             {
8015                 Return (2)
8016             }
8017
8018
8019             Store ("While/Break PASS", Debug)
8020
8021
8022             //  Check Break statement nested in If nested in While
8023             Store (0, CNT0)
8024
8025             While (LLess (CNT0, 10))
8026             {
8027                 if (LEqual (CNT0, 5))
8028                 {
8029                     Break       //  exit encompassing Package (If)
8030
8031                     //  if we execute the next instruction,
8032                     //  Break did not exit the loop
8033                     Store (20, CNT0)    //  exit While loop with value larger
8034                                             //  than above
8035                 }
8036
8037                 Increment (CNT0)    //  check if Break exited both If and While
8038             }   //  While
8039
8040             If (LGreater (CNT0, 19))
8041             {   //  instruction after Break inside IfOp executed
8042                 Return (5)
8043             }
8044
8045             //
8046             // Break will exit out of the while loop, therefore
8047             //  the CNT0 counter should still Increment until 5
8048             //
8049             If (LNotEqual (CNT0, 5))
8050             {   //  instruction after Break inside WhileOp executed
8051                 Return (6)
8052             }
8053             Store ("While/If/Break PASS", Debug)
8054
8055
8056             //  All the conditions passed
8057             Return (0)
8058         }   //  TEST
8059     }   //  WHLB
8060
8061
8062 //
8063 // test IndexOp2.asl
8064 //
8065 //  Additional IndexOp test cases to support ACPICMB (control method battery
8066 //  test) on Toshiba Portege 7020CT. Test cases include appropriate bit
8067 //  shifting of Field elements and reading Field elements greater than 64 bits.
8068 //
8069 // MTL NOTE: This test has been modified slightly from the original test
8070 //  to take into account ACPI specification limitations.
8071 //
8072     Scope (\_SB)    //  System Bus
8073     {   //  _SB system bus
8074
8075         Device (MEM)
8076         {   //  MEM
8077             Name (_HID, 0x010CD041)
8078             Name (_STA, 0x0F)
8079
8080             OperationRegion (SMEM, SystemMemory, 0x800000, 0x100)
8081             Field (SMEM, AnyAcc, NoLock, Preserve)
8082             {   //  Field:  SMEM overlay using 32-bit field elements
8083                 SMD0,   32, //  32-bits
8084                 SMD1,   32,     //  32-bits
8085                 SMD2,   32,     //  32-bits
8086                 SMD3,   32  //  32-bits
8087             }   //  Field:  SMEM overlay using 32-bit field elements
8088             Field (SMEM, AnyAcc, NoLock, Preserve)
8089             {   //  Field:  SMEM overlay using greater than 32-bit field elements
8090                 SME0,   69, //  larger than an integer (32 or 64)
8091                 SME1,   97  //  larger than an integer
8092             }   //  Field:  SMEM overlay using greater than 32-bit field elements
8093
8094             OperationRegion (SRAM, SystemMemory, 0x100B0000, 0xF000)
8095             Field (SRAM, AnyAcc, NoLock, Preserve)
8096             {   //  Field:  SRAM overlay
8097                     ,   0x34000,    //  skip
8098                 IEAX,   0x20,
8099                 IEBX,   0x20,
8100                 IECX,   0x20,
8101                 IEDX,   0x20,
8102                 IESI,   0x20,
8103                 IEDI,   0x20,
8104                 IEBP,   0x20,
8105                     ,   0x20,
8106                 OEAX,   0x20,
8107                 OEBX,   0x20,
8108                 OECX,   0x20,
8109                 OEDX,   0x20,
8110                 OESI,   0x20,
8111                 OEDI,   0x20,
8112                 OEBP,   0x20,
8113                     ,   0x618,  //  skip
8114                 ACST,   1,
8115                 BES1,   1,
8116                 BES2,   1,
8117                     ,   5,          //  skip
8118                 BMN1,   0x68,
8119                 BSN1,   0x58,
8120                 BTP1,   0x48,
8121                 BPU1,   0x20,
8122                 BDC1,   0x20,
8123                 BLF1,   0x20,
8124                 BTC1,   0x20,
8125                 BDV1,   0x20,
8126                 BST1,   0x20,
8127                 BPR1,   0x20,
8128                 BRC1,   0x20,
8129                 BPV1,   0x20,
8130                     ,   0x20,
8131                 BCW1,   0x20,
8132                 BCL1,   0x20,
8133                 BG11,   0x20,
8134                 BG21,   0x20,
8135                 BOI1,   0x20,
8136                     ,   0x530,  //  skip
8137                 BMN2,   0x68,
8138                 BSN2,   0x58,
8139                 BTP2,   0x48,
8140                 BPU2,   0x20,
8141                 BDC2,   0x20,
8142                 BLF2,   0x20,
8143                 BTC2,   0x20,
8144                 BDV2,   0x20,
8145                 BST2,   0x20,
8146                 BPR2,   0x20,
8147                 BRC2,   0x20,
8148                 BPV2,   0x20,
8149                     ,   0x20,
8150                 BCW2,   0x20,
8151                 BCL2,   0x20,
8152                 BG12,   0x20,
8153                 BG22,   0x20,
8154                 BOI2,   0x20,
8155                     ,   0x518,  //  skip
8156                 AC01,   0x10,
8157                 AC11,   0x10,
8158                 PSV1,   0x10,
8159                 CRT1,   0x10,
8160                 TMP1,   0x10,
8161                 AST1,   0x10,
8162                 AC21,   0x10,
8163                 AC31,   0x10,
8164                 AC02,   0x10,
8165                 AC12,   0x10,
8166                 PSV2,   0x10,
8167                 CRT2,   0x10,
8168                 TMP2,   0x10,
8169                 AST2,   0x10,
8170                 AC22,   0x10,
8171                 AC32,   0x10,
8172                 AC03,   0x10,
8173                 AC13,   0x10,
8174                 PSV3,   0x10,
8175                 CRT3,   0x10,
8176                 TMP3,   0x10,
8177                 AST3,   0x10,
8178                 AC23,   0x10,
8179                 AC33,   0x10,
8180                     ,   0x80,       //  skip
8181                 TMPF,   0x10,
8182                     ,   0x570,  //  skip
8183                 FANH,   1,
8184                 FANL,   7,
8185                 TF11,   1,
8186                 TF21,   1,
8187                 TF31,   1,
8188                     ,   1,
8189                 TF10,   1,
8190                 TF20,   1,
8191                 TF30,   1,
8192                     ,   1,
8193                 TP11,   1,
8194                 TP21,   1,
8195                 TP31,   1,
8196                     ,   0x6D,   //  109
8197                 GP50,   1,
8198                 GP51,   1,
8199                 GP52,   1,
8200                 GP53,   1,
8201                     ,   4,
8202                 GP60,   1,
8203                 GP61,   1,
8204                 GP62,   1,
8205                 GP63,   1,
8206                 GP64,   1,
8207                 GP65,   1,
8208                 GP66,   1,
8209                     ,   1,
8210                 GP70,   1,
8211                 GP71,   1,
8212                 GP72,   1,
8213                 GP73,   1,
8214                 GP74,   1,
8215                 GP75,   1,
8216                 GP76,   1,
8217                     ,   1,
8218                 WED0,   1,
8219                 WED1,   1,
8220                 WED2,   1,
8221                 WED3,   1,
8222                 WED4,   1,
8223                     ,   3,
8224                 SBL0,   1,
8225                 SBL1,   1,
8226                 SBL2,   1,
8227                 SBL3,   1,
8228                     ,   4,
8229                 LIDS,   1,
8230                 VALF,   1,
8231                     ,   2,
8232                 DCKI,   1,
8233                 DCKF,   1,
8234                 BT1F,   1,
8235                 BT2F,   1,
8236                     ,   0x7D0,  //  skip
8237                 HKCD,   8,
8238                     ,   8,
8239                 DLID,   0x20,
8240                 DSRN,   0x20,
8241                     ,   0x20,
8242                 BDID,   0x20,
8243                 DSPW,   1,
8244                 VGAF,   1,
8245                 VWE0,   1,
8246                 VWE1,   1,
8247                 PPSC,   1,
8248                 SPSC,   1,
8249                 EWLD,   1,
8250                 EWPS,   1,
8251                     ,   0x1768, //  skip
8252                 PRES,   0x8000
8253             }   //  Field:  SRAM overlay
8254         }   //  MEM
8255
8256         Device (BAT1)
8257         {   //  BAT1
8258             Name (_HID, EISAID ("PNP0C0A"))     //  Control Method Battey ID
8259             Name (_UID, 1)
8260             Name (_PCL, Package (1) {\_SB})
8261
8262             Method (_STA)
8263             {   //  _STA
8264                 If (\_SB.MEM.BES1)
8265                     {   Return (0x1F)   }   //  battery present
8266                 Else
8267                     {   Return (0x0F)   }   //  battery not present
8268             }   //  _STA
8269
8270             Method (_BIF,, Serialized)
8271             {   //  _BIF
8272                 Name (BUFR, Package (13)    {})
8273
8274                 Store (\_SB.MEM.BPU1, Index (BUFR, 0))
8275                 Store (\_SB.MEM.BDC1, Index (BUFR, 1))
8276                 Store (\_SB.MEM.BLF1, Index (BUFR, 2))
8277                 Store (\_SB.MEM.BTC1, Index (BUFR, 3))
8278                 Store (\_SB.MEM.BDV1, Index (BUFR, 4))
8279                 Store (\_SB.MEM.BCW1, Index (BUFR, 5))
8280                 Store (\_SB.MEM.BCL1, Index (BUFR, 6))
8281                 Store (\_SB.MEM.BG11, Index (BUFR, 7))
8282                 Store (\_SB.MEM.BG21, Index (BUFR, 8))
8283                 Store (\_SB.MEM.BMN1, Index (BUFR, 9))
8284                 Store (\_SB.MEM.BSN1, Index (BUFR, 10))
8285                 Store (\_SB.MEM.BTP1, Index (BUFR, 11))
8286                 Store (\_SB.MEM.BOI1, Index (BUFR, 12))
8287
8288                 Return (BUFR)
8289             }   //  _BIF
8290         }   //  BAT1
8291
8292         Device (IDX2)
8293         {
8294             Method (B2IB,, Serialized)
8295             {   //  B2IB:   store from Buffer into Index'ed Buffer
8296
8297                 Name (SRCB, Buffer ()   {"Short Buffer"})   //  12 characters plus NULL
8298
8299                 Name (DEST, Buffer ()                           //  62 characters plus NULL
8300                     {"Destination buffer that is longer than the short source buffer"})
8301
8302
8303                 //  verify object type returned by Index(Buffer,Element,)
8304
8305                 Store (Index (DEST, 2, ), Local1)
8306                 Store (ObjectType (Local1), Local2)
8307
8308                 If (LNotEqual (Local2, 14))     //  Buffer Field is type 14
8309                 {
8310                     //  Local2 indicates Local1 is not a Buffer Field
8311
8312                     Return (0x61)
8313                 }
8314
8315                 //  verify object type and value returned by DerefOf(Index(Buffer,Element,))
8316                 //  should return Number containing element value
8317
8318                 Store (DerefOf (Local1), Local3)
8319                 Store (ObjectType (Local3), Local4)
8320
8321                 If (LNotEqual (Local4, 1))          //  Number is type 1
8322                 {
8323                     //  Local2 indicates Local1 is not a Number
8324                     Return (0x62)
8325                 }
8326                 Else
8327                 {
8328                     If (LNotEqual (Local3, 0x73))       //  expect 's' element from DEST
8329                     {
8330                         Return (0x63)
8331                     }
8332                 }
8333
8334                 Store ("DerefOf(Index(Buffer,,)) PASS", Debug)
8335
8336
8337                 //
8338                 // The following sections have been rewritten because storing into
8339                 // an Indexed buffer only changes one byte - the FIRST byte of the
8340                 // buffer is written to the source index.  This is the ONLY byte
8341                 // written -- as per ACPI 2.0
8342                 //
8343                 // Overwrite DEST contents, at buffer position 2 [only]
8344
8345                 Store (SRCB, Index (DEST, 2, ))
8346
8347                 //
8348                 // Check that the next byte is not changed
8349                 //
8350                 Store (DerefOf (Index (DEST, 3, )), Local0)
8351                 If (LNotEqual (Local0, 0x74))       //  't'
8352                 {
8353                     //  DEST element is not matching original value
8354                     If (LEqual (Local0, 0x68))
8355                     {
8356                         //  DEST element was altered to 'h'
8357                         Return (0x68)
8358                     }
8359                     Else
8360                     {
8361                         // DEST element is an unknown value
8362                         Return (0x69)
8363                     }
8364                 }
8365
8366                 //
8367                 // Check that the elements beyond the SRCB buffer copy
8368                 //  have not been altered.
8369                 //
8370                 Store (DerefOf (Index (DEST, 14)), Local0)
8371
8372                 //
8373                 // This should be an 'f'.
8374                 //
8375                 If (LNotEqual (Local0, 0x66))
8376                 {
8377                     //  DEST element was zero'd by buffer copy
8378                     If (LEqual (Local0, 0))
8379                     {
8380                         //  DEST element is zero
8381                         Return (0x6A)
8382                     }
8383                     Else
8384                     {
8385                         //  DEST element is unknown value
8386                         Return (0x6B)
8387                     }
8388                 }
8389
8390                 Store ("Store(SRCB,Index(Buffer,,)) PASS", Debug)
8391
8392                 //
8393                 //  verify altering SRCB does NOT alter DEST
8394                 //
8395                 Store (0x6A, Index (SRCB, 1))   //  SRCB = "Sjort Buffer"
8396
8397                 Store (DerefOf (Index (SRCB, 1)), Local0)
8398
8399                 If (LNotEqual (Local0, 0x6A))       //  'j'
8400                 {
8401                     //  SRCB element is unaltered
8402                     Return (0x71)
8403                 }
8404
8405                 Store (DerefOf (Index (DEST, 3)), Local0) // DEST = "Destination buffer that...
8406
8407                 If (LNotEqual (Local0, 0x74))       //  't'
8408                 {
8409                     //  DEST element is altered
8410                     If (LEqual (Local0, 0x6A))  //  'j'
8411                     {
8412                         //  SRCB change altered DEST element
8413                         Return (0x72)
8414                     }
8415                     Else
8416                     {
8417                         //  DEST element is unknown value
8418                         Return (0x73)
8419                     }
8420                 }
8421
8422                 //  verify altering DEST does NOT alter SRCB
8423
8424                 Store (0x6B, Index (DEST, 4, )) //  DEST = "DeSkination buffer..."
8425
8426                 Store (DerefOf (Index (DEST, 4, )), Local0)
8427
8428                 If (LNotEqual (Local0, 0x6B))       //  'k'
8429                 {
8430                     //  DEST element is unaltered
8431                     Return (0x74)
8432                 }
8433
8434                 Store (DerefOf (Index (SRCB, 2, )), Local0)
8435
8436                 If (LNotEqual (Local0, 0x6F))       //  'o'
8437                 {   //  SRC element is altered
8438                     If (LEqual (Local0, 0x6B))  //  'k'
8439                     {
8440                         //  DEST change altered SRCB element
8441                         Return (0x75)
8442                     }
8443                     Else
8444                     {
8445                         //  SRCB element is unknown value
8446                         Return (0x76)
8447                     }
8448                 }
8449
8450                 Store ("SRCB and DEST independent PASS", Debug)
8451
8452
8453                 // verify string can be written to Index target/destination
8454                 // Only FIRST byte is written
8455
8456                 Store ("New Buff", Index (DEST, 2, ))   //  DEST = "DeNkination buffer..."
8457
8458                 Store (DerefOf (Index (DEST, 2, )), Local0)
8459
8460                 If (LNotEqual (Local0, 0x4E))       //  'N'
8461                 {
8462                     //  DEST element is unaltered
8463                     Return (0x81)
8464                 }
8465
8466                 Store (DerefOf (Index (DEST, 6, )), Local0)
8467
8468                 If (LNotEqual (Local0, 0x61))       //  'a'
8469                 {
8470                     //  DEST element is unaltered
8471                     Return (0x82)
8472                 }
8473
8474                 Store (DerefOf (Index (DEST, 10, )), Local0)
8475
8476                 If (LNotEqual (Local0, 0x6E))       //  'n'
8477                 {
8478                     //  DEST element is unaltered
8479                     Return (0x83)
8480                 }
8481
8482                 Store ("Store(String,Index) PASS", Debug)
8483
8484
8485                 Return (0)  //  pass
8486             }   //  B2IB:   store from Buffer into Index'ed Buffer
8487
8488             Method (FB2P,, Serialized)
8489             {   //  FB2P:   store from Field Buffer into Index'ed Package
8490                 Name (DEST, Package (2) {})
8491
8492                 //  initialize memory using 32-bit field elements
8493                 Store (0x01234567, \_SB.MEM.SMD0)
8494                 Store (0x89ABCDEF, \_SB.MEM.SMD1)
8495                 Store (0xFEDCBA98, \_SB.MEM.SMD2)
8496                 Store (0x76543210, \_SB.MEM.SMD3)
8497
8498                 //  move greater than 64-bit buffers into DEST package
8499                 Store (\_SB.MEM.SME0, Index (DEST, 0))
8500                 Store (\_SB.MEM.SME1, Index (DEST, 1))
8501
8502                 //  validate DEST contents
8503                 Store (DerefOf (Index (DEST, 0, )), Local0)
8504                 Store (DerefOf (Index (DEST, 1, )), Local1)
8505
8506                 //  verify Local0 and Local1 are Buffers
8507                 Store (ObjectType (Local0), Local2)
8508                 if (LNotEqual (Local2, 3))  //  Buffer type is 3
8509                 {
8510                     Return (0x11)
8511                 }
8512
8513                 Store (ObjectType (Local1), Local3)
8514                 if (LNotEqual (Local3, 3))  //  Buffer type is 3
8515                 {
8516                     Return (0x12)
8517                 }
8518
8519                 //  validate DEST buffer contents
8520                 Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 0)), Local4)
8521                 If (LNotEqual (Local4, 0x67))
8522                 {
8523                     Return (0x13)
8524                 }
8525
8526                 Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 1)), Local4)
8527                 If (LNotEqual (Local4, 0x45))
8528                 {
8529                     Return (0x14)
8530                 }
8531
8532                 Store (DerefOf (Index (DerefOf (Index (DEST, 0)), 4)), Local4)
8533                 If (LNotEqual (Local4, 0xEF))
8534                 {
8535                     Return (0x15)
8536                 }
8537
8538                 Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 5, )), Local4)
8539                 If (LNotEqual (Local4, 0xCD))
8540                 {
8541                     Return (0x16)
8542                 }
8543
8544                 Store ("Store(Mem,PkgElement) PASS", Debug)
8545
8546
8547                 //  validate changing source \_SB.MEM.SMD* does not impact DEST
8548                 Store (0x12345678, \_SB.MEM.SMD0)
8549
8550                 Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 0, )), Local5)
8551                 If (LNotEqual (Local5, 0x67))
8552                 {
8553                     Return (0x21)
8554                 }
8555
8556                 Store (DerefOf (Index (DerefOf (Index (DEST, 0, )), 1, )), Local5)
8557                 If (LNotEqual (Local5, 0x45))
8558                 {
8559                     Return (0x22)
8560                 }
8561
8562                 //  validate changing DEST does not impact source \_SB.MEM.SMD*
8563                 Store (0x30, Index (DerefOf (Index (DEST, 0)), 0))
8564
8565                 Store (DerefOf(Index (DerefOf (Index (DEST, 0)), 0)), Local5)
8566                 If (LNotEqual (Local5, 0x30))
8567                 {
8568                     Return (0x23)
8569                 }
8570
8571                 //
8572                 // This section was modified from the original iPCO code because
8573                 //  it attempted to compare two buffers.  This is not allowed until
8574                 //  ACPI v2.0, so the test has been modified to just check the
8575                 //  changed \_SB.MEM.SMD0
8576                 //
8577                 Store (\_SB.MEM.SMD0, Local5)
8578
8579                 If(LNotEqual(Local5, 0x12345678))
8580                 {
8581                     Return (0x24)
8582                 }
8583
8584                 Store ("Mem and Pkg independent PASS", Debug)
8585
8586
8587                 Return (0)
8588             }   //  FB2P:   store from Field Buffer into Index'ed Package
8589
8590             Method (TEST)
8591             {
8592                 Store ("++++++++ IndexOp2 Test", Debug)
8593
8594                 //  store _BIF package return value into Local0
8595
8596                 Store (\_SB.BAT1._BIF, Local0)
8597
8598                 //  save Local0 object type value into Local1
8599                 Store (ObjectType (Local0), Local1)
8600
8601                 //  validate Local0 is a Package
8602                 If (LNotEqual (Local1, 4))  //  Package type is 4
8603                 {
8604                     //  failure
8605                     Return (2)
8606                 }
8607
8608                 //  validate source and destination buffers are independent of each
8609                 //  of each other (i.e., changing one's contents does not change
8610                 //  other's contents) using B2IB (store from Buffer into Index'ed
8611                 //  Buffer) and FB2P (store from Field Buffer into Index'ed Package)
8612
8613                 //  call B2IB (store from Buffer into Index'ed Buffer)
8614                 Store (B2IB, Local2)    //  Local2 is B2IB return value
8615
8616                 //  save Local2 object type value into Local3
8617                 Store (ObjectType (Local2), Local3)
8618
8619                 //  validate Local2 is a Number
8620                 If (LNotEqual (Local3, 1))  //  Number type is 1
8621                 {
8622                     //  failure
8623                     Return (4)
8624                 }
8625
8626                 //  zero indicates pass, non-zero is an error code
8627                 If (LNotEqual (Local2, 0))
8628                 {
8629                     //  return B2IB error code
8630                     Return (Local2)
8631                 }
8632
8633                 //  call FB2P (store from Field Buffer into Index'ed Package)
8634                 Store (FB2P, Local2)    //  Local2 is FB2P return value
8635
8636                 //  save Local2 object type value into Local3
8637                 Store (ObjectType (Local2), Local3)
8638
8639                 //  validate Local2 is a Number
8640                 If (LNotEqual (Local3, 1))  //  Number type is 1
8641                 {
8642                     //  failure
8643                     Return (5)
8644                 }
8645
8646                 //  zero indicates pass, non-zero is an error code
8647                 If (LNotEqual (Local2, 0))
8648                 {
8649                     //  return FB2P error code
8650                     Return (Local2)
8651                 }
8652
8653
8654                 Return (0)
8655             }   //  TEST
8656         }   //  IDX2:   Test device name
8657     }   //  _SB system bus
8658
8659 //
8660 // test SizeOf.asl
8661 //
8662 //  Test for SizeOf
8663 //      test cases include following SizeOf arguments:
8664 //          buffer, buffer field;
8665 //          control method argument, control method local variable;
8666 //          control method return values;
8667 //          direct string, string;
8668 //          package;
8669 //          buffer, package, and string package elements
8670 //
8671 // MTL NOTE: This test has been modified to remove any SizeOf(Index(Buff,...
8672 //  calls because it is not legal to perform a SizeOf operation on a Buffer Field.
8673 //  This test has also been extended to test additional Package element sizes.
8674 //
8675     Device (SIZO)
8676     {
8677         //  SAR0 control method validates SizeOf(Arg)
8678         //      SAR0 should only be called by SARG
8679         Method (SAR0, 2)
8680         //  Arg0    object to determine size of
8681         //  Arg1    expected Arg length
8682         {   //  SAR0:   SizeOf(Arg) test control method
8683             //  Local0  Arg0 length
8684             //  Local1  Local0 object type
8685
8686             //  Store first string size (Arg0) into Local7
8687             Store (SizeOf (Arg0), Local0)
8688
8689             //  save Local0 object type value into Local1
8690             Store (ObjectType (Local0), Local1)
8691
8692             //  validate Local0 is a Number
8693             If (LNotEqual (Local1, 1))      //  Number type is 1
8694                 {   Return (0x21)   }
8695
8696             //  If strings are not of equal size, return error code
8697             If (LNotEqual (Local0, Arg1))
8698                 {   Return (0x22)   }
8699
8700             Return (0)
8701         }   //  SAR0:   SizeOf(Arg) test control method
8702
8703         Method (SARG,, Serialized)
8704         {   //  SARG:   SizeOf(Arg) test control method
8705             Name (BUFR, Buffer (12) {}) //  uninitialized Buffer
8706             Name (BUF1, Buffer() {0x01, 0x02, 0x03, 0x04, 0x05})
8707             Name (PKG0, Package (4) {}) //  uninitialized Package
8708             Name (STR0, "String")
8709             Name (PKG1, Package (4)
8710             {
8711                 BUFR,
8712                 "String2",
8713                 STR0,
8714                 PKG0
8715             })  //  PKG1
8716
8717             Name (PKG2, Package (4)
8718             {
8719                 Buffer (15) {},
8720                 "String 1",
8721                 Package (2) {}
8722             })  //  PKG2
8723
8724             //  Namespace entry buffer reference
8725             Store (SAR0 (BUFR, 12), Local0)
8726
8727             //  save Local0 object type value into Local1
8728             Store (ObjectType (Local0), Local1)
8729
8730             //  validate Local0 is a Number
8731             If (LNotEqual (Local1, 1))      //  Number type is 1
8732             {
8733                 Return (0x23)
8734             }
8735
8736             If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8737             {
8738                 Return (Local0)
8739             }
8740
8741             Store ("SizeOf(Arg=BUFR) PASS", Debug)
8742
8743
8744             //  Namespace entry package reference
8745             Store (SAR0 (PKG0, 4), Local0)
8746
8747             //  save Local0 object type value into Local1
8748             Store (ObjectType (Local0), Local1)
8749
8750             //  validate Local0 is a Number
8751             If (LNotEqual (Local1, 1))      //  Number type is 1
8752             {
8753                 Return (0x24)
8754             }
8755
8756             If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8757             {
8758                 Return (Local0)
8759             }
8760
8761             Store ("SizeOf(Arg=PKG0) PASS", Debug)
8762
8763
8764             //  Namespace entry string reference
8765             Store (SAR0 (STR0, 6), Local0)
8766
8767             //  save Local0 object type value into Local1
8768             Store (ObjectType (Local0), Local1)
8769
8770             //  validate Local0 is a Number
8771             If (LNotEqual (Local1, 1))      //  Number type is 1
8772             {
8773                 Return (0x25)
8774             }
8775
8776             If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8777             {
8778                 Return (Local0)
8779             }
8780
8781             Store ("SizeOf(Arg=STR0) PASS", Debug)
8782
8783
8784             //  direct string reference
8785             Store (SAR0 ("String", 6), Local0)
8786
8787             //  save Local0 object type value into Local1
8788             Store (ObjectType (Local0), Local1)
8789
8790             //  validate Local0 is a Number
8791             If (LNotEqual (Local1, 1))      //  Number type is 1
8792             {
8793                 Return (0x26)
8794             }
8795
8796             If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8797             {
8798                 Return (Local0)
8799             }
8800
8801             Store ("SizeOf(Arg=String) PASS", Debug)
8802
8803             Store (0x55, Index (BUF1, 2))
8804
8805             /****************************************************
8806             //
8807             // This section is commented because it is illegal to
8808             //  perform a SizeOf operation on a Buffer Field
8809             //
8810             //  Namespace BufferField reference
8811             Store (SAR0 (Index (BUFR, 2, ), 10), Local0)
8812
8813             //  save Local0 object type value into Local1
8814             Store (ObjectType (Local0), Local1)
8815
8816             //  validate Local0 is a Number
8817             If (LNotEqual (Local1, 1))      //  Number type is 1
8818                 {   Return (0x27)   }
8819
8820             If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8821                 {   Return (Local0) }
8822
8823             Store ("SizeOf(Arg=BufferField) PASS", Debug)
8824             ****************************************************/
8825
8826             //  Namespace BufferPackageElement reference
8827             //
8828             Store (SAR0 (Index(PKG1, 0), 12), Local0)
8829
8830             //  save Local0 object type value into Local1
8831             Store (ObjectType (Local0), Local1)
8832
8833             //  validate Local0 is a Number
8834             If (LNotEqual (Local1, 1))      //  Number type is 1
8835             {
8836                 Return (0x28)
8837             }
8838
8839             If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8840             {
8841                 Return (Local0)
8842             }
8843
8844             Store ("SizeOf(Arg=PackageBuffer NTE Reference Element) PASS", Debug)
8845
8846
8847             //  Namespace StringPackageElement reference
8848             Store (SAR0 (Index (PKG1, 1, ), 7), Local0)
8849
8850             //  save Local0 object type value into Local1
8851             Store (ObjectType (Local0), Local1)
8852
8853             //  validate Local0 is a Number
8854             If (LNotEqual (Local1, 1))      //  Number type is 1
8855             {
8856                 Return (0x29)
8857             }
8858
8859             If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8860             {
8861                 Return (Local0)
8862             }
8863
8864             Store ("SizeOf(Arg=Package String Element) PASS", Debug)
8865
8866
8867             //  Namespace StringPackageElement reference
8868             Store (SAR0 (Index (PKG1, 2, ), 6), Local0)
8869
8870             //  save Local0 object type value into Local1
8871             Store (ObjectType (Local0), Local1)
8872
8873             //  validate Local0 is a Number
8874             If (LNotEqual (Local1, 1))      //  Number type is 1
8875             {
8876                 Return (0x2A)
8877             }
8878
8879             If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8880             {
8881                 Return (Local0)
8882             }
8883
8884             Store ("SizeOf(Arg=Package String NTE Reference Element) PASS", Debug)
8885
8886
8887             //  Namespace PackagePackageElement reference
8888             Store (SAR0 (Index (PKG1, 3, ), 4), Local0)
8889
8890             //  save Local0 object type value into Local1
8891             Store (ObjectType (Local0), Local1)
8892
8893             //  validate Local0 is a Number
8894             If (LNotEqual (Local1, 1))      //  Number type is 1
8895             {
8896                 Return (0x2B)
8897             }
8898
8899             If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8900             {
8901                 Return (Local0)
8902             }
8903
8904             Store ("SizeOf(Arg=Package Package NTE Reference Element) PASS", Debug)
8905
8906             // Package Buffer Element
8907             Store (SAR0 (Index (PKG2, 0), 15), Local0)
8908
8909             //  save Local0 object type value into Local1
8910             Store (ObjectType (Local0), Local1)
8911
8912             //  validate Local0 is a Number
8913             If (LNotEqual (Local1, 1))      //  Number type is 1
8914             {
8915                 Return (0x2B)
8916             }
8917
8918             If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8919             {
8920                 Return (Local0)
8921             }
8922
8923             Store ("SizeOf(Arg=Package Buffer Element) PASS", Debug)
8924
8925             // Package String Element
8926             Store (SAR0 (Index (PKG2, 1), 8), Local0)
8927
8928             //  save Local0 object type value into Local1
8929             Store (ObjectType (Local0), Local1)
8930
8931             //  validate Local0 is a Number
8932             If (LNotEqual (Local1, 1))      //  Number type is 1
8933             {
8934                 Return (0x2B)
8935             }
8936
8937             If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8938             {
8939                 Return (Local0)
8940             }
8941
8942             Store ("SizeOf(Arg=Package String Element) PASS", Debug)
8943
8944             // Package Package Element
8945             Store (SAR0 (Index (PKG2, 2), 2), Local0)
8946
8947             //  save Local0 object type value into Local1
8948             Store (ObjectType (Local0), Local1)
8949
8950             //  validate Local0 is a Number
8951             If (LNotEqual (Local1, 1))      //  Number type is 1
8952             {
8953                 Return (0x2B)
8954             }
8955
8956             If (LNotEqual (Local0, 0))      //  Local0 is SAR0 return error code
8957             {
8958                 Return (Local0)
8959             }
8960
8961             Store ("SizeOf(Arg=Package Package Element) PASS", Debug)
8962
8963             Store ("SizeOf(Arg) PASS", Debug)
8964
8965             Return (0)
8966         }   //  SARG:   SizeOf(Arg) test control method
8967
8968         Method (SBUF,, Serialized)
8969         {   //  SBUF:   SizeOf(Buffer) test control method
8970             Name (BUFR, Buffer (12) {})
8971
8972             //  store size of BUFR buffer into Local0
8973             Store (SizeOf (BUFR), Local0)
8974
8975             //  save Local0 object type value into Local1
8976             Store (ObjectType (Local0), Local1)
8977
8978             //  validate Local0 is a Number
8979             If (LNotEqual (Local1, 1))      //  Number type is 1
8980             {
8981                 Return (0x31)
8982             }
8983
8984             If (LNotEqual (Local0, 12))     //  BUFR size is 12
8985             {
8986                 Return (0x32)
8987             }
8988
8989             Store ("SizeOf(BUFR) PASS", Debug)
8990
8991             Return (0)
8992         }   //  SBUF:   SizeOf(Buffer) test control method
8993
8994
8995         /****************************************************
8996         //
8997         // This section is commented because it is illegal to
8998         //  perform a SizeOf operation on a Buffer Field
8999         //
9000         Method (SIND)
9001         {   //  SIND:   SizeOf(Index(,,)) test control method
9002             Name (BUFR, Buffer (12) {})
9003
9004             //  store size of Index(BUFR,2,) buffer into Local0
9005             Store (SizeOf (Index (BUFR, 2, )), Local0)
9006
9007             //  save Local0 object type value into Local1
9008             Store (ObjectType (Local0), Local1)
9009
9010             //  validate Local0 is a Number
9011             If (LNotEqual (Local1, 1))      //  Number type is 1
9012             {
9013                 Return (0x41)
9014             }
9015
9016             If (LNotEqual (Local0, 10))     //  12 - 2 = 10
9017             {
9018                 Return (0x42)
9019             }
9020
9021             Store ("SizeOf(Index(BUFR,,)) PASS", Debug)
9022
9023             //  TBD:    strings and packages
9024
9025             Return (0)
9026         }   //  SIND:   SizeOf(Index(,,)) test control method
9027         ****************************************************/
9028
9029         Method (SLOC,, Serialized)
9030         {   //  SLOC:   SizeOf(Local) test control method
9031             Name (BUFR, Buffer (12) {}) //  uninitialized Buffer
9032             Name (STR0, "String")
9033             Name (PKG0, Package (4) {}) //  uninitialized Package
9034
9035
9036             //  store BUFR Buffer into Local2
9037             Store (BUFR, Local2)
9038
9039             //  store size of BUFR buffer into Local0
9040             Store (SizeOf (Local2), Local0)
9041
9042             //  save Local0 object type value into Local1
9043             Store (ObjectType (Local0), Local1)
9044
9045             //  validate Local0 is a Number
9046             If (LNotEqual (Local1, 1))      //  Number type is 1
9047             {
9048                 Return (0x51)
9049             }
9050
9051             If (LNotEqual (Local0, 12)) //  BUFR size is 12
9052             {
9053                 Return (0x52)
9054             }
9055
9056             Store ("SizeOf(Local2=Buffer) PASS", Debug)
9057
9058
9059             //  store STR0 string into Local2
9060             Store (STR0, Local2)
9061
9062             //  store size of STR0 buffer into Local0
9063             Store (SizeOf (Local2), Local0)
9064
9065             //  save Local0 object type value into Local1
9066             Store (ObjectType (Local0), Local1)
9067
9068             //  validate Local0 is a Number
9069             If (LNotEqual (Local1, 1))      //  Number type is 1
9070             {
9071                 Return (0x53)
9072             }
9073
9074             If (LNotEqual (Local0, 6))      //  STR0 size is 6
9075             {
9076                 Return (0x54)
9077             }
9078
9079             Store ("SizeOf(Local2=String) PASS", Debug)
9080
9081
9082             //  store PKG0 Package into Local2
9083             Store (PKG0, Local2)
9084
9085             //  store size of PKG0 buffer into Local0
9086             Store (SizeOf (Local2), Local0)
9087
9088             //  save Local0 object type value into Local1
9089             Store (ObjectType (Local0), Local1)
9090
9091             //  validate Local0 is a Number
9092             If (LNotEqual (Local1, 1))      //  Number type is 1
9093             {
9094                 Return (0x55)
9095             }
9096
9097             If (LNotEqual (Local0, 4))      //  PKG0 size is 4
9098             {
9099                 Return (0x56)
9100             }
9101
9102             Store ("SizeOf(Local2=Package) PASS", Debug)
9103
9104
9105             Return (0)
9106         }   //  SLOC:   SizeOf(Local) test control method
9107
9108         Method (TEST)
9109         {
9110             Store ("++++++++ SizeOf Test", Debug)
9111
9112             //  Store current operating system string into Local0
9113             Store (_OS, Local0)
9114
9115             Store (SizeOf (_OS), Local3)
9116
9117             //  save Local3 object type value into Local4
9118             Store (ObjectType (Local3), Local4)
9119
9120             //  validate Local3 is a Number
9121             If (LNotEqual (Local4, 1))  //  Number type is 1
9122             {
9123                 //  failure
9124                 Return (0x61)
9125             }
9126
9127             //  Store current operating system string into Local0
9128             //  This verifies above SizeOf(_OS) did not corrupt ACPI namespace
9129             Store (_OS, Local0)
9130
9131             //  Store SARG [Validate SizeOf(Arg)] return value into Local1
9132             Store (SARG, Local1)
9133
9134             //  save Local1 object type value into Local2
9135             Store (ObjectType (Local1), Local2)
9136
9137             //  validate Local1 is a Number
9138             If (LNotEqual (Local2, 1))  //  Number type is 1
9139             {
9140                 //  failure
9141                 Return (0x62)
9142             }
9143
9144             //  zero indicates pass, non-zero is an error code
9145             If (LNotEqual (Local1, 0))
9146             {
9147                 //  return SARG error code
9148                 Return (Local1)
9149             }
9150
9151
9152             //  Store SBUF [Validate SizeOf(Buffer)] return value into Local1
9153             Store (SBUF, Local1)
9154
9155             //  save Local1 object type value into Local2
9156             Store (ObjectType (Local1), Local2)
9157
9158             //  validate Local1 is a Number
9159             If (LNotEqual (Local2, 1))  //  Number type is 1
9160             {
9161                 //  failure
9162                 Return (0x63)
9163             }
9164
9165             //  zero indicates pass, non-zero is an error code
9166             If (LNotEqual (Local1, 0))
9167             {
9168                 //  return SBUF error code
9169                 Return (Local1)
9170             }
9171
9172             /****************************************************
9173             //
9174             // This section is commented because it is illegal to
9175             //  perform a SizeOf operation on a Buffer Field
9176             //
9177             //  Store SIND [verify SizeOf(Index(,,))] return value into Local1
9178             Store (SIND, Local1)
9179
9180             //  save Local1 object type value into Local2
9181             Store (ObjectType (Local1), Local2)
9182
9183             //  validate Local1 is a Number
9184             If (LNotEqual (Local2, 1))  //  Number type is 1
9185             {
9186                 //  failure
9187                 Return (0x64)
9188             }
9189
9190             //  zero indicates pass, non-zero is an error code
9191             If (LNotEqual (Local1, 0))
9192             {
9193                 //  return SARG error code
9194                 Return (Local1)
9195             }
9196             ****************************************************/
9197
9198             //  Store SLOC [verify SizeOf(Local)] return value into Local1
9199             Store (SLOC, Local1)
9200
9201             //  save Local1 object type value into Local2
9202             Store (ObjectType (Local1), Local2)
9203
9204             //  validate Local1 is a Number
9205             If (LNotEqual (Local2, 1))  //  Number type is 1
9206             {
9207                 //  failure
9208                 Return (0x65)
9209             }
9210
9211             //  zero indicates pass, non-zero is an error code
9212             If (LNotEqual (Local1, 0))
9213             {
9214                 //  return SLOC error code
9215                 Return (Local1)
9216             }
9217
9218
9219             //  TBD:    SizeOf (METH) -- where METH control method returns
9220             //              buffer, BufferField, string, package, package element
9221
9222
9223             Return (0)
9224         }   //  TEST
9225     }   //  SIZO
9226
9227 //
9228 // test SmiShare.asl
9229 //
9230     Scope (\_SB)    //  System Bus
9231     {   //  _SB system bus
9232         //  Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long
9233         OperationRegion(RAM1, SystemMemory, 0x400000, 0xA)
9234
9235         Field (RAM1, AnyAcc, NoLock, Preserve)
9236         {
9237             BI1T, 1,        // Create some bits in memory to access
9238             BI2T, 2,
9239             BI3T, 3,
9240             LST2, 2
9241         }   //  End Field RAM1
9242
9243         Field (RAM1, WordAcc, NoLock, WriteAsZeros)
9244         {
9245             WRD, 16
9246         }   //  End 2nd Field RAM1
9247
9248         Field (RAM1, ByteAcc, NoLock, WriteAsOnes)
9249         {
9250             BYTE, 8
9251         }   //  End 3rd Field RAM1
9252
9253         Field (RAM1, ByteAcc, NoLock, Preserve)
9254         {
9255             SMIC, 8,
9256             SMID, 8
9257         }
9258
9259         Device (MBIT)
9260         {
9261             Method (_INI)
9262             {
9263                 Store (0, BI1T)
9264                 Store (3, BI2T)
9265                 Store (7, BI3T)
9266                 Store (0, LST2)
9267             }   //  End _INI Method
9268         }   //  End Device MBIT
9269
9270         Device (MWRD)
9271         {
9272             Method (_INI)
9273             {
9274                 Store (0, WRD)
9275             }   //  End _INI Method
9276         }   //  End Device MWRD
9277
9278         Device (MBYT)
9279         {
9280             Method (_INI)
9281             {
9282                 Store (0, BYTE)
9283                 Store (0xC, SMIC)
9284                 Store (0xD, SMID)
9285             }   //  End _INI Method
9286         }   //  End Device MBYT
9287
9288     /*
9289         //  Declare an OpRegion in Memory starting at offset 0x400000 that is 10 bytes long
9290         OperationRegion(\RAM1, SystemMemory, 0x400000, 0xA)
9291
9292         Field (\RAM1, AnyAcc, NoLock, Preserve)
9293         {
9294             BI1T, 1,        // Create some bits in memory to access
9295             BI2T, 2,
9296             BI3T, 3,
9297             LST2, 2
9298         }   //  End Field RAM1
9299
9300         Field (\RAM1, WordAcc, NoLock, WriteAsZeros)
9301         {
9302             WRD, 16
9303         }   //  End 2nd Field RAM1
9304
9305         Field (\RAM1, ByteAcc, NoLock, WriteAsOnes)
9306         {
9307             BYTE, 8
9308         }   //  End 3rd Field RAM1
9309
9310         Field (\RAM1, ByteAcc, NoLock, Preserve)
9311         {
9312             SMIC, 8,
9313             SMID, 8
9314         }
9315     */
9316         Method (SMIX)
9317         {
9318             Return (BYTE)
9319         }   //  End SMIX
9320
9321         Method (EVNT)
9322         {
9323             Store (SMIX, Local0)
9324
9325             Notify (\_SB_, 0x29)
9326             If (And (Local0, 0x01))
9327             {   Notify (\_SB_.SMIS, 0x21)}
9328
9329             If (And (Local0, 0x02))
9330             {   Notify (\_SB_.SMIS, 0x22)}
9331
9332             If (And (Local0, 0x04))
9333             {   Notify (\_SB_.SMIS, 0x24)}
9334
9335             If (And (Local0, 0x08))
9336             {   Notify (\_SB_.SMIS, 0x28)}
9337
9338         }   //  End Method EVNT
9339
9340         Method (NTFY)
9341         {
9342             Notify (\_SB_, 1)
9343             Notify (\_TZ_.TZ1, 2)
9344             Notify (\_PR_.CPU0, 3)
9345
9346             Notify (\_SB_, 0x81)
9347             Notify (\_TZ_.TZ1, 0x82)
9348             Notify (\_PR_.CPU0, 0x83)
9349         }
9350
9351         Device (SMIS)
9352         {
9353             Method (BINK)
9354             {
9355                 Store (0, Local0)               //  Zero out Local0
9356
9357                 If (LNotEqual (SMID, 0xD))
9358                 {   Or (0x80, Local0, Local0)}
9359
9360                 If (LNotEqual (SMIC, 0xC))
9361                 {   Or (0x40, Local0, Local0)}
9362
9363                 If (LNotEqual (BYTE, 0))
9364                 {   Or (0x20, Local0, Local0)}
9365
9366                 If (LNotEqual (WRD, 0))
9367                 {   Or (0x10, Local0, Local0)}
9368
9369                 If (LNotEqual (LST2, 0))
9370                 {   Or (0x8, Local0, Local0)}
9371
9372                 If (LNotEqual (BI3T, 0x7))
9373                 {   Or (0x4, Local0, Local0)}
9374
9375                 If (LNotEqual (BI2T, 0x3))
9376                 {   Or (0x2, Local0, Local0)}
9377
9378                 If (LNotEqual (BI1T, 0))
9379                 {   Or (0x1, Local0, Local0)}
9380
9381                 Return (Local0)
9382             }   //  End Method BINK
9383
9384             Method (TEST)
9385             {
9386                 Store ("++++++++ SmiShare Test", Debug)
9387
9388                 //  Expect EVNT to generate Notify value we just previously
9389                 //  stored in BYTE
9390
9391                 Store (0x20, BYTE)
9392                 EVNT ()
9393                 Store (0x21, BYTE)
9394                 EVNT ()
9395                 Store (0x22, BYTE)
9396                 EVNT ()
9397                 Store (0x23, BYTE)
9398                 EVNT ()
9399
9400                 NTFY ()
9401                 Return (0)  //  pass
9402             }   //  End Method TEST
9403         }   //  Device SMIS
9404
9405         Device(CNDT)
9406         {
9407             Method(TEST)
9408             {
9409                 If (ECOK)
9410                 {
9411                     return("Broken")
9412                 }
9413                 Else
9414                 {
9415                     return("Works")
9416                 }
9417             }
9418
9419             Method(ECOK)
9420             {
9421                 Return(0x0)
9422             }
9423         }
9424
9425     }   //  _SB system bus
9426
9427
9428 /* Test a very big buffer */
9429
9430     Name(WQAB, Buffer(6756)
9431     {
9432         0x46,0x4F,0x4D,0x42,0x01,0x00,0x00,0x00,
9433         0x54,0x1A,0x00,0x00,0xBA,0xAD,0x00,0x00,
9434         0x44,0x53,0x00,0x01,0x1A,0x7D,0xDA,0x54,
9435         0x98,0xBD,0x92,0x00,0x01,0x06,0x18,0x42,
9436         0x10,0x47,0x10,0x92,0x46,0x62,0x02,0x89,
9437         0x80,0x90,0x18,0x18,0x14,0x81,0x85,0x00,
9438         0x49,0x02,0x88,0xC4,0x41,0xE1,0x20,0xD4,
9439         0x9F,0x40,0x7E,0x05,0x20,0x74,0x28,0x40,
9440         0xA6,0x00,0x83,0x02,0x9C,0x22,0x88,0xA0,
9441         0x57,0x01,0x36,0x05,0x98,0x14,0x60,0x51,
9442         0x80,0x76,0x01,0x96,0x05,0xE8,0x16,0x20,
9443         0x1D,0x96,0x88,0x04,0x47,0x89,0x01,0x47,
9444         0xE9,0xC4,0x16,0x6E,0xD8,0xE0,0x85,0xA2,
9445         0x68,0x06,0x51,0x12,0x94,0x8B,0x20,0x5D,
9446         0x10,0x52,0x2E,0xC0,0x37,0x82,0x06,0x10,
9447         0xA5,0x77,0x01,0xB6,0x05,0x98,0x86,0x27,
9448         0xD2,0x20,0xE4,0x60,0x08,0x54,0xCE,0x80,
9449         0x20,0x69,0x44,0x21,0x1E,0xA7,0x44,0x08,
9450         0x0A,0x84,0x90,0xD4,0xF1,0xA0,0xA0,0x71,
9451         0x88,0xAD,0xCE,0x46,0x93,0xA9,0x74,0x7E,
9452         0x48,0x82,0x70,0xC6,0x2A,0x7E,0x3A,0x9A,
9453         0xD0,0xD9,0x9C,0x60,0xE7,0x18,0x72,0x3C,
9454         0x48,0xF4,0x20,0xB8,0x00,0x0F,0x1C,0x2C,
9455         0x34,0x84,0x22,0x6B,0x80,0xC1,0x8C,0xDD,
9456         0x63,0xB1,0x0B,0x4E,0x0A,0xEC,0x61,0xB3,
9457         0x01,0x19,0xA2,0x24,0x38,0xD4,0x11,0xC0,
9458         0x12,0x05,0x98,0x1F,0x87,0x0C,0x0F,0x95,
9459         0x8C,0x25,0x24,0x1B,0xAB,0x87,0xC2,0xA5,
9460         0x40,0x68,0x6C,0x27,0xED,0x19,0x45,0x2C,
9461         0x79,0x4A,0x82,0x49,0xE0,0x51,0x44,0x36,
9462         0x1A,0x27,0x28,0x1B,0x1A,0x25,0x03,0x42,
9463         0x9E,0x05,0x58,0x07,0x26,0x04,0x76,0x2F,
9464         0xC0,0x9A,0x00,0x73,0xB3,0x90,0xB1,0xB9,
9465         0xE8,0xFF,0x0F,0x71,0xB0,0x31,0xDA,0x9A,
9466         0xAE,0x90,0xC2,0xC4,0x88,0x12,0x2C,0x5E,
9467         0xC5,0xC3,0x10,0xCA,0x93,0x42,0xA8,0x48,
9468         0x95,0xA1,0x68,0xB4,0x51,0x2A,0x14,0xE0,
9469         0x4C,0x80,0x30,0x5C,0x1D,0x03,0x82,0x46,
9470         0x88,0x15,0x29,0x56,0xFB,0x83,0x20,0xF1,
9471         0x2D,0x40,0x54,0x01,0xA2,0x48,0xA3,0x41,
9472         0x9D,0x03,0x3C,0x5C,0x0F,0xF5,0xF0,0x3D,
9473         0xF6,0x93,0x0C,0x72,0x90,0x67,0xF1,0xA8,
9474         0x70,0x9C,0x06,0x49,0xE0,0x0B,0x80,0x4F,
9475         0x08,0x1E,0x38,0xDE,0x35,0xA0,0x66,0x7C,
9476         0xBC,0x4C,0x10,0x1C,0x6A,0x88,0x1E,0x68,
9477         0xB8,0x13,0x38,0x44,0x06,0xE8,0x49,0x3D,
9478         0x52,0x60,0x07,0x77,0x32,0xEF,0x01,0xAF,
9479         0x0A,0xCD,0x5E,0x12,0x08,0xC1,0xF1,0xF8,
9480         0x7E,0xC0,0x26,0x9C,0xC0,0xF2,0x07,0x81,
9481         0x1A,0x99,0xA1,0x3D,0xCA,0xD3,0x8A,0x19,
9482         0xF2,0x31,0xC1,0x04,0x16,0x0B,0x21,0x05,
9483         0x10,0x1A,0x0F,0xF8,0x6F,0x00,0x8F,0x17,
9484         0xBE,0x12,0xC4,0xF6,0x80,0x12,0x0C,0x0B,
9485         0x21,0x23,0xAB,0xF0,0x78,0xE8,0x28,0x7C,
9486         0x95,0x38,0x9C,0xD3,0x8A,0x67,0x82,0xE1,
9487         0x20,0xF4,0x05,0x90,0x00,0x51,0xE7,0x0C,
9488         0xD4,0x61,0xC1,0xE7,0x04,0x76,0x33,0x38,
9489         0x83,0x47,0x00,0x8F,0xE4,0x84,0xFC,0x2B,
9490         0xF1,0xC0,0xE0,0x03,0xE2,0xEF,0x1F,0xA7,
9491         0xEC,0x11,0x9C,0xA9,0x01,0x7D,0x1C,0xF0,
9492         0xFF,0x7F,0x28,0x7C,0x88,0x1E,0xDF,0x29,
9493         0x1F,0xAF,0x4F,0x17,0x96,0x35,0x4E,0xE8,
9494         0x77,0x08,0x9F,0x38,0x7C,0x64,0x71,0x44,
9495         0x08,0x39,0x39,0x05,0xA0,0x81,0x4F,0xF7,
9496         0xEC,0x22,0x9C,0xAE,0x27,0xE5,0x40,0xC3,
9497         0xA0,0xE3,0x04,0xC7,0x79,0x00,0x1C,0xE3,
9498         0x84,0x7F,0x2E,0x80,0x3F,0x40,0x7E,0xCA,
9499         0x78,0xC5,0x48,0xE0,0x98,0x23,0x44,0x9F,
9500         0x6B,0x3C,0x42,0x2C,0xFC,0x53,0x45,0xE1,
9501         0x03,0x21,0x63,0x04,0x17,0xA0,0xC7,0x08,
9502         0x7C,0x03,0x8E,0x11,0x7D,0x94,0xE0,0xEA,
9503         0x0F,0x1A,0x74,0x80,0xB8,0xFF,0xFF,0x00,
9504         0xE1,0x83,0x7A,0x80,0xC0,0x37,0xFA,0xD1,
9505         0x03,0x3D,0x2E,0x8B,0x3E,0x0F,0xC8,0xF8,
9506         0x89,0x46,0xF3,0xE2,0xA7,0x03,0x7E,0xF8,
9507         0x00,0x0F,0xA8,0x87,0x84,0x03,0xC5,0x4C,
9508         0x9B,0x83,0x3E,0xBB,0x1C,0x3A,0x76,0xB8,
9509         0xE0,0x3F,0x81,0x80,0x4B,0xDE,0x21,0x0C,
9510         0x14,0x23,0xC6,0x9F,0x83,0x7C,0x0A,0x03,
9511         0xFF,0xFF,0xFF,0x14,0x06,0xFE,0xE1,0xF0,
9512         0x20,0x4F,0x07,0x9F,0xB6,0xA8,0x74,0x18,
9513         0xD4,0x81,0x0B,0xB0,0x32,0x89,0x08,0xCF,
9514         0x12,0xB5,0x41,0xE8,0xD4,0xF0,0x36,0xF1,
9515         0xB6,0xE5,0x5B,0x40,0x9C,0xD3,0xEC,0xED,
9516         0xC0,0x45,0x30,0x22,0xD4,0x0C,0x45,0x4E,
9517         0x5A,0x11,0x63,0x44,0x79,0xDC,0x32,0xCA,
9518         0xDB,0xD6,0x0B,0x40,0xBC,0x13,0x7B,0xDE,
9519         0x32,0x46,0xF0,0xC8,0x0F,0x5C,0x2C,0xC6,
9520         0xEA,0xF5,0x5F,0xF3,0x81,0x0B,0x70,0xF6,
9521         0xFF,0x3F,0x70,0x01,0x1C,0x0A,0x7A,0x18,
9522         0x42,0x0F,0xC3,0x53,0x39,0x97,0x87,0xC8,
9523         0x53,0x89,0x18,0x35,0x4C,0xD4,0x67,0x28,
9524         0xDF,0x2D,0x7C,0x20,0x02,0xDF,0x99,0x0B,
9525         0xF8,0xFD,0xFF,0x0F,0x44,0x70,0x8E,0x29,
9526         0xB8,0x33,0x0D,0x78,0x7C,0xCE,0x40,0x20,
9527         0xA7,0xE2,0x43,0x0D,0x60,0x41,0xF4,0x13,
9528         0xC2,0x27,0x1A,0x2A,0x13,0x06,0x75,0xA8,
9529         0x01,0xAC,0x5C,0x61,0x9E,0x46,0xCF,0xF9,
9530         0x59,0xC6,0xA7,0x1A,0x1F,0x4A,0x8D,0x63,
9531         0x88,0x97,0x99,0x87,0x1A,0x1F,0x0B,0x5E,
9532         0x49,0x7D,0xA8,0x31,0x54,0x9C,0x87,0x1A,
9533         0x0F,0x37,0x50,0xD4,0x37,0x9B,0x67,0x1B,
9534         0xA3,0xC7,0xF7,0x0D,0xD5,0x10,0x0F,0x35,
9535         0x4C,0xF2,0x4A,0x35,0x16,0x1F,0x6A,0xC0,
9536         0xF1,0xFF,0x3F,0xD4,0x00,0xFC,0xFF,0xFF,
9537         0x1F,0x6A,0x00,0x47,0x47,0x03,0x38,0x47,
9538         0x46,0xDC,0xD1,0x00,0x5C,0x87,0x52,0xE0,
9539         0x70,0x34,0x00,0x1E,0x47,0x21,0x30,0x5F,
9540         0x68,0x7C,0x14,0x02,0x16,0xFF,0xFF,0xA3,
9541         0x10,0xF8,0x65,0x9F,0x83,0x50,0x42,0x8F,
9542         0x42,0x80,0xA0,0xDB,0xCF,0x53,0xC4,0xB3,
9543         0x8F,0x2F,0x3F,0x0F,0x04,0x11,0x5E,0xF3,
9544         0x7D,0x0A,0xF2,0x21,0xDF,0x47,0x21,0x06,
9545         0x63,0x28,0x5F,0x83,0x7C,0x14,0x62,0x50,
9546         0xAF,0x41,0xBE,0xEF,0x1B,0xE4,0xF1,0x22,
9547         0x48,0xEC,0x67,0x02,0x1F,0x85,0x98,0xE8,
9548         0xA3,0x10,0xA0,0xF0,0xFF,0x7F,0x14,0x02,
9549         0xF8,0xFF,0xFF,0x3F,0x0A,0x01,0xCE,0x02,
9550         0x1C,0x0D,0x40,0x37,0xAD,0x47,0x21,0xF0,
9551         0xDE,0x59,0x4E,0xFB,0x04,0x7C,0x16,0x02,
9552         0xCC,0xFE,0xFF,0xCF,0x42,0xC0,0xEC,0x28,
9553         0x74,0x14,0x67,0xF9,0x2A,0xF4,0x04,0xF0,
9554         0x02,0x10,0x23,0xCC,0x3B,0xD0,0x4B,0x26,
9555         0xBB,0x8B,0x1B,0xE7,0xC9,0xE5,0x2C,0x9E,
9556         0xC4,0x7D,0x09,0xF2,0x81,0xE2,0x59,0xC8,
9557         0x50,0xA7,0x1B,0xF4,0x8D,0xDC,0x03,0x8B,
9558         0x19,0x3F,0xC4,0xF3,0x90,0x21,0x9E,0x85,
9559         0x00,0x76,0xFD,0xFF,0xCF,0x42,0x00,0xFF,
9560         0xFF,0xFF,0x47,0x03,0xF8,0x2F,0x00,0x9F,
9561         0x85,0x80,0xE7,0x09,0xE0,0x41,0xDB,0x67,
9562         0x21,0x80,0x33,0x87,0xCB,0xF3,0x7F,0x05,
9563         0x3A,0x96,0xF7,0x08,0xCF,0xFA,0x24,0x5F,
9564         0x2F,0x3D,0xD3,0x87,0x82,0x67,0x21,0x86,
9565         0x75,0x18,0x3E,0x0B,0x31,0x88,0x17,0x4D,
9566         0x43,0xBC,0x70,0xFA,0x30,0xE0,0xFF,0x3F,
9567         0x5E,0xE0,0x57,0x4E,0x03,0x05,0x09,0xF4,
9568         0x2C,0x04,0x30,0xFE,0xFF,0x7F,0x16,0x02,
9569         0xC8,0xB8,0x46,0x9D,0x85,0x80,0xE5,0x6D,
9570         0xE5,0x19,0xDB,0xA7,0x95,0x04,0xFF,0xFF,
9571         0x67,0x21,0xC0,0x41,0x2E,0x23,0x07,0x21,
9572         0x4C,0xC4,0x87,0x83,0x8F,0x99,0x80,0x9E,
9573         0x29,0xBE,0xB8,0x1B,0xE3,0x09,0xE0,0x45,
9574         0xE2,0x31,0x93,0x1D,0x35,0x0D,0xF3,0x2C,
9575         0x64,0xBC,0xB3,0x78,0x0D,0x78,0x82,0xF7,
9576         0xE4,0x9F,0x85,0x18,0xD8,0x61,0x05,0x7B,
9577         0x14,0x32,0xA8,0xC1,0x63,0x87,0x08,0x13,
9578         0xE8,0x59,0x88,0xC5,0x7D,0xAE,0xE8,0x3C,
9579         0xE1,0xB3,0x10,0xF0,0xFE,0xFF,0x9F,0x25,
9580         0xE0,0x5E,0x0D,0x9E,0x85,0x00,0x13,0x87,
9581         0x0D,0x9F,0x35,0xC0,0x33,0x7C,0x8F,0xEA,
9582         0x1C,0x1E,0x8F,0x81,0x7F,0x56,0x1D,0xE7,
9583         0x04,0x96,0x7B,0xD1,0xB2,0x71,0xA0,0xA1,
9584         0x23,0xB2,0x3A,0x20,0x8D,0x0D,0x73,0x29,
9585         0x89,0x7C,0x72,0x6C,0xD4,0x56,0x04,0xA7,
9586         0x33,0x93,0x4F,0x00,0xD6,0x42,0x21,0x05,
9587         0x34,0x1A,0x8B,0xE1,0x9D,0xF9,0xE8,0x44,
9588         0x41,0x0C,0xE8,0xE3,0x90,0x6D,0x1C,0x0A,
9589         0x50,0x7B,0xD1,0x14,0xC8,0x39,0x07,0xA3,
9590         0x7F,0x76,0x74,0x36,0xBE,0x13,0x70,0x0D,
9591         0x10,0x3A,0x25,0x18,0xDA,0x6A,0x04,0xFC,
9592         0xFF,0x67,0x89,0x01,0x33,0xFE,0x53,0x8C,
9593         0x09,0x7C,0x8E,0xC1,0x1F,0x0C,0xF0,0x03,
9594         0x7F,0x31,0xA8,0xFA,0x5E,0xA0,0xFB,0x82,
9595         0xD5,0xDD,0x64,0x20,0xCC,0xC8,0x04,0xF5,
9596         0x9D,0x0E,0x40,0x01,0xE4,0x0B,0x81,0xCF,
9597         0x51,0x0F,0x05,0x6C,0x22,0x21,0xC2,0x44,
9598         0x33,0x3A,0x62,0xC2,0xA8,0xE8,0x13,0xA6,
9599         0x20,0x9E,0xB0,0x63,0x4D,0x18,0x3D,0x13,
9600         0x5F,0x74,0xD8,0x88,0x31,0x21,0xAE,0x1E,
9601         0xD0,0x26,0x18,0xD4,0x97,0x22,0x58,0x43,
9602         0xE6,0x63,0xF1,0x05,0x02,0x37,0x65,0x30,
9603         0xCE,0x89,0x5D,0x13,0x7C,0xD9,0xC1,0xCD,
9604         0x19,0x8C,0xF0,0x98,0xBB,0x18,0xBF,0x3A,
9605         0x79,0x74,0xFC,0xA0,0xE0,0x1B,0x0E,0xC3,
9606         0x7E,0x32,0xF3,0x8C,0xDE,0xCB,0x7C,0x8D,
9607         0xC3,0xC0,0x7A,0xBC,0x1C,0xD6,0x68,0x61,
9608         0x0F,0xED,0x3D,0xC4,0xFF,0xFF,0x43,0x8C,
9609         0xCF,0x13,0xC6,0x08,0xEB,0xDB,0x0B,0x38,
9610         0xEE,0x59,0xF0,0xEF,0x1A,0xE0,0xB9,0x84,
9611         0xF8,0xAE,0x01,0x30,0xF0,0xFF,0x7F,0xD7,
9612         0x00,0x4E,0xD7,0x04,0xDF,0x35,0x80,0xF7,
9613         0xD0,0x7D,0xD7,0x00,0xAE,0xD9,0xEF,0x1A,
9614         0xA8,0x63,0x80,0x15,0xDE,0x35,0xA0,0x5D,
9615         0xD9,0xDE,0xD7,0x9E,0xB0,0xAC,0xE9,0xB2,
9616         0x81,0x52,0x73,0xD9,0x00,0x14,0xFC,0xFF,
9617         0x2F,0x1B,0x80,0x01,0x29,0x13,0x46,0x85,
9618         0x9F,0x30,0x05,0xF1,0x84,0x1D,0xEC,0xB2,
9619         0x01,0x8A,0x18,0x97,0x0D,0xD0,0x8F,0xED,
9620         0x65,0x03,0x18,0xDC,0x13,0xF8,0x6D,0x03,
9621         0x78,0x43,0xFA,0xB6,0x01,0xD6,0xFF,0xFF,
9622         0x6D,0x03,0xAC,0xF9,0x6F,0x1B,0x28,0x0E,
9623         0xAB,0xBC,0x6D,0x40,0x3C,0xC9,0x33,0x02,
9624         0xAB,0xBA,0x6E,0xA0,0xF4,0x5C,0x37,0x00,
9625         0x12,0x88,0x99,0x30,0x2A,0xFE,0x84,0x29,
9626         0x88,0x27,0xEC,0x68,0xD7,0x0D,0x50,0x04,
9627         0xB9,0x6E,0x80,0x7E,0x5E,0x09,0xFE,0xFF,
9628         0xAF,0x1B,0xC0,0xE0,0xA2,0x80,0xB9,0x6F,
9629         0x00,0x6F,0x58,0x7E,0xDF,0x00,0x7C,0xDC,
9630         0xC4,0x31,0xF7,0x0D,0xC0,0xCC,0xFF,0xFF,
9631         0xBE,0x01,0xB0,0xE7,0xA2,0x80,0xBB,0x6F,
9632         0x00,0xEF,0x8B,0xB4,0xEF,0x1B,0x60,0xFE,
9633         0xFF,0xDF,0x37,0xC0,0x28,0x6D,0xFD,0x1E,
9634         0x1C,0x3D,0x21,0x78,0x7C,0xB8,0xFB,0xA5,
9635         0xC7,0xE7,0xBB,0x39,0x38,0x06,0x79,0x8C,
9636         0x87,0x76,0xC0,0xAF,0xEF,0x9E,0x98,0xEF,
9637         0xE6,0xC0,0xFF,0x4C,0x70,0x3C,0x18,0x68,
9638         0x1C,0x62,0xAB,0x97,0x06,0x72,0x34,0x38,
9639         0x3F,0xDC,0x19,0x81,0x61,0x15,0x7F,0xF2,
9640         0x47,0x38,0xC7,0xD0,0xD9,0xE1,0x20,0xB1,
9641         0x83,0xE0,0xC1,0x56,0x6D,0x02,0x85,0x86,
9642         0x50,0x14,0x18,0x14,0x8B,0x0F,0x18,0xF8,
9643         0x61,0xB3,0xB3,0x00,0x93,0x04,0x87,0x3A,
9644         0x02,0xF8,0x3E,0xD1,0xFC,0x38,0x74,0x37,
9645         0x38,0x54,0x8F,0xE5,0xA1,0x80,0x9E,0x01,
9646         0x71,0xC7,0x0C,0x32,0x69,0xCF,0x28,0xE2,
9647         0x53,0xC2,0x29,0x85,0x49,0xE0,0xF3,0x03,
9648         0x43,0xE3,0x04,0xAF,0x0D,0xA1,0xF9,0xFF,
9649         0xFF,0xA4,0xC0,0x3C,0xDF,0x31,0x04,0x6C,
9650         0x02,0xBB,0xBF,0x64,0xC8,0xDA,0xC0,0x75,
9651         0x4B,0x32,0x44,0x6F,0x38,0xB2,0x85,0xA2,
9652         0xE9,0x44,0x79,0xDF,0x88,0x62,0x67,0x08,
9653         0xC2,0x88,0x12,0x2C,0xC8,0xA3,0x42,0xAC,
9654         0x28,0x2F,0x05,0x46,0x88,0x18,0xE2,0x95,
9655         0x23,0xD0,0x09,0x87,0x0F,0xF2,0xD8,0x14,
9656         0xA7,0xFD,0x41,0x90,0x58,0x4F,0x02,0x8D,
9657         0xC5,0x91,0x46,0x83,0x3A,0x07,0x78,0xB8,
9658         0x3E,0xC4,0x78,0xF8,0x0F,0x21,0x06,0x39,
9659         0xC8,0x73,0x7B,0x54,0x38,0x4E,0x5F,0x25,
9660         0x4C,0xF0,0x02,0xE0,0x83,0x0A,0x1C,0xD7,
9661         0x80,0x9A,0xF1,0x33,0x06,0x58,0x8E,0xE3,
9662         0x3E,0xA9,0xC0,0x1D,0x8F,0xEF,0x07,0x6C,
9663         0xC2,0x09,0x2C,0x7F,0x10,0xA8,0xE3,0x0C,
9664         0x9F,0xE7,0x0B,0x8B,0x21,0x1F,0x13,0x4C,
9665         0x60,0xB1,0x27,0x1B,0x3A,0x1E,0xF0,0xDF,
9666         0x63,0x1E,0x2F,0x7C,0x32,0xF1,0x7C,0x4D,
9667         0x30,0x22,0x84,0x9C,0x8C,0x07,0x7D,0x87,
9668         0xC0,0x5C,0x6F,0xD8,0xB9,0x85,0x8B,0x3A,
9669         0x68,0xA0,0x4E,0x0B,0x3E,0x28,0xB0,0x9B,
9670         0x11,0xE6,0xB8,0xCE,0xCF,0x2A,0x60,0xF8,
9671         0xFF,0x9F,0x55,0x60,0x8F,0x10,0xFE,0xED,
9672         0xC1,0xF3,0xF2,0x95,0xE1,0xD5,0x21,0x81,
9673         0x43,0x8E,0x10,0x3D,0x2E,0x8F,0x10,0x73,
9674         0x3E,0xC2,0x0C,0x11,0x5C,0x67,0x01,0x70,
9675         0x0C,0x11,0xF8,0x1C,0x70,0xC0,0x71,0x69,
9676         0xE2,0x03,0xF5,0x01,0x07,0x70,0x70,0x4D,
9677         0xC3,0x1D,0x70,0xC0,0x71,0x16,0x60,0xFF,
9678         0xFF,0xC3,0x0D,0x2C,0x49,0x26,0x0E,0x23,
9679         0x18,0x11,0x30,0x28,0x02,0x02,0xA4,0xB3,
9680         0x80,0x0F,0x29,0x00,0x1F,0xAE,0x0C,0x0F,
9681         0x29,0xD8,0x93,0x86,0x07,0x8E,0x1B,0x85,
9682         0x07,0x8D,0x0B,0x30,0x68,0x7A,0xE2,0x80,
9683         0x7F,0x4C,0xF0,0x19,0x05,0x1C,0xE3,0x06,
9684         0xDF,0x2A,0x0C,0xFC,0xFF,0x3F,0x30,0xCC,
9685         0xE1,0xC2,0x63,0x39,0x8A,0xA0,0x07,0x1E,
9686         0xD4,0xF7,0x8C,0x33,0xF7,0x24,0x8F,0xD1,
9687         0x51,0x0F,0x27,0xF4,0xE4,0x85,0x3B,0x57,
9688         0xF9,0x0A,0x71,0x14,0x18,0xB8,0x77,0x29,
9689         0x8F,0xCF,0x17,0x2B,0xC3,0x63,0x46,0xFB,
9690         0x1E,0x72,0xD6,0x11,0x02,0xE2,0x2F,0x75,
9691         0x6C,0xC0,0x60,0x39,0x18,0x00,0x87,0x01,
9692         0xE3,0x13,0x0D,0x58,0x67,0x1B,0x3C,0xF4,
9693         0x69,0x31,0xC4,0xE3,0x0B,0xFB,0x56,0x61,
9694         0x82,0xEA,0x41,0x75,0x12,0xF4,0xD0,0xC0,
9695         0x01,0xE8,0xA1,0xC1,0x3F,0xB9,0x90,0xFB,
9696         0x2B,0x1D,0x82,0xB5,0xE2,0x69,0xDE,0x47,
9697         0x1E,0xF3,0xDC,0xA2,0xBC,0x0D,0x3C,0x07,
9698         0xF0,0xD3,0x82,0x87,0xE3,0x63,0x81,0xC7,
9699         0xE9,0x4B,0x58,0x82,0xF7,0x1A,0x9F,0x6C,
9700         0x1E,0x5C,0x58,0xB2,0x21,0xA0,0x06,0xEB,
9701         0x21,0x60,0xA6,0x9A,0xC0,0x49,0x46,0x80,
9702         0xCA,0x00,0xA1,0x1B,0xCB,0xE9,0x3E,0x8B,
9703         0x84,0x38,0xCD,0x47,0x99,0xC7,0x02,0x8F,
9704         0xF5,0xC1,0xC0,0xFF,0x7F,0xCD,0x23,0xD4,
9705         0x7D,0xCD,0x33,0x7B,0x3A,0xC0,0xAC,0x22,
9706         0xDC,0x7B,0xCE,0x1B,0x86,0xD1,0x9E,0x2D,
9707         0x7C,0xCD,0x78,0xD6,0x34,0x42,0x38,0x76,
9708         0x83,0xF3,0x48,0x8C,0xF0,0x82,0xC0,0x4E,
9709         0x0C,0x0F,0x30,0xC6,0x39,0x79,0xC3,0xFA,
9710         0xC2,0xCB,0x40,0x83,0x19,0xDB,0x97,0x01,
9711         0x36,0x2A,0xDF,0x88,0xC0,0x97,0xFC,0x62,
9712         0x00,0x65,0x16,0xBE,0x9E,0xF8,0xA0,0xC4,
9713         0x2E,0x06,0x2C,0xE5,0xC5,0x00,0x54,0x37,
9714         0x0C,0x5F,0x0C,0xE0,0x5F,0x89,0x5E,0x0C,
9715         0xC0,0x70,0x71,0xF2,0x3D,0xC0,0x1E,0xEE,
9716         0xA3,0x74,0x9C,0xBE,0xFD,0xBD,0x19,0xF8,
9717         0x6C,0xC0,0x60,0x3C,0xC3,0x30,0xC6,0x08,
9718         0xE3,0x51,0x86,0x31,0xC1,0xDC,0xB7,0x03,
9719         0xE8,0x39,0x87,0x81,0x4A,0x78,0x3B,0x80,
9720         0x72,0x0E,0xE8,0xF2,0x68,0x42,0x4F,0x01,
9721         0x4F,0x07,0x3E,0x29,0x1A,0xA2,0xAF,0xB1,
9722         0x0A,0x26,0x50,0xC4,0x07,0x0D,0x3E,0xB5,
9723         0x28,0x3E,0x15,0x78,0x2D,0xCF,0x4E,0xE1,
9724         0xE2,0x9C,0x89,0xA7,0x6A,0x38,0x03,0xBD,
9725         0xE6,0x86,0x63,0xFF,0x7F,0x38,0xFC,0xA9,
9726         0xE0,0x35,0x80,0x1D,0x24,0x3D,0x2D,0x23,
9727         0xC2,0x38,0xA4,0x3C,0x32,0xF8,0xB6,0x18,
9728         0xC7,0x90,0x0F,0x91,0xBE,0x13,0x18,0xF2,
9729         0x21,0xEF,0x79,0xC7,0xC0,0xAF,0x08,0x71,
9730         0x9E,0xB2,0x7C,0x67,0xF0,0x65,0x01,0x7C,
9731         0x91,0x2E,0x0B,0x68,0x68,0x9F,0x64,0x7C,
9732         0x41,0x30,0xEC,0x89,0xB3,0x00,0x77,0x05,
9733         0x50,0x81,0xFA,0xAE,0x00,0xFF,0x42,0xF0,
9734         0xAE,0x00,0x86,0x79,0xF9,0x56,0xC0,0x35,
9735         0x1D,0x4A,0xD0,0x67,0x12,0x5F,0x17,0x70,
9736         0x53,0x64,0xA9,0x8E,0x0A,0xD0,0x53,0x4C,
9737         0x02,0x75,0x47,0xF7,0x51,0x01,0xC6,0x4D,
9738         0xD9,0x07,0x54,0x76,0x5A,0x60,0x67,0x21,
9739         0x76,0x1D,0xC1,0x5D,0x49,0x18,0xCA,0xB3,
9740         0x81,0x2F,0x59,0xFC,0x70,0x00,0x03,0xDC,
9741         0xB3,0x38,0xC4,0x08,0xB1,0xD9,0x81,0xEB,
9742         0x75,0xD2,0x70,0x2F,0x44,0xEC,0xFF,0x7F,
9743         0x32,0x00,0xE3,0x51,0x1B,0x1C,0x27,0x9D,
9744         0xF0,0x91,0x9E,0x59,0xF8,0x49,0x19,0x30,
9745         0x71,0xF2,0x03,0xE3,0xC9,0x1A,0xC6,0x00,
9746         0xB8,0xBC,0x57,0x95,0x81,0xFC,0x43,0x90,
9747         0x20,0x18,0xD4,0x29,0x19,0x38,0x1C,0xC5,
9748         0x70,0xA7,0x64,0x78,0x50,0xF8,0xC3,0x00,
9749         0xE6,0x46,0xE8,0x7B,0x82,0xA1,0xDE,0x93,
9750         0x0E,0xE3,0x91,0xD0,0x04,0x3E,0x2D,0xC3,
9751         0xFA,0xFF,0x9F,0x96,0x81,0xD5,0xB1,0xDD,
9752         0x43,0xF6,0x59,0x01,0x77,0x76,0x80,0x3B,
9753         0x3D,0x7E,0x7A,0x00,0x9C,0x00,0x3D,0x3D,
9754         0x80,0xED,0xBC,0x01,0xF7,0x40,0x80,0x38,
9755         0xFE,0xA3,0x82,0x5F,0x59,0x28,0x1C,0x3F,
9756         0xB6,0xF3,0x63,0x09,0xEE,0x70,0xE0,0x23,
9757         0x83,0x0F,0x90,0xB8,0xA1,0xF8,0x50,0x81,
9758         0x3C,0x0B,0x80,0x62,0xF4,0x6C,0x04,0xEC,
9759         0x06,0xF3,0xD2,0x12,0xE5,0xFF,0xFF,0xDE,
9760         0xC0,0x4E,0x29,0xB8,0x83,0x00,0xF8,0x8E,
9761         0x01,0xE0,0x1D,0x0C,0x97,0x35,0x66,0x94,
9762         0x10,0x18,0x8D,0x19,0x77,0x08,0xE1,0x27,
9763         0x02,0xDC,0x98,0x3D,0x6E,0x8F,0x19,0x77,
9764         0x9C,0xE5,0xA3,0x7A,0xCA,0x08,0xE5,0x03,
9765         0x07,0x3B,0x67,0xBC,0x11,0xF0,0xA1,0x03,
9766         0x8F,0x03,0x0C,0xEE,0x48,0x01,0xC6,0xCB,
9767         0x01,0x1B,0x3B,0xB8,0x83,0x90,0x53,0x20,
9768         0x4B,0x87,0xD1,0xD8,0x71,0xB2,0x81,0x74,
9769         0x8C,0xF1,0x21,0xD7,0x63,0xC7,0x0D,0xD6,
9770         0x63,0xC7,0x1D,0x5F,0xB0,0xFF,0xFF,0xE3,
9771         0x0B,0x18,0xC6,0xC0,0xC5,0x0F,0x03,0x7D,
9772         0xF3,0xF3,0xE8,0x0C,0xEE,0x61,0xFB,0x04,
9773         0x13,0xE3,0xF9,0x25,0xC4,0x23,0xCC,0x8B,
9774         0x4B,0x84,0xA3,0x08,0xF2,0xE6,0x12,0xE7,
9775         0xD5,0x20,0xCC,0x63,0x4B,0x94,0x10,0x11,
9776         0x0E,0x26,0xCE,0x13,0x8C,0x11,0x0E,0x3C,
9777         0x8A,0x21,0x22,0x9C,0x40,0x88,0x93,0x3E,
9778         0xD9,0x20,0xE1,0x63,0x84,0x8D,0xF6,0x04,
9779         0xC3,0xC7,0xC2,0xCF,0x2B,0x1E,0x3C,0x3F,
9780         0xAD,0xF9,0x2E,0xE8,0xC9,0x9C,0xE3,0x43,
9781         0x96,0xA7,0xF6,0x38,0xE9,0xC3,0x2C,0x6E,
9782         0x50,0x0F,0x8E,0xEC,0xAE,0xE3,0xE3,0x35,
9783         0xF6,0x14,0xE4,0x21,0xF0,0x13,0x81,0x2F,
9784         0x88,0x9E,0xAC,0xEF,0x7A,0xEC,0x5E,0x66,
9785         0x8C,0xEA,0xA7,0x80,0x3A,0xA6,0x9C,0xC1,
9786         0x2B,0x04,0xBB,0xE7,0xF9,0x90,0xED,0xBB,
9787         0x24,0x1B,0x05,0xEE,0x90,0xE0,0x33,0x12,
9788         0x3F,0x55,0x78,0x18,0x1E,0x05,0x8C,0x19,
9789         0xBC,0x23,0x1C,0x5A,0x88,0x03,0x7E,0xDF,
9790         0x65,0x43,0x8D,0x71,0x7A,0x3E,0x7F,0xB0,
9791         0x41,0xC0,0x87,0x3A,0x54,0x0F,0xF3,0xA8,
9792         0x5E,0x0A,0x19,0xCE,0xD9,0xC1,0x1D,0x04,
9793         0xF6,0xF8,0xE1,0x41,0xF0,0x9B,0x25,0x1F,
9794         0x04,0x3B,0xDF,0xBC,0xC1,0x19,0xE4,0xFF,
9795         0x7F,0x0C,0xB0,0xCF,0x54,0x3E,0x9A,0x20,
9796         0x8E,0x80,0xE8,0xF3,0x87,0xC7,0xF0,0x26,
9797         0xC7,0x87,0x83,0x3D,0x7A,0xE0,0x4E,0x22,
9798         0x70,0x8F,0x5D,0x07,0xED,0x6B,0x9C,0x2F,
9799         0x5A,0x30,0xEE,0x7B,0xCF,0x22,0xE0,0xC7,
9800         0x78,0x6C,0x01,0xC7,0xA1,0x04,0xDC,0xC1,
9801         0x8E,0x6B,0x1C,0x42,0x51,0x60,0x74,0x28,
9802         0xC1,0xC5,0x00,0x12,0x8C,0x63,0x9C,0xD1,
9803         0xD0,0x97,0x48,0x1F,0xD2,0xE0,0x0C,0x1A,
9804         0xF6,0x3C,0x9F,0x50,0xB8,0x3D,0x01,0x8A,
9805         0x4E,0x28,0x20,0xC3,0x7D,0x06,0xC1,0x9E,
9806         0x10,0xF8,0x19,0x84,0xFD,0xFF,0x0F,0x8E,
9807         0x1E,0xF7,0x7B,0xA3,0x4F,0x8D,0x6C,0xEE,
9808         0x0F,0x01,0x27,0x70,0xEE,0xEC,0xD4,0x8C,
9809         0x3B,0x33,0x60,0xCF,0x1F,0x1E,0x02,0x3F,
9810         0x17,0x78,0xF8,0x1E,0x02,0x7E,0xF0,0x0F,
9811         0xCC,0x06,0x07,0xE3,0x29,0xC2,0xD7,0x0E,
9812         0x0E,0xCE,0x4F,0x03,0x06,0xE7,0xAF,0x50,
9813         0x9F,0xE7,0x19,0x38,0xF6,0xD4,0xEB,0x7B,
9814         0x87,0xE7,0xEB,0x43,0x05,0xFE,0xA6,0xE7,
9815         0x43,0x05,0x38,0x0E,0x0F,0xFC,0xB0,0xC2,
9816         0x86,0xF0,0x28,0x80,0x3F,0xB5,0xF8,0xF8,
9817         0x17,0xE7,0x29,0x82,0xDD,0x46,0xB0,0x87,
9818         0x0B,0xC0,0x51,0xB4,0xB3,0x18,0x2A,0xCC,
9819         0x59,0x8C,0xFC,0xFF,0xCF,0x51,0xA8,0xB3,
9820         0x18,0x3D,0x5C,0x00,0x2E,0x04,0x1F,0x0F,
9821         0x40,0x73,0x10,0x78,0x5C,0xF0,0x85,0xE0,
9822         0x48,0x0E,0xE4,0xE9,0x00,0xF0,0x19,0x4A,
9823         0xC3,0xA1,0x09,0x13,0x03,0x06,0x75,0x3E,
9824         0xF0,0x09,0xC5,0xC7,0x0E,0x7E,0x36,0xF0,
9825         0x8D,0xDC,0x43,0xE5,0xA7,0x66,0x5F,0xF2,
9826         0x11,0xE0,0x02,0x75,0xA0,0x61,0xA0,0x46,
9827         0xE4,0x23,0xD2,0xFF,0xFF,0xB9,0x0D,0x1B,
9828         0x60,0x68,0xF4,0x1C,0x0E,0xE3,0x80,0xEB,
9829         0x73,0x38,0x76,0x40,0x3E,0x87,0xC3,0x3F,
9830         0x47,0xC3,0x1F,0x1B,0x3B,0xDD,0xF3,0x81,
9831         0xC1,0xBA,0x7E,0x63,0x06,0x06,0xB6,0x6F,
9832         0x91,0x07,0x06,0x1C,0x51,0xCF,0xC6,0x57,
9833         0x08,0x0F,0x0C,0x6C,0x80,0x1E,0x18,0xF0,
9834         0x89,0x05,0x21,0x27,0x03,0x43,0x9D,0x32,
9835         0x8C,0x1C,0xF3,0x89,0xC3,0xC3,0xF0,0xA1,
9836         0x22,0xEA,0x33,0xC0,0x23,0x1E,0x1B,0x1B,
9837         0xFB,0xFF,0x8F,0x0D,0x2C,0xC7,0x16,0x8F,
9838         0x0D,0xFC,0x47,0x78,0xFC,0xD8,0xE0,0x8C,
9839         0xE5,0xD1,0xC4,0x97,0x99,0x23,0x3B,0x8D,
9840         0x33,0x7B,0x0D,0xF1,0xD1,0xEE,0xF1,0xDB,
9841         0x63,0x03,0x97,0x85,0xB1,0x01,0xA5,0x90,
9842         0x63,0x43,0x1F,0x52,0x7C,0x0A,0xB0,0x71,
9843         0x54,0x32,0x0F,0x1F,0xAF,0x7C,0x62,0x38,
9844         0xBA,0x20,0x6F,0xE8,0xBE,0x5C,0xF8,0x48,
9845         0x63,0x30,0x5F,0x5A,0x7C,0x06,0xE5,0x43,
9846         0x04,0xD7,0x57,0xC5,0x43,0x04,0x3E,0xA1,
9847         0x86,0x88,0x1E,0xCF,0xFF,0xFF,0x11,0xCC,
9848         0x43,0x64,0x43,0x03,0xAF,0x87,0xA1,0x01,
9849         0xA5,0x98,0xC0,0x5E,0x85,0x87,0x46,0x4F,
9850         0x3F,0x3E,0x04,0x30,0x08,0xDF,0x06,0xD8,
9851         0x55,0xC0,0x57,0x21,0x83,0x24,0x18,0xE7,
9852         0x64,0x41,0x07,0x07,0x8E,0x21,0x79,0x70,
9853         0xF0,0x07,0xE3,0x21,0x70,0x60,0xCF,0xE0,
9854         0xB9,0xE8,0x31,0xD8,0xA7,0x1D,0x9F,0x4A,
9855         0xC0,0x77,0xE6,0x04,0xC7,0xE9,0x1D,0x7B,
9856         0x29,0xF0,0x08,0x1E,0xAD,0x3C,0x02,0x7E,
9857         0xB4,0x02,0x66,0xFF,0xFF,0xA3,0x15,0x30,
9858         0x09,0x7A,0xE6,0xA4,0x03,0x77,0x34,0x18,
9859         0xD4,0xD1,0x0A,0x5C,0x11,0xC0,0x75,0xDC,
9860         0xF0,0xD1,0x02,0xCE,0x50,0x0F,0xDA,0x07,
9861         0x65,0xCF,0xDA,0x97,0x21,0x76,0xB4,0x00,
9862         0x97,0x89,0x43,0x08,0xD0,0x04,0x3E,0x89,
9863         0x67,0xEF,0x43,0x03,0xB3,0x8A,0xA1,0x01,
9864         0xA5,0xA3,0x01,0xEE,0x44,0x81,0xFD,0xFF,
9865         0x9F,0x28,0x60,0xDE,0x30,0x70,0x07,0x0A,
9866         0xC0,0xCD,0xE9,0xDB,0xE3,0xE2,0xD0,0x38,
9867         0xC4,0xE7,0xA7,0x73,0xF6,0xD1,0xE8,0x4C,
9868         0x71,0x67,0x11,0x30,0x9C,0x7D,0x11,0x8F,
9869         0x18,0x03,0xF9,0x81,0x21,0x59,0x30,0x28,
9870         0x16,0x0F,0xC5,0x07,0x03,0x0E,0xEC,0x23,
9871         0x02,0x3B,0x17,0xB0,0x73,0xAD,0xE1,0xF8,
9872         0x59,0xC0,0xA7,0x84,0xB7,0xA6,0x17,0x7B,
9873         0x9F,0xD7,0x7D,0xD6,0x08,0xC9,0xCE,0xF4,
9874         0x3E,0x89,0xE2,0x0E,0xA2,0x70,0x4E,0x9F,
9875         0xE0,0x22,0xF0,0x65,0xDF,0xA3,0xE0,0xA7,
9876         0x07,0xCF,0xF1,0x8D,0xC1,0xA7,0x07,0xE6,
9877         0x7E,0xF8,0x9A,0xF1,0x33,0xC3,0xE3,0x43,
9878         0x88,0x27,0xE2,0xDA,0xA6,0x20,0x5B,0x18,
9879         0x42,0x09,0xF4,0xFF,0x8F,0x10,0xE5,0x6D,
9880         0x20,0xCA,0x29,0x44,0x88,0x12,0xA4,0xB1,
9881         0xC9,0x0B,0x35,0xCA,0xD9,0x45,0x6E,0x6D,
9882         0xF6,0x82,0x0B,0x14,0x2A,0x66,0x9C,0x28,
9883         0xEF,0x10,0xB1,0xDA,0x1F,0x04,0x91,0xF4,
9884         0x32,0xD0,0x71,0xC9,0x91,0x0E,0x7D,0xE8,
9885         0x61,0xFB,0x04,0x8C,0x3F,0x48,0xE2,0xAE,
9886         0x2A,0x3E,0x28,0xF8,0x00,0x80,0x77,0x09,
9887         0xA8,0x5B,0x9D,0xC7,0xED,0xF3,0x06,0xF8,
9888         0xAF,0x17,0x58,0x82,0xF2,0x07,0x81,0x1A,
9889         0x99,0xA1,0x3D,0xCC,0xB7,0x19,0x43,0xBE,
9890         0x07,0x1C,0x16,0x3B,0x27,0xF9,0xF0,0x08,
9891         0x1C,0x8E,0x01,0x4F,0x1B,0xBE,0x51,0x7B,
9892         0xBE,0x3E,0x62,0x01,0x8E,0xFE,0xFF,0x47,
9893         0x2C,0x30,0x9D,0xDF,0x7D,0x82,0x01,0xC7,
9894         0xCD,0x82,0x9F,0x61,0x00,0x67,0x40,0xCF,
9895         0x30,0x60,0x1F,0x2A,0x6E,0x08,0x5C,0xEE,
9896         0x8A,0x28,0x90,0x05,0xC2,0xA0,0x0E,0xFD,
9897         0xE4,0x08,0x42,0xCF,0x9C,0x70,0x86,0x72,
9898         0xB2,0xBD,0x5F,0x1D,0xC8,0x2D,0xC2,0x43,
9899         0x3D,0x8B,0xC7,0x04,0x76,0xDA,0x02,0x36,
9900         0xFF,0xFF,0xE3,0x29,0xB0,0x98,0xF7,0xD3,
9901         0x69,0x84,0x63,0x03,0xFB,0x71,0x0B,0x38,
9902         0x1D,0xCC,0xE0,0xDC,0x7F,0xD8,0x2D,0x1A,
9903         0x37,0x34,0xB0,0x0D,0xCC,0x43,0x03,0x3E,
9904         0x27,0x47,0x30,0x9E,0x98,0xF8,0x55,0xE2,
9905         0xE1,0x89,0x1F,0x43,0xC0,0xFA,0xFF,0x3F,
9906         0x99,0x01,0xF6,0x84,0x1E,0xCB,0x50,0xD2,
9907         0x4E,0x66,0x80,0xC0,0xFB,0xD8,0x3B,0xC3,
9908         0x4B,0x83,0xE7,0x74,0xD2,0xCF,0x62,0x3E,
9909         0x99,0x19,0x21,0x0A,0xBB,0x8F,0x19,0xAD,
9910         0x37,0x14,0xCD,0x3C,0xE8,0x3B,0x99,0x51,
9911         0x62,0x46,0x6A,0x0E,0x4C,0x48,0x11,0x0F,
9912         0x27,0x4A,0x88,0x60,0xAF,0x13,0x6F,0x67,
9913         0x4F,0x66,0x4C,0xD6,0xC9,0x0C,0x24,0xFF,
9914         0xFF,0x93,0x19,0x98,0x5C,0x9F,0xCC,0x80,
9915         0xCA,0x39,0x0A,0x7F,0x32,0x03,0x78,0x74,
9916         0xC0,0xC2,0x9D,0xCC,0xC0,0xF2,0xFF,0x3F,
9917         0xC4,0x00,0xCE,0xC7,0x0A,0x63,0x0C,0x3C,
9918         0xDA,0xC1,0x0C,0x15,0xE6,0x6C,0x86,0x0E,
9919         0x72,0x08,0xA1,0xC1,0x0E,0x21,0x50,0xE6,
9920         0x72,0xA0,0xA7,0xF0,0x9A,0xE0,0x73,0x14,
9921         0xD8,0x0F,0x67,0xC0,0xE1,0xD4,0x80,0x0F,
9922         0x74,0xE2,0x42,0x8F,0xC2,0x23,0x0E,0x58,
9923         0xFD,0xC0,0xC8,0xFF,0xFF,0x64,0x06,0x18,
9924         0x78,0x6A,0xF8,0x40,0x82,0x63,0x31,0xEA,
9925         0x1B,0xC4,0x21,0xBE,0x8D,0xF8,0xE8,0xFE,
9926         0x6A,0xE2,0x4B,0x00,0xE6,0x42,0xE2,0xD3,
9927         0x09,0xB3,0x70,0x38,0x03,0x5A,0x43,0x60,
9928         0x57,0x26,0xCF,0x9C,0x0F,0xE1,0x6C,0x3C,
9929         0x7A,0xDC,0xE9,0x04,0xDE,0x38,0x7C,0x3A,
9930         0x01,0x5E,0x07,0x0C,0xCC,0x0C,0xC2,0x3F,
9931         0x84,0xB0,0x21,0x9C,0xAA,0xC7,0x70,0xEE,
9932         0xAF,0x38,0x3E,0x9D,0x80,0xF3,0xFF,0x7F,
9933         0x62,0x03,0x0C,0x0A,0x7E,0x32,0xF8,0xB8,
9934         0x46,0x25,0xC2,0xA0,0x8E,0xE6,0x80,0x7B,
9935         0x98,0x27,0x36,0x26,0x6F,0xC5,0x1A,0x8B,
9936         0x4F,0x6C,0x30,0xFF,0xFF,0x27,0x36,0x80,
9937         0xD1,0x87,0x20,0xB0,0xFD,0xFF,0x0F,0x41,
9938         0x60,0x1C,0xA0,0x0F,0x41,0x80,0x9B,0xD3,
9939         0x09,0xEE,0xC4,0x07,0xB6,0x63,0x10,0x60,
9940         0x6D,0xE8,0x3E,0x06,0x81,0xF9,0xFF,0x3F,
9941         0x5A,0x98,0xA3,0xE0,0xC2,0x8E,0x7C,0x28,
9942         0x29,0xA7,0x3E,0xB4,0x0C,0x20,0x69,0x38,
9943         0xC9,0x01,0x9D,0xD3,0x3D,0x70,0x92,0x75,
9944         0xEA,0x40,0x8F,0xC7,0xA0,0xAF,0x1C,0xBE,
9945         0x12,0xF0,0x23,0x07,0x93,0x00,0xAA,0x41,
9946         0xFA,0xCC,0x07,0x9C,0x8E,0x1C,0xE0,0x38,
9947         0x26,0x05,0xC6,0xDE,0x0E,0xDE,0x22,0x3D,
9948         0x89,0xA7,0xA1,0xE3,0x0C,0x51,0x38,0x26,
9949         0x39,0x18,0x44,0x7A,0x95,0x62,0x03,0x7C,
9950         0xAB,0xF1,0xD9,0xC8,0x07,0x10,0x78,0xE3,
9951         0xF6,0xD8,0x61,0xFF,0xFF,0x0F,0x75,0xC0,
9952         0x01,0xE2,0xA4,0xF8,0x21,0xC3,0x98,0x67,
9953         0xC5,0x0F,0x75,0x80,0xF5,0x18,0x27,0x3A,
9954         0x94,0xF0,0x43,0x1D,0x20,0xE8,0xFF,0x7F,
9955         0xA8,0x03,0x86,0x38,0x6F,0x24,0xD1,0x1E,
9956         0xEA,0x98,0xE8,0x43,0x1D,0x40,0xC8,0xFF,
9957         0xFF,0xA1,0x0E,0x18,0x9E,0x87,0x00,0xAE,
9958         0x9C,0xEF,0xC0,0x7C,0x22,0x02,0xEF,0xFF,
9959         0xFF,0x7C,0x07,0xB8,0x1B,0x2D,0xCC,0x51,
9960         0x70,0x41,0xAF,0x0E,0x03,0x51,0x09,0x30,
9961         0x28,0x02,0xC7,0x5F,0x9B,0x60,0x1C,0xEA,
9962         0x7C,0x87,0x3E,0x2F,0x78,0xD8,0x4F,0x05,
9963         0x9E,0xC4,0xA9,0xFA,0x5A,0x70,0x14,0x4F,
9964         0x00,0x3E,0xE1,0x01,0xFF,0xA1,0xC1,0x9A,
9965         0x44,0xF1,0x43,0x03,0xF5,0x11,0xE4,0xFF,
9966         0x7F,0x68,0xC0,0x28,0xEA,0xF9,0x06,0x7D,
9967         0xCC,0xF2,0xD9,0x20,0xE6,0x0B,0x48,0x84,
9968         0x07,0x10,0x5F,0x1F,0xD8,0x71,0xD2,0x67,
9969         0xA0,0x40,0x51,0xDE,0x37,0xF8,0x09,0x07,
9970         0x5C,0x83,0xF3,0x09,0x07,0xBC,0x87,0x23,
9971         0x1F,0x4B,0xC0,0x77,0xD0,0x84,0x73,0x81,
9972         0xF1,0x8D,0x8D,0x9D,0x06,0xC0,0x76,0x00,
9973         0x06,0xDF,0x69,0x00,0x1C,0xC7,0x24,0x7E,
9974         0x3A,0x04,0x13,0xCC,0xC1,0xBC,0x34,0xFB,
9975         0xFF,0xEF,0xFD,0x94,0x43,0xCF,0x86,0x80,
9976         0x75,0x49,0x07,0x43,0x94,0x88,0xB3,0x21,
9977         0x20,0xFD,0xFF,0x7F,0x36,0xC4,0x20,0xC4,
9978         0x09,0xFC,0x12,0xD1,0xDC,0xD9,0x90,0xAE,
9979         0xD8,0x67,0x43,0x80,0xE1,0xFF,0xFF,0x23,
9980         0x00,0xF6,0x7C,0x04,0x38,0x3D,0x64,0x83,
9981         0xE7,0x14,0x08,0xE3,0xE4,0x03,0x38,0xFE,
9982         0xFF,0x8F,0x15,0xE6,0x18,0x78,0xEA,0x97,
9983         0x9B,0x8F,0x03,0x54,0xD4,0x2B,0xC2,0x30,
9984         0x94,0xC5,0x87,0x05,0x1F,0x11,0xF8,0x61,
9985         0xC1,0x23,0xA8,0x78,0x9C,0xF4,0x74,0xE3,
9986         0x33,0x21,0x3B,0x24,0x38,0xFC,0x20,0xE9,
9987         0x41,0x13,0x3C,0xE7,0x23,0x78,0xB7,0x1E,
9988         0x38,0xA7,0x02,0xC0,0x4D,0xAE,0x27,0xA3,
9989         0x4E,0x17,0x0E,0x70,0x8E,0x92,0x8D,0x63,
9990         0x08,0xE5,0x70,0xCC,0xB7,0x87,0xA6,0xC9,
9991         0x4E,0x56,0x30,0x63,0x41,0xEA,0x24,0xE0,
9992         0x01,0x38,0x10,0x8C,0xB4,0x93,0x68,0x34,
9993         0x86,0xB3,0x5A,0x18,0xC1,0x19,0xC4,0xC7,
9994         0x11,0xE7,0x3A,0x19,0xA1,0x3F,0x07,0x3E,
9995         0x15,0x61,0x82,0xDC,0x4B,0xE8,0xBC,0x7D,
9996         0x37,0xE0,0x57,0x61,0x8F,0xC5,0xFF,0x7F,
9997         0x60,0xDF,0x4E,0xC0,0x31,0x17,0xAB,0x01,
9998         0x45,0x0D,0xC0,0x68,0x98,0x53,0xC0,0x53,
9999         0x09,0xB8,0x82,0xCD,0x0D,0x7D,0x61,0xB1,
10000         0xD6,0xA9,0xE8,0x14,0xF4,0x3E,0x70,0x70,
10001         0xC0,0x63,0xF6,0x1E,0x1C,0x2C,0x34,0x0F,
10002         0x0E,0x6C,0xD9,0x06,0x87,0x56,0x72,0x17,
10003         0x21,0x87,0x0F,0xFC,0xEC,0x80,0x03,0xA0,
10004         0x67,0x07,0x0B,0xC9,0xB3,0x03,0x9B,0xBE,
10005         0xB3,0x08,0x28,0x70,0xFE,0xFF,0x11,0xDE,
10006         0x3B,0x7C,0x6E,0x79,0xF6,0x60,0x63,0x78,
10007         0x74,0x31,0x9A,0xD1,0xB9,0xA6,0xDB,0x04,
10008         0x4A,0xC5,0x6D,0x82,0x82,0xF8,0x06,0xE0,
10009         0x84,0x34,0xBA,0x75,0xE2,0x66,0x62,0xFC,
10010         0x47,0x0C,0x1F,0x11,0x0E,0xE9,0x6C,0x4D,
10011         0x30,0x0F,0xA4,0x9E,0x81,0xBE,0xB3,0xE1,
10012         0x67,0x1F,0xF2,0xC1,0xC5,0xD3,0xF0,0xF5,
10013         0x86,0xDC,0x3B,0xE8,0xB4,0x7D,0x66,0xC0,
10014         0x1C,0x74,0x7D,0x9D,0x7A,0x83,0x27,0x57,
10015         0x09,0xEA,0xE1,0x02,0x42,0x2F,0x34,0xBE,
10016         0xDC,0x25,0x78,0xE0,0xF4,0xE9,0xEE,0xBD,
10017         0x84,0x9D,0xF1,0x12,0xBC,0xE0,0x25,0x98,
10018         0x77,0x10,0xA8,0x51,0x79,0x10,0x98,0xAB,
10019         0x3C,0xCB,0x37,0x06,0x54,0xB2,0x8B,0x16,
10020         0x3D,0xC3,0xBC,0xC3,0xF8,0x92,0xE0,0xEB,
10021         0x87,0xCF,0x2D,0x5E,0xC0,0xEB,0x16,0x0C,
10022         0x82,0x67,0xA0,0x57,0x17,0xDF,0xD9,0x0D,
10023         0xFC,0x2A,0xF0,0x46,0x13,0x22,0x98,0x61,
10024         0x0F,0xFF,0xDD,0xDD,0xA8,0xBE,0xE9,0x18,
10025         0xEB,0x75,0xC4,0x23,0xE5,0xC7,0x96,0x03,
10026         0x8A,0xF4,0xF2,0xE6,0x09,0xF8,0x2C,0xE3,
10027         0x53,0xDD,0x49,0xF9,0x7A,0x68,0xF4,0x57,
10028         0x08,0x1F,0x7E,0x8C,0xEC,0x73,0x0E,0x3B,
10029         0xDF,0xB1,0x41,0x71,0xC4,0x07,0x86,0x97,
10030         0x1A,0x4F,0x85,0x9D,0xBB,0x60,0x1C,0x1C,
10031         0xD8,0xB1,0x08,0x73,0x7C,0x05,0xD7,0xC9,
10032         0xE6,0xFF,0xFF,0xE4,0x00,0x6E,0x78,0xCC,
10033         0xC1,0xD7,0xE7,0x0D,0xDF,0x0C,0x3C,0x2E,
10034         0x7E,0xE4,0xF0,0x49,0xE3,0xA5,0xD3,0xD8,
10035         0xA7,0xE9,0xA3,0xD1,0xCB,0x9B,0x4F,0x2F,
10036         0x18,0x58,0x5F,0x1A,0x38,0xAC,0xD1,0xC2,
10037         0x3E,0x06,0x9C,0xB9,0x2F,0x44,0xB8,0xC3,
10038         0x23,0x58,0x00,0xF1,0xB7,0x92,0x47,0x0E,
10039         0x4F,0xC0,0x80,0x4C,0xD3,0xBA,0x74,0x20,
10040         0xE2,0xA7,0x3C,0x2B,0x5F,0x99,0x2E,0x43,
10041         0x0C,0xE3,0xA9,0xF2,0xF1,0xC3,0xB3,0xF1,
10042         0x51,0xC0,0xC7,0x28,0xCF,0xFC,0x8C,0x22,
10043         0xBD,0x32,0x10,0x50,0x9D,0x88,0xB8,0x42,
10044         0x18,0x89,0xA1,0xD1,0x9D,0x83,0xC7,0x1F,
10045         0x22,0x05,0x31,0xA0,0x6F,0x2E,0xC0,0xF4,
10046         0x4C,0x04,0x5C,0xFE,0xFF,0x37,0x17,0x80,
10047         0xFF,0xFF,0xFF,0x9B,0x0B,0xE0,0xE6,0xFE,
10048         0xE0,0x9B,0x0B,0x70,0x8D,0xB4,0x2A,0x7A,
10049         0x61,0x77,0x08,0x18,0xD4,0x9D,0x1D,0x70,
10050         0x78,0x2B,0x78,0x67,0x87,0xF5,0xFF,0xBF,
10051         0xB3,0xC3,0xC3,0x8C,0x13,0xE5,0x85,0x21,
10052         0xC6,0x3B,0x3B,0x0B,0xF0,0x26,0xD0,0x51,
10053         0xC6,0x77,0x76,0x80,0x1F,0x67,0xD8,0x77,
10054         0x69,0xF0,0x5E,0x75,0x81,0xF5,0xFF,0xFF,
10055         0xAA,0x0B,0x3C,0x04,0xDF,0xA7,0x41,0x3E,
10056         0x5E,0x30,0x8C,0x83,0x2B,0x27,0xA1,0xC7,
10057         0x02,0x6B,0x85,0x41,0xDD,0xA9,0xC1,0xA5,
10058         0x09,0x5C,0x17,0x5F,0x1F,0x6A,0x7C,0xA4,
10059         0xC5,0x9F,0x2F,0x70,0x01,0x86,0x4C,0x4F,
10060         0x65,0x30,0xAE,0x29,0x3E,0x95,0x61,0xEE,
10061         0x0E,0x1E,0x90,0x8F,0x18,0xC0,0x67,0x15,
10062         0x1E,0x18,0xEE,0xB4,0xE0,0x9B,0x92,0x41,
10063         0xCF,0x31,0xA8,0x8F,0x3C,0x27,0xEF,0x7B,
10064         0xC2,0xE3,0x84,0xA3,0x9E,0x83,0xE8,0xD8,
10065         0xC0,0x71,0xDC,0xC0,0xFD,0xFF,0xC7,0x06,
10066         0xEF,0x70,0x83,0x3B,0xE8,0xF8,0x62,0x70,
10067         0x5C,0x18,0xB8,0xE7,0x02,0x0F,0xC3,0x37,
10068         0x1D,0x8F,0x08,0x33,0xFE,0xD7,0x3F,0x23,
10069         0x04,0xC4,0x5F,0x8C,0xD8,0x80,0xC1,0x78,
10070         0x6B,0xF3,0xF5,0x0D,0x37,0x60,0x5F,0x1D,
10071         0x7C,0xC1,0xF0,0x09,0xCC,0xE8,0x2F,0x30,
10072         0x4F,0x62,0x3E,0x36,0x90,0x0B,0x1C,0x1D,
10073         0x30,0x38,0x00,0x3D,0x60,0xF8,0x87,0x8B,
10074         0x77,0x39,0x30,0x5C,0x05,0x7D,0x5C,0xF0,
10075         0xB1,0xC7,0x8A,0xEE,0x72,0xE8,0x9B,0x9C,
10076         0x61,0xE2,0x18,0xE2,0x0D,0x8C,0xDD,0x25,
10077         0xC8,0x61,0x0E,0xEA,0x5D,0xC2,0x73,0xE0,
10078         0x67,0x0B,0x9F,0xE0,0x7C,0xF3,0x09,0x71,
10079         0xAA,0x8F,0x56,0xEF,0x01,0x3E,0x7A,0xBC,
10080         0x77,0xF9,0xEC,0xC4,0x2E,0x02,0x3E,0x72,
10081         0x19,0xC7,0xD3,0xF4,0x15,0xD0,0x43,0x36,
10082         0xD8,0xAB,0x86,0x4F,0x60,0x3E,0xBA,0xE1,
10083         0x8E,0x51,0x9E,0x89,0xA7,0xEF,0x3B,0x08,
10084         0x3B,0x92,0x1C,0x75,0xA8,0x6B,0x7A,0x44,
10085         0xF9,0xFF,0x9F,0xD0,0x81,0xF8,0xD6,0x06,
10086         0xCE,0x68,0xF7,0x0F,0xF4,0x36,0x3D,0x32,
10087         0xCC,0xD1,0x00,0xD6,0x25,0x04,0x5C,0x77,
10088         0x0C,0x5F,0x42,0x80,0x4F,0xD0,0x4B,0x04,
10089         0xFA,0x9A,0xE1,0xD1,0x3D,0x02,0x60,0xAE,
10090         0x18,0xEC,0x58,0xE0,0xC3,0x86,0xAF,0x01,
10091         0xEC,0x5E,0xE0,0x30,0xF7,0x08,0x50,0x81,
10092         0x7A,0x78,0xF0,0xD5,0xDE,0x23,0x40,0x71,
10093         0xB2,0xF4,0xA1,0xC1,0x03,0xB5,0xAA,0x33,
10094         0x26,0x94,0x23,0x26,0x3F,0x9B,0xF9,0x26,
10095         0x81,0xB9,0x5D,0xFA,0x26,0x01,0x37,0xCF,
10096         0x2C,0x50,0x49,0x20,0xF4,0xFF,0xBF,0x49,
10097         0xC0,0x85,0xE9,0xF2,0x32,0x43,0xE7,0x7F,
10098         0xE0,0xBE,0xD5,0x79,0x84,0x3E,0x44,0x30,
10099         0x94,0xF7,0x3C,0x9F,0xC2,0xF8,0x19,0xC2,
10100         0x07,0x4C,0x76,0xA6,0xE0,0x67,0x4D,0xDC,
10101         0x1D,0xC0,0x28,0x6F,0x9E,0x9E,0x00,0x3B,
10102         0x7F,0x1A,0xF9,0xDD,0xE0,0x5D,0xC0,0xD3,
10103         0xF7,0xBD,0x88,0x9F,0x28,0xC0,0x17,0xEC,
10104         0x4E,0x07,0x05,0xFA,0x84,0x3C,0x22,0xA3,
10105         0xFA,0x88,0xC0,0x2F,0x49,0x60,0x3C,0x92,
10106         0xF8,0x40,0x01,0x84,0xEE,0x05,0xA8,0xD3,
10107         0x07,0x47,0x3D,0xE3,0x17,0x54,0x63,0xBE,
10108         0x5B,0x3D,0xC2,0x79,0x72,0x98,0xCB,0x01,
10109         0x8B,0x73,0x4D,0x02,0xD5,0x71,0x97,0x8F,
10110         0x0E,0xEE,0xB5,0x15,0xFB,0xFF,0x27,0x38,
10111         0xB8,0x77,0x96,0x77,0x3E,0x43,0x79,0x90,
10112         0xE0,0xBB,0xB6,0x82,0xE3,0xAA,0x06,0xE3,
10113         0xD8,0xC2,0x2F,0x79,0x80,0x9D,0x61,0x71,
10114         0xC1,0x7F,0x0F,0x03,0x51,0x89,0x30,0x28,
10115         0x02,0xCB,0xBB,0xB7,0x52,0xF8,0x43,0x06,
10116         0xE3,0x4D,0x81,0x4F,0x1A,0x3B,0x6A,0xE0,
10117         0xFB,0xFF,0x1F,0x35,0xD8,0x86,0x8A,0xBB,
10118         0x29,0x82,0x75,0xAA,0x98,0x21,0xF0,0x60,
10119         0x0F,0x00,0x9F,0xAF,0x7C,0x06,0x50,0x14,
10120         0x18,0xD4,0xA1,0x1D,0xCE,0x6D,0x18,0x70,
10121         0x30,0x62,0xDC,0xA5,0x10,0xEE,0x94,0xDF,
10122         0x51,0x62,0x3F,0x97,0xB3,0xE9,0xE2,0xAE,
10123         0xE6,0x3E,0x9D,0xB0,0x0B,0x32,0x8C,0xB3,
10124         0xC0,0x23,0xC0,0xAB,0x39,0xBF,0x20,0x3F,
10125         0x17,0xBF,0x10,0x3C,0x26,0x85,0x78,0x53,
10126         0x7A,0x25,0x36,0xC6,0x93,0x71,0x73,0xB7,
10127         0x62,0x72,0xDE,0x79,0x41,0x36,0xC6,0xD1,
10128         0x44,0x8C,0x72,0x6E,0x0F,0x03,0x91,0x5F,
10129         0x90,0x7D,0x3F,0x79,0x21,0x88,0x18,0xCD,
10130         0x10,0x41,0x9F,0x97,0x8D,0x15,0x28,0xDE,
10131         0x0B,0x32,0x13,0xF8,0x56,0xD0,0xC1,0xC5,
10132         0x17,0x64,0xEC,0xFF,0xFF,0x82,0x0C,0x30,
10133         0xE2,0x64,0x04,0xF8,0x3C,0x71,0xE0,0xCE,
10134         0x35,0x30,0xFE,0xFF,0x97,0x6A,0xD8,0x27,
10135         0x1B,0xC0,0xD9,0xD0,0x7D,0xB2,0x01,0xF7,
10136         0x68,0xE1,0x1D,0x4D,0x10,0x27,0x1B,0x0A,
10137         0xE4,0xE0,0xEB,0xA2,0x70,0x3C,0xF4,0x49,
10138         0x84,0x1E,0x9D,0x7C,0x94,0xC4,0x9D,0x19,
10139         0x3C,0x91,0x77,0x16,0x8F,0xE2,0x65,0xD0,
10140         0xF7,0x82,0x13,0x79,0x7D,0xB0,0x9C,0x63,
10141         0x24,0xA8,0x46,0xE2,0xE3,0x03,0xFC,0xEB,
10142         0x8B,0x8F,0x91,0xF0,0xF9,0xFC,0xC3,0xF2,
10143         0x60,0x0C,0xF9,0xFF,0x7F,0x8A,0xC4,0x80,
10144         0x3C,0xBB,0x3C,0x86,0xF0,0x0B,0x24,0xDC,
10145         0xD3,0xCC,0x01,0x60,0x64,0x5D,0x1E,0xD1,
10146         0x67,0x47,0x8E,0x11,0xD7,0x17,0x45,0x5F,
10147         0x81,0x7D,0x10,0x38,0x9F,0xE7,0x44,0xB0,
10148         0x8E,0x9A,0x1F,0x6D,0xF8,0xF8,0x39,0xF8,
10149         0x5B,0xC1,0x03,0xA5,0x8F,0x45,0x21,0x1E,
10150         0x91,0xF8,0x39,0x11,0x5C,0x26,0xCE,0x89,
10151         0x40,0xE2,0xD0,0x0B,0xE3,0xB4,0x80,0x1B,
10152         0x88,0xCF,0x94,0xD8,0x29,0x9F,0x08,0x3B,
10153         0x97,0x60,0x46,0x07,0xAE,0xCB,0xBD,0x47,
10154         0x07,0xFE,0x93,0x00,0x1E,0xEB,0xFF,0xFF,
10155         0x78,0x07,0xBE,0x93,0xBA,0xEF,0x26,0xBE,
10156         0xC8,0xF8,0x50,0xF4,0x7C,0x07,0xF8,0x0F,
10157         0x77,0xB8,0x43,0xC5,0x39,0xDF,0x01,0xD2,
10158         0xFE,0xFF,0xE7,0x3B,0x60,0x79,0xB6,0x7E,
10159         0xBE,0x03,0xBB,0xC8,0xF3,0x1D,0x40,0xAC,
10160         0xFF,0xFF,0xF9,0x0E,0xB0,0x73,0x46,0xC3,
10161         0x9D,0xEF,0xC0,0x76,0xB4,0x01,0xCC,0x4D,
10162         0xE3,0xD1,0x06,0xDC,0xC3,0x85,0x3D,0x0C,
10163         0xAE,0xD0,0xA6,0x4F,0x8D,0x46,0xAD,0x1A,
10164         0x94,0xA9,0x51,0xE6,0xFF,0xDF,0xA0,0x56,
10165         0x9F,0x4A,0x8D,0x19,0xCB,0x0E,0xA5,0x80,
10166         0x8F,0x0A,0x8D,0xCD,0xF2,0x28,0x04,0x62,
10167         0x31,0xAF,0x06,0x81,0x38,0x2C,0x08,0x8D,
10168         0xF4,0xCA,0x11,0x88,0x25,0x3F,0xFB,0x05,
10169         0x62,0xB9,0x6F,0x06,0x81,0x38,0xE0,0x1B,
10170         0x4C,0xE0,0xE4,0x61,0x25,0x70,0xF2,0x6E,
10171         0x10,0x88,0x23,0x83,0x50,0xA1,0x3A,0x40,
10172         0x58,0x4C,0x10,0x1A,0xCA,0x07,0x08,0x93,
10173         0xFE,0x48,0x10,0x20,0x31,0x02,0xC2,0xC2,
10174         0xBD,0xBF,0x04,0x62,0x69,0xEF,0x09,0x81,
10175         0x58,0x88,0x15,0x10,0x16,0x17,0x84,0x86,
10176         0xD3,0x02,0xC2,0x24,0x99,0x01,0x61,0x81,
10177         0x40,0xA8,0x7C,0x35,0x20,0x4C,0xA4,0x1B,
10178         0x40,0xBA,0x7A,0x81,0x38,0x88,0x1E,0x10,
10179         0x26,0xC3,0x0F,0x08,0x0B,0x0D,0x42,0xA3,
10180         0x3D,0x30,0x04,0x48,0x0C,0x81,0xB0,0xF8,
10181         0x8E,0x40,0x98,0xF8,0x57,0x91,0x40,0x9C,
10182         0xDF,0x12,0xC4,0x4D,0x69,0x88,0x35,0x01,
10183         0x31,0x0D,0x9E,0x80,0x98,0x22,0x10,0x01,
10184         0x39,0xF6,0xD3,0x43,0x40,0xD6,0x60,0x0A,
10185         0x88,0x45,0x07,0x11,0x90,0x85,0xA8,0x02,
10186         0x62,0x79,0x5D,0x01,0xB1,0xF0,0x20,0x02,
10187         0x72,0xE6,0x97,0x9F,0x80,0xAC,0xE0,0xA5,
10188         0xF3,0x10,0xC0,0xDE,0x10,0x81,0x48,0x72,
10189         0x10,0x01,0x39,0xB0,0x2F,0x20,0x16,0x1F,
10190         0x44,0x40,0xCE,0xFA,0x28,0x14,0x90,0x83,
10191         0x83,0x68,0x10,0xE4,0x6B,0x26,0x20,0xA7,
10192         0x07,0x11,0x10,0xF9,0x04,0x05,0x21,0x6A,
10193         0xBD,0x81,0x30,0x3D,0x8F,0x42,0x0D,0x85,
10194         0x80,0x50,0xE5,0xEA,0xCE,0x31,0x2C,0x07,
10195         0x08,0xCD,0x05,0x22,0x30,0xAB,0x70,0x07,
10196         0xC4,0x54,0x81,0x08,0xC8,0x09,0x80,0xC8,
10197         0xFF,0x9F,0x60,0x2A,0x10,0x9A,0x12,0x8C,
10198         0xEA,0x92,0x07,0xC4,0x12,0x80,0xD0,0x54,
10199         0x20,0x34,0x25,0x88,0x00,0xAD,0xCA,0x1E,
10200         0x10,0x53,0x0A,0x42,0x95,0x83,0xD0,0x74,
10201         0x20,0x54,0xB6,0xBE,0xC3,0x02,0x05,0x11,
10202         0x90,0xA3,0x83,0x50,0xE1,0xFE,0x40,0x98,
10203         0xDE,0x97,0x86,0x00,0x9D,0x0E,0x44,0x40,
10204         0x4E,0x0C,0x42,0x15,0x7C,0x32,0x82,0x10,
10205         0xB1,0x20,0x54,0xC1,0x27,0x23,0x28,0xD1,
10206         0xF2,0xB2,0x13,0x90,0xF5,0x81,0x50,0xBD,
10207         0x20,0x02,0x73,0x36,0x20,0x9A,0x17,0x84,
10208         0xE6,0x07,0xA3,0x5A,0x8D,0x02,0x31,0xFD,
10209         0x20,0x34,0x0F,0x88,0xC0,0xAC,0xE0,0xF9,
10210         0x71,0xC0,0x0C,0x84,0xAA,0x04,0x11,0x98,
10211         0x73,0x01,0xD1,0xAC,0x20,0x34,0x3B,0x18,
10212         0xD5,0xFE,0x0F,0xD1,0x00,0x08,0x08,0xCD,
10213         0x07,0xA2,0xC3,0x00,0x79,0x96,0x09,0xC8,
10214         0x1A,0x41,0xA8,0x66,0x10,0x81,0x39,0x27,
10215         0x10,0xCD,0x0E,0x42,0x95,0xFD,0x4D,0x82,
10216         0x91,0x8C,0x0F,0xD0,0x40,0x24,0x37,0x08,
10217         0xD5,0xF1,0x0C,0x0A,0x46,0x74,0x83,0x08,
10218         0xC8,0x59,0x40,0x68,0x36,0x30,0x9A,0x4C,
10219         0xED,0x91,0x80,0xBA,0x05,0x61,0xE9,0x41,
10220         0x68,0x3A,0xBB,0x83,0xA7,0x20,0x54,0x81,
10221         0x5E,0x30,0xA6,0x19,0x44,0x87,0x05,0x02,
10222         0x42,0x73,0x81,0x51,0x1D,0xAF,0x96,0x40,
10223         0x44,0x1B,0x08,0xD5,0x0A,0xA2,0x81,0x93,
10224         0x1F,0x53,0x10,0x92,0x14,0x84,0xFC,0xFF,
10225         0x07,0xAA,0xC7,0x9C,0x40,0xAC,0xFA,0x5B,
10226         0x25,0x50,0x27,0x01,0xA1,0xC9,0x40,0x74,
10227         0x7C,0x20,0x0F,0xB8,0x83,0x64,0x20,0x54,
10228         0x29,0x88,0xC0,0xAC,0xF4,0x63,0xA4,0x23,
10229         0x05,0x51,0x7D,0xBC,0xA0,0x20,0x34,0xD1,
10230         0x3B,0x2C,0x08,0x7B,0xB8,0x69,0xA8,0xE4,
10231         0x59,0xA5,0xA1,0x12,0x10,0x9A,0x0D,0x44,
10232         0xC7,0x04,0xF2,0xAA,0x79,0x4C,0x60,0x20,
10233         0x54,0x2F,0x08,0xCD,0x01,0x42,0x13,0x83,
10234         0x08,0xD4,0xA9,0xBF,0x37,0x1A,0x2A,0xF9,
10235         0x5B,0x09,0xC4,0xCA,0x5E,0x69,0x02,0xB1,
10236         0xDE,0xA7,0x4E,0x20,0xE6,0x1D,0x98,0xA9,
10237         0x05,0xA1,0xEA,0x41,0x04,0xE6,0xB4,0x40,
10238         0x54,0x81,0x78,0x10,0xA6,0x08,0x44,0x60,
10239         0x4E,0x02,0x44,0xD3,0x81,0xD0,0xEC,0x60,
10240         0x54,0xE7,0xA3,0x4D,0x40,0xD6,0x0E,0x42,
10241         0xB3,0x80,0x08,0xCC,0x59,0x1E,0x69,0x02,
10242         0xB1,0x92,0x2F,0x9D,0x0E,0x24,0x04,0x84,
10243         0x26,0xD3,0x7F,0x68,0xA1,0x05,0x80,0x99,
10244         0x84,0x04,0x20,0x4C,0x16,0x88,0x0E,0x27,
10245         0xD6,0x08,0x22,0x40,0xC7,0x01,0xA3,0xD1,
10246         0x40,0x68,0x5C,0x40,0x9A,0x1D,0x90,0x2A,
10247         0x6D,0x00,0xC6,0x54,0x83,0xD0,0x24,0x20,
10248         0x02,0x74,0x2C,0x10,0x01,0x5A,0x74,0x04,
10249         0x30,0x16,0x01,0x84,0x46,0x05,0xA1,0xC9,
10250         0x2A,0x80,0xB2,0x9C,0x20,0x1A,0x20,0xC9,
10251         0x30,0x60,0x0A,0x42,0x33,0x81,0xD0,0x8C,
10252         0x20,0x54,0x7C,0x07,0x10,0x16,0x04,0x84,
10253         0x86,0x03,0xD1,0x00,0xFE,0xFF,0x8F,0x0C,
10254         0x02,0xD1,0x00,0x9C,0x23,0xC4,0x61,0x85,
10255         0x82,0xD0,0xF4,0x20,0x34,0x6C,0x09,0x50,
10256         0x16,0x1D,0x44,0xC7,0x23,0x92,0x02,0x8C,
10257         0x05,0x02,0xA1,0x31,0x41,0x68,0x6C,0x10,
10258         0x1A,0x29,0x06,0x28,0x13,0x54,0xE3,0x50,
10259         0x44,0x7B,0x80,0x31,0x99,0x20,0x54,0x36,
10260         0x88,0xC0,0x1C,0x14,0x88,0x86,0x07,0xA1,
10261         0x62,0x82,0x00,0x52,0x10,0x01,0x12,0x20,
10262         0x1A,0x1E,0x84,0x8A,0x29,0x32,0x74,0x0A,
10263         0x42,0x55,0x24,0x39,0x9A,0x50,0x10,0x1D,
10264         0x4D,0x08,0x08,0xCD,0x07,0x46,0x75,0x35,
10265         0x39,0x6E,0x50,0x10,0xAA,0x1D,0x84,0x06,
10266         0x05,0xA1,0x39,0xA2,0x80,0xB2,0xEC,0x20,
10267         0x02,0xB2,0x9E,0x2A,0x87,0x0A,0x0A,0x22,
10268         0x30,0xA7,0x02,0xA2,0x49,0x41,0xA8,0x8E,
10269         0x2C,0x47,0x0A,0x9A,0x06,0x84,0x25,0x06,
10270         0xA1,0xC9,0xDA,0x80,0xB0,0x0C,0x75,0x0E,
10271         0x24,0x14,0x84,0xE6,0x04,0xA1,0x4A,0xF2,
10272         0x0C,0x8F,0x82,0xE8,0x38,0x42,0x80,0x68,
10273         0x7A,0x10,0xAA,0xA6,0xCF,0x00,0x28,0x88,
10274         0x06,0x40,0x40,0x68,0x4E,0x30,0xAA,0xA8,
10275         0xD1,0xD1,0x84,0x82,0x50,0xDD,0x2F,0x4E,
10276         0x81,0xF8,0xFF,0x0F,
10277     })  // END MBUF
10278
10279 } //end DefinitionBlock
10280