1    /*
2     * Some or all of this work - Copyright (c) 2006 - 2021, 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     * Integer arithmetic
30     */
31    Name (Z083, 0x53)
32    /* Verifying 2-parameters, 1-result operator */
33
34    Method (M000, 6, Serialized)
35    {
36        Local5 = 0x00
37        Local3 = Arg1
38        While (Local3)
39        {
40            /* Operands */
41
42            Local6 = (Local5 * 0x02)
43            Local0 = DerefOf (Arg3 [Local6])
44            Local6++
45            Local1 = DerefOf (Arg3 [Local6])
46            /* Expected result */
47
48            Local2 = DerefOf (Arg4 [Local5])
49            Switch (ToInteger (Arg5))
50            {
51                Case (0x00)
52                {
53                    Local7 = (Local0 + Local1)
54                    If ((Local7 != Local2))
55                    {
56                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
57                    }
58
59                    Local7 = (Local1 + Local0)
60                    If ((Local7 != Local2))
61                    {
62                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
63                    }
64                }
65                Case (0x01)
66                {
67                    Local7 = (Local0 - Local1)
68                    If ((Local7 != Local2))
69                    {
70                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
71                    }
72                }
73                Case (0x02)
74                {
75                    Local7 = (Local0 * Local1)
76                    If ((Local7 != Local2))
77                    {
78                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
79                    }
80
81                    Local7 = (Local1 * Local0)
82                    If ((Local7 != Local2))
83                    {
84                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
85                    }
86                }
87                Case (0x03)
88                {
89                    Local7 = (Local0 & Local1)
90                    If ((Local7 != Local2))
91                    {
92                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
93                    }
94
95                    Local7 = (Local1 & Local0)
96                    If ((Local7 != Local2))
97                    {
98                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
99                    }
100                }
101                Case (0x04)
102                {
103                    NAnd (Local0, Local1, Local7)
104                    If ((Local7 != Local2))
105                    {
106                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
107                    }
108
109                    NAnd (Local1, Local0, Local7)
110                    If ((Local7 != Local2))
111                    {
112                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
113                    }
114                }
115                Case (0x05)
116                {
117                    NOr (Local0, Local1, Local7)
118                    If ((Local7 != Local2))
119                    {
120                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
121                    }
122
123                    NOr (Local1, Local0, Local7)
124                    If ((Local7 != Local2))
125                    {
126                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
127                    }
128                }
129                Case (0x06)
130                {
131                    Local7 = (Local0 | Local1)
132                    If ((Local7 != Local2))
133                    {
134                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
135                    }
136
137                    Local7 = (Local1 | Local0)
138                    If ((Local7 != Local2))
139                    {
140                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
141                    }
142                }
143                Case (0x07)
144                {
145                    Local7 = (Local0 ^ Local1)
146                    If ((Local7 != Local2))
147                    {
148                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
149                    }
150
151                    Local7 = (Local1 ^ Local0)
152                    If ((Local7 != Local2))
153                    {
154                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
155                    }
156                }
157                Case (0x08)
158                {
159                    Local7 = (Local0 % Local1)
160                    If ((Local7 != Local2))
161                    {
162                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
163                    }
164                }
165                Case (0x09)
166                {
167                    Local7 = (Local0 << Local1)
168                    If ((Local7 != Local2))
169                    {
170                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
171                    }
172                }
173                Case (0x0A)
174                {
175                    Local7 = (Local0 >> Local1)
176                    If ((Local7 != Local2))
177                    {
178                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
179                    }
180                }
181
182            }
183
184            Local5++
185            Local3--
186        }
187    }
188
189    /* Verifying 2-parameters, 2-results operator */
190
191    Method (M001, 6, Serialized)
192    {
193        Local5 = 0x00
194        Local4 = Arg1
195        While (Local4)
196        {
197            /* Operands */
198
199            Local6 = (Local5 * 0x02)
200            Local0 = DerefOf (Arg3 [Local6])
201            Local6++
202            Local1 = DerefOf (Arg3 [Local6])
203            /* Expected result */
204
205            Local6 = (Local5 * 0x02)
206            Local2 = DerefOf (Arg4 [Local6])
207            Local6++
208            Local3 = DerefOf (Arg4 [Local6])
209            Switch (ToInteger (Arg5))
210            {
211                Case (0x00)
212                {
213                    Divide (Local0, Local1, Local6, Local7)
214                    If ((Local7 != Local2))
215                    {
216                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
217                    }
218
219                    If ((Local6 != Local3))
220                    {
221                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
222                    }
223                }
224
225            }
226
227            Local5++
228            Local4--
229        }
230    }
231
232    /* Verifying 1-parameter, 1-result operator */
233
234    Method (M002, 6, Serialized)
235    {
236        Local5 = 0x00
237        Local3 = Arg1
238        While (Local3)
239        {
240            /* Operand */
241
242            Local0 = DerefOf (Arg3 [Local5])
243            /* Expected result */
244
245            Local1 = DerefOf (Arg4 [Local5])
246            Switch (ToInteger (Arg5))
247            {
248                Case (0x00)
249                {
250                    Local0++
251                    If ((Local0 != Local1))
252                    {
253                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
254                    }
255                }
256                Case (0x01)
257                {
258                    Local0--
259                    If ((Local0 != Local1))
260                    {
261                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
262                    }
263                }
264                Case (0x02)
265                {
266                    Local2 = ~Local0
267                    If ((Local2 != Local1))
268                    {
269                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
270                    }
271                }
272                Case (0x03)
273                {
274                    FindSetLeftBit (Local0, Local2)
275                    If ((Local2 != Local1))
276                    {
277                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
278                    }
279                }
280                Case (0x04)
281                {
282                    FindSetRightBit (Local0, Local2)
283                    If ((Local2 != Local1))
284                    {
285                        ERR (Arg0, Z083, __LINE__, 0x00, 0x00, Local5, Arg2)
286                    }
287                }
288
289            }
290
291            Local5++
292            Local3--
293        }
294    }
295
296    /* =================================== // */
297    /*          Bitwise operands           // */
298    /*                                     // */
299    /*  (utilized by different operators)  // */
300    /* =================================== // */
301    Name (P030, Package (0x14)
302    {
303        0x00,
304        0x00,
305        0x00,
306        0xFFFFFFFF,
307        0xFFFFFFFF,
308        0xFFFFFFFF,
309        0xF0F0F0F0,
310        0xFFFFFFFF,
311        0x0F0F0F0F,
312        0xFFFFFFFF,
313        0xF0F0F0F0,
314        0x00,
315        0x0F0F0F0F,
316        0x00,
317        0xF0F0F0F0,
318        0x11111111,
319        0x0F0F0F0F,
320        0x11111111,
321        0x87654321,
322        0x90ABCDFE
323    })
324    Name (P031, Package (0x14)
325    {
326        0x00,
327        0x00,
328        0x00,
329        0xFFFFFFFFFFFFFFFF,
330        0xFFFFFFFFFFFFFFFF,
331        0xFFFFFFFFFFFFFFFF,
332        0xF0F0F0F0F0F0F0F0,
333        0xFFFFFFFFFFFFFFFF,
334        0x0F0F0F0F0F0F0F0F,
335        0xFFFFFFFFFFFFFFFF,
336        0xF0F0F0F0F0F0F0F0,
337        0x00,
338        0x0F0F0F0F0F0F0F0F,
339        0x00,
340        0xF0F0F0F0F0F0F0F0,
341        0x1111111111111111,
342        0x0F0F0F0F0F0F0F0F,
343        0x1111111111111111,
344        0x8765432199118822,
345        0x90AB66887799CDFE
346    })
347    Name (P032, Package (0x05)
348    {
349        0x00,
350        0xFFFFFFFF,
351        0xF0F0F0F0,
352        0x0F0F0F0F,
353        0x12345678
354    })
355    Name (P033, Package (0x05)
356    {
357        0x00,
358        0xFFFFFFFFFFFFFFFF,
359        0xF0F0F0F0F0F0F0F0,
360        0x0F0F0F0F0F0F0F0F,
361        0x123456780AF9BCED
362    })
363    /* ===================================== Add */
364
365    Name (P000, Package (0x14)
366    {
367        0x12345678,
368        0x6BCDEF01,
369        0x62345678,
370        0x4BCDEF01,
371        0x00,
372        0x00,
373        0x10000000,
374        0x90000000,
375        0x00,
376        0xFF,
377        0x00,
378        0xFFFF,
379        0x00,
380        0xFFFFFFFF,
381        /* 32-overflow */
382
383        0x12345678,
384        0xF0000000,
385        0xFFFFFFFF,
386        0xFFFFFFFF,
387        0x01,
388        0xFFFFFFFF
389    })
390    Name (P001, Package (0x0A)
391    {
392        0x7E024579,
393        0xAE024579,
394        0x00,
395        0xA0000000,
396        0xFF,
397        0xFFFF,
398        0xFFFFFFFF,
399        /* 32-overflow */
400
401        0x02345678,
402        0xFFFFFFFE,
403        0x00
404    })
405    Name (P002, Package (0x1A)
406    {
407        /* 32-overflow */
408
409        0x12345678,
410        0xF0000000,
411        0xFFFFFFFF,
412        0xFFFFFFFF,
413        0x12345678DCABEF98,
414        0x6BCDEF0119283746,
415        0x72345678DCABEF98,
416        0x5BCDEF0119283746,
417        0x00,
418        0x00,
419        0x1000000000000000,
420        0x9000000000000000,
421        0x00,
422        0xFF,
423        0x00,
424        0xFFFF,
425        0x00,
426        0xFFFFFFFF,
427        0x00,
428        0xFFFFFFFFFFFFFFFF,
429        /* 64-overflow */
430
431        0x12345678DCABEF98,
432        0xF000000000000000,
433        0xFFFFFFFFFFFFFFFF,
434        0xFFFFFFFFFFFFFFFF,
435        0x01,
436        0xFFFFFFFFFFFFFFFF
437    })
438    Name (P003, Package (0x0D)
439    {
440        /* 32-overflow */
441
442        0x0000000102345678,
443        0x00000001FFFFFFFE,
444        0x7E024579F5D426DE,
445        0xCE024579F5D426DE,
446        0x00,
447        0xA000000000000000,
448        0xFF,
449        0xFFFF,
450        0xFFFFFFFF,
451        0xFFFFFFFFFFFFFFFF,
452        /* 64-overflow */
453
454        0x02345678DCABEF98,
455        0xFFFFFFFFFFFFFFFE,
456        0x00
457    })
458    Method (ADD0, 0, Serialized)
459    {
460        Debug = "TEST: ADD0, Integer Add"
461        If ((F64 == 0x01))
462        {
463            M000 (__METHOD__, 0x07, "p000", P000, P001, 0x00)
464            M000 (__METHOD__, 0x0D, "p002", P002, P003, 0x00)
465        }
466        Else
467        {
468            M000 (__METHOD__, 0x0A, "p000", P000, P001, 0x00)
469        }
470    }
471
472    /* ===================================== Subtract */
473
474    Name (P004, Package (0x18)
475    {
476        0x62345678,
477        0x4BCDEF01,
478        0x00,
479        0x00,
480        0x90000000,
481        0x10000000,
482        0xFF,
483        0x00,
484        0xFFFF,
485        0x00,
486        0xFFFFFFFF,
487        0xFFFFFFFF,
488        0xFFFFFFFF,
489        0x00,
490        /* 32-overflow */
491
492        0x00,
493        0x87654321,
494        0x12345678,
495        0x6BCDEF01,
496        0x10000000,
497        0x90000000,
498        0x00,
499        0xFF,
500        0x00,
501        0xFFFF
502    })
503    Name (P005, Package (0x0C)
504    {
505        0x16666777,
506        0x00,
507        0x80000000,
508        0xFF,
509        0xFFFF,
510        0x00,
511        0xFFFFFFFF,
512        /* 32-overflow */
513
514        0x789ABCDF,
515        0xA6666777,
516        0x80000000,
517        0xFFFFFF01,
518        0xFFFF0001
519    })
520    Name (P006, Package (0x28)
521    {
522        /* 32-overflow */
523
524        0x00,
525        0x87654321,
526        0x12345678,
527        0x6BCDEF01,
528        0x10000000,
529        0x90000000,
530        0x00,
531        0xFF,
532        0x00,
533        0xFFFF,
534        0x12345678DCABEF98,
535        0x6BCDEF0119283746,
536        0x72345678DCABEF98,
537        0x5BCDEF0119283746,
538        0x00,
539        0x00,
540        0xFFFFFFFFFFFFFFFF,
541        0x00,
542        0x00,
543        0xFFFFFFFFFFFFFFFF,
544        0x9000000000000000,
545        0x1000000000000000,
546        0x1000000000000000,
547        0x9000000000000000,
548        0xFF,
549        0x00,
550        0x00,
551        0xFF,
552        0xFFFF,
553        0x00,
554        0x00,
555        0xFFFF,
556        0xFFFFFFFF,
557        0x00,
558        0x00,
559        0xFFFFFFFF,
560        0xFFFFFFFFFFFFFFFF,
561        0xFFFFFFFFFFFFFFFF,
562        0x12345678DCABEF98,
563        0xF000000000000000
564    })
565    Name (P007, Package (0x14)
566    {
567        /* 32-overflow */
568
569        0xFFFFFFFF789ABCDF,
570        0xFFFFFFFFA6666777,
571        0xFFFFFFFF80000000,
572        0xFFFFFFFFFFFFFF01,
573        0xFFFFFFFFFFFF0001,
574        0xA6666777C383B852,
575        0x16666777C383B852,
576        0x00,
577        0xFFFFFFFFFFFFFFFF,
578        0x01,
579        0x8000000000000000,
580        0x8000000000000000,
581        0xFF,
582        0xFFFFFFFFFFFFFF01,
583        0xFFFF,
584        0xFFFFFFFFFFFF0001,
585        0xFFFFFFFF,
586        0xFFFFFFFF00000001,
587        0x00,
588        0x22345678DCABEF98
589    })
590    Method (SUB0, 0, Serialized)
591    {
592        Debug = "TEST: SUB0, Integer Subtract"
593        If ((F64 == 0x01))
594        {
595            M000 (__METHOD__, 0x07, "p004", P004, P005, 0x01)
596            M000 (__METHOD__, 0x14, "p006", P006, P007, 0x01)
597        }
598        Else
599        {
600            M000 (__METHOD__, 0x0C, "p004", P004, P005, 0x01)
601        }
602    }
603
604    /* ===================================== Multiply */
605
606    Name (P008, Package (0x14)
607    {
608        0x00,
609        0x00,
610        0x00,
611        0xFFFFFFFF,
612        0x00012345,
613        0x7ABC,
614        0x12,
615        0x34,
616        0x01,
617        0xFF,
618        0x01,
619        0xFFFF,
620        0x01,
621        0xFFFFFFFF,
622        /* bit-size of multiplicand */
623
624        0x67812345,
625        0x02,
626        /* bit-size of multiplier */
627
628        0x03,
629        0x45678123,
630        0xFFFFFFFF,
631        0xFFFFFFFF
632        /* ACPI: Overflow conditions are ignored and results are undefined. */
633    })
634    Name (P009, Package (0x0A)
635    {
636        0x00,
637        0x00,
638        0x8BA4C8AC,
639        0x03A8,
640        0xFF,
641        0xFFFF,
642        0xFFFFFFFF,
643        /* bit-size of multiplicand */
644
645        0xCF02468A,
646        /* bit-size of multiplier */
647
648        0xD0368369,
649        0x01
650        /* ACPI: Overflow conditions are ignored and results are undefined. */
651    })
652    Name (P00A, Package (0x0E)
653    {
654        0x92345678,
655        0xABCDEF68,
656        0xF2345678,
657        0xABCDEF68,
658        0x00,
659        0xFFFFFFFFFFFFFFFF,
660        0x01,
661        0xFFFFFFFFFFFFFFFF,
662        /* bit-size of multiplicand */
663
664        0x6781234511992288,
665        0x02,
666        /* bit-size of multiplier */
667
668        0x03,
669        0x4567812377665544,
670        0xFFFFFFFFFFFFFFFF,
671        0xFFFFFFFFFFFFFFFF
672        /* ACPI: Overflow conditions are ignored and results are undefined. */
673    })
674    Name (P00B, Package (0x07)
675    {
676        0x621E9265A81528C0,
677        0xA28BCC2CA81528C0,
678        0x00,
679        0xFFFFFFFFFFFFFFFF,
680        /* bit-size of multiplicand */
681
682        0xCF02468A23324510,
683        /* bit-size of multiplier */
684
685        0xD036836A6632FFCC,
686        0x01
687        /* ACPI: Overflow conditions are ignored and results are undefined. */
688    })
689    Method (MTP0, 0, Serialized)
690    {
691        Debug = "TEST: MTP0, Integer Multiply"
692        If ((F64 == 0x01))
693        {
694            M000 (__METHOD__, 0x09, "p008", P008, P009, 0x02)
695            M000 (__METHOD__, 0x07, "p00a", P00A, P00B, 0x02)
696        }
697        Else
698        {
699            M000 (__METHOD__, 0x0A, "p008", P008, P009, 0x02)
700        }
701    }
702
703    /* ===================================== Divide */
704
705    Name (P00C, Package (0x10)
706    {
707        /* divident divisor */
708
709        0x12345678,
710        0x1000,
711        0xFFFFFFFF,
712        0x00400000,
713        /* bit-size of operands */
714
715        0x78123456,
716        0x80000000,
717        0x78123456,
718        0x02,
719        0x00,
720        0x01,
721        0x78123456,
722        0x11223344,
723        /* bit-size of result */
724
725        0xFFFFFFFF,
726        0x01,
727        /* bit-size of remainder */
728
729        0xFFFFFFFF,
730        0x80000000
731    })
732    Name (P00D, Package (0x10)
733    {
734        /* result   remainder */
735
736        0x00012345,
737        0x0678,
738        0x03FF,
739        0x003FFFFF,
740        0x00,
741        0x78123456,
742        0x3C091A2B,
743        0x00,
744        0x00,
745        0x00,
746        0x07,
747        0x0022CD7A,
748        0xFFFFFFFF,
749        0x00,
750        0x01,
751        0x7FFFFFFF
752    })
753    Name (P00E, Package (0x10)
754    {
755        /* divident         divisor */
756
757        0x1234567811223344,
758        0x1000,
759        0xFFFFFFFFFFFFFFFF,
760        0x4000000000000000,
761        0x7812345699887766,
762        0x8000000000000000,
763        0x7812345600448866,
764        0x02,
765        0x00,
766        0x01,
767        0x78123456AABBCCDD,
768        0x110022BD33CA4784,
769        0xFFFFFFFFFFFFFFFF,
770        0x01,
771        0xFFFFFFFFFFFFFFFF,
772        0x8000000000000000
773    })
774    Name (P00F, Package (0x10)
775    {
776        /* result           remainder */
777
778        0x0001234567811223,
779        0x0344,
780        0x03,
781        0x3FFFFFFFFFFFFFFF,
782        0x00,
783        0x7812345699887766,
784        0x3C091A2B00224433,
785        0x00,
786        0x00,
787        0x00,
788        0x07,
789        0x0111412A4033D841,
790        0xFFFFFFFFFFFFFFFF,
791        0x00,
792        0x01,
793        0x7FFFFFFFFFFFFFFF
794    })
795    Method (DVD0, 0, Serialized)
796    {
797        Debug = "TEST: DVD0, Integer Divide"
798        If ((F64 == 0x01))
799        {
800            M001 (__METHOD__, 0x08, "p00c", P00C, P00D, 0x00)
801            M001 (__METHOD__, 0x08, "p00e", P00E, P00F, 0x00)
802        }
803        Else
804        {
805            M001 (__METHOD__, 0x08, "p00c", P00C, P00D, 0x00)
806        }
807    }
808
809    /* ===================================== Increment */
810
811    Name (P014, Package (0x06)
812    {
813        0x00,
814        0xFFFFFFFE,
815        0x12334579,
816        0x7FFFFFFF,
817        0x80000000,
818        0xFFFFFFFF
819    })
820    Name (P015, Package (0x06)
821    {
822        0x01,
823        0xFFFFFFFF,
824        0x1233457A,
825        0x80000000,
826        0x80000001,
827        0x00
828    })
829    Name (P016, Package (0x06)
830    {
831        0xFFFFFFFF,
832        0xFFFFFFFFFFFFFFFE,
833        0x1233457988339042,
834        0x7FFFFFFFFFFFFFFF,
835        0x8000000000000000,
836        0xFFFFFFFFFFFFFFFF
837    })
838    Name (P017, Package (0x06)
839    {
840        0x0000000100000000,
841        0xFFFFFFFFFFFFFFFF,
842        0x1233457988339043,
843        0x8000000000000000,
844        0x8000000000000001,
845        0x00
846    })
847    Method (ICR0, 0, Serialized)
848    {
849        Debug = "TEST: ICR0, Increment an Integer"
850        If ((F64 == 0x01))
851        {
852            M002 (__METHOD__, 0x05, "p014", P014, P015, 0x00)
853            M002 (__METHOD__, 0x06, "p016", P016, P017, 0x00)
854        }
855        Else
856        {
857            M002 (__METHOD__, 0x06, "p014", P014, P015, 0x00)
858        }
859    }
860
861    /* ===================================== Decrement */
862
863    Name (P018, Package (0x06)
864    {
865        0xFFFFFFFF,
866        0x12334579,
867        0x80000000,
868        0x7FFFFFFF,
869        0x80000001,
870        0x00
871    })
872    Name (P019, Package (0x06)
873    {
874        0xFFFFFFFE,
875        0x12334578,
876        0x7FFFFFFF,
877        0x7FFFFFFE,
878        0x80000000,
879        0xFFFFFFFF
880    })
881    Name (P01A, Package (0x06)
882    {
883        0x00,
884        0xFFFFFFFFFFFFFFFF,
885        0x1233457966887700,
886        0x8000000000000000,
887        0x7FFFFFFFFFFFFFFF,
888        0x8000000000000001
889    })
890    Name (P01B, Package (0x06)
891    {
892        0xFFFFFFFFFFFFFFFF,
893        0xFFFFFFFFFFFFFFFE,
894        0x12334579668876FF,
895        0x7FFFFFFFFFFFFFFF,
896        0x7FFFFFFFFFFFFFFE,
897        0x8000000000000000
898    })
899    Method (DCR0, 0, Serialized)
900    {
901        Debug = "TEST: DCR0, Decrement an Integer"
902        If ((F64 == 0x01))
903        {
904            M002 (__METHOD__, 0x05, "p018", P018, P019, 0x01)
905            M002 (__METHOD__, 0x06, "p01a", P01A, P01B, 0x01)
906        }
907        Else
908        {
909            M002 (__METHOD__, 0x06, "p018", P018, P019, 0x01)
910        }
911    }
912
913    /* ===================================== And */
914
915    Name (P01C, Package (0x0A)
916    {
917        0x00,
918        0x00,
919        0xFFFFFFFF,
920        0xF0F0F0F0,
921        0x0F0F0F0F,
922        0x00,
923        0x00,
924        0x10101010,
925        0x01010101,
926        0x80214120
927    })
928    Name (P01D, Package (0x0A)
929    {
930        0x00,
931        0x00,
932        0xFFFFFFFFFFFFFFFF,
933        0xF0F0F0F0F0F0F0F0,
934        0x0F0F0F0F0F0F0F0F,
935        0x00,
936        0x00,
937        0x1010101010101010,
938        0x0101010101010101,
939        0x8021420011118822
940    })
941    Method (AND0, 0, Serialized)
942    {
943        Debug = "TEST: AND0, Integer Bitwise And"
944        If ((F64 == 0x01))
945        {
946            M000 (__METHOD__, C000, "p030", P030, P01C, 0x03)
947            M000 (__METHOD__, C000, "p031", P031, P01D, 0x03)
948        }
949        Else
950        {
951            M000 (__METHOD__, C000, "p030", P030, P01C, 0x03)
952        }
953    }
954
955    /* ===================================== Nand */
956
957    Name (P01E, Package (0x02)
958    {
959        0x9A3353AC,
960        0x39A966CA
961    })
962    Name (P01F, Package (0x01)
963    {
964        0xE7DEBD77
965    })
966    Name (P020, Package (0x01)
967    {
968        0xFFFFFFFFE7DEBD77
969    })
970    Name (P021, Package (0x02)
971    {
972        0x9A3353AC395C9353,
973        0x39A966CAA36A3A66
974    })
975    Name (P022, Package (0x01)
976    {
977        0xE7DEBD77DEB7EDBD
978    })
979    Name (P023, Package (0x0A)
980    {
981        0xFFFFFFFF,
982        0xFFFFFFFF,
983        0x00,
984        0x0F0F0F0F,
985        0xF0F0F0F0,
986        0xFFFFFFFF,
987        0xFFFFFFFF,
988        0xEFEFEFEF,
989        0xFEFEFEFE,
990        0x7FDEBEDF
991    })
992    Name (P024, Package (0x0A)
993    {
994        0xFFFFFFFFFFFFFFFF,
995        0xFFFFFFFFFFFFFFFF,
996        0xFFFFFFFF00000000,
997        0xFFFFFFFF0F0F0F0F,
998        0xFFFFFFFFF0F0F0F0,
999        0xFFFFFFFFFFFFFFFF,
1000        0xFFFFFFFFFFFFFFFF,
1001        0xFFFFFFFFEFEFEFEF,
1002        0xFFFFFFFFFEFEFEFE,
1003        0xFFFFFFFF7FDEBEDF
1004    })
1005    Name (P025, Package (0x0A)
1006    {
1007        0xFFFFFFFFFFFFFFFF,
1008        0xFFFFFFFFFFFFFFFF,
1009        0x00,
1010        0x0F0F0F0F0F0F0F0F,
1011        0xF0F0F0F0F0F0F0F0,
1012        0xFFFFFFFFFFFFFFFF,
1013        0xFFFFFFFFFFFFFFFF,
1014        0xEFEFEFEFEFEFEFEF,
1015        0xFEFEFEFEFEFEFEFE,
1016        0x7FDEBDFFEEEE77DD
1017    })
1018    Method (NAN0, 0, Serialized)
1019    {
1020        Debug = "TEST: NAN0, Integer Bitwise Nand"
1021        If ((F64 == 0x01))
1022        {
1023            M000 (__METHOD__, 0x01, "p01e", P01E, P020, 0x04)
1024            M000 (__METHOD__, 0x01, "p021", P021, P022, 0x04)
1025            M000 (__METHOD__, C000, "p030", P030, P024, 0x04)
1026            M000 (__METHOD__, C000, "p031", P031, P025, 0x04)
1027        }
1028        Else
1029        {
1030            M000 (__METHOD__, 0x01, "p01e", P01E, P01F, 0x04)
1031            M000 (__METHOD__, C000, "p030", P030, P023, 0x04)
1032        }
1033    }
1034
1035    /* ===================================== Nor */
1036
1037    Name (P026, Package (0x02)
1038    {
1039        0x9A3353AC,
1040        0x39A966CA
1041    })
1042    Name (P027, Package (0x01)
1043    {
1044        0x44448811
1045    })
1046    Name (P028, Package (0x01)
1047    {
1048        0xFFFFFFFF44448811
1049    })
1050    Name (P029, Package (0x02)
1051    {
1052        0x9A3353AC993CA39C,
1053        0x39A966CA3356A5C9
1054    })
1055    Name (P02A, Package (0x01)
1056    {
1057        0x4444881144815822
1058    })
1059    Name (P02B, Package (0x0A)
1060    {
1061        0xFFFFFFFF,
1062        0x00,
1063        0x00,
1064        0x00,
1065        0x00,
1066        0x0F0F0F0F,
1067        0xF0F0F0F0,
1068        0x0E0E0E0E,
1069        0xE0E0E0E0,
1070        0x68103000
1071    })
1072    Name (P02C, Package (0x0A)
1073    {
1074        0xFFFFFFFFFFFFFFFF,
1075        0xFFFFFFFF00000000,
1076        0xFFFFFFFF00000000,
1077        0xFFFFFFFF00000000,
1078        0xFFFFFFFF00000000,
1079        0xFFFFFFFF0F0F0F0F,
1080        0xFFFFFFFFF0F0F0F0,
1081        0xFFFFFFFF0E0E0E0E,
1082        0xFFFFFFFFE0E0E0E0,
1083        0xFFFFFFFF68103000
1084    })
1085    Name (P02D, Package (0x0A)
1086    {
1087        0xFFFFFFFFFFFFFFFF,
1088        0x00,
1089        0x00,
1090        0x00,
1091        0x00,
1092        0x0F0F0F0F0F0F0F0F,
1093        0xF0F0F0F0F0F0F0F0,
1094        0x0E0E0E0E0E0E0E0E,
1095        0xE0E0E0E0E0E0E0E0,
1096        0x6810985600663201
1097    })
1098    Method (NOR0, 0, Serialized)
1099    {
1100        Debug = "TEST: NOR0, Integer Bitwise Nor"
1101        If ((F64 == 0x01))
1102        {
1103            M000 (__METHOD__, 0x01, "p026", P026, P028, 0x05)
1104            M000 (__METHOD__, 0x01, "p029", P029, P02A, 0x05)
1105            M000 (__METHOD__, C000, "p030", P030, P02C, 0x05)
1106            M000 (__METHOD__, C000, "p031", P031, P02D, 0x05)
1107        }
1108        Else
1109        {
1110            M000 (__METHOD__, 0x01, "p026", P026, P027, 0x05)
1111            M000 (__METHOD__, C000, "p030", P030, P02B, 0x05)
1112        }
1113    }
1114
1115    /* ===================================== Not */
1116
1117    Name (P02E, Package (0x05)
1118    {
1119        0xFFFFFFFF,
1120        0x00,
1121        0x0F0F0F0F,
1122        0xF0F0F0F0,
1123        0xEDCBA987
1124    })
1125    Name (P02F, Package (0x05)
1126    {
1127        0xFFFFFFFFFFFFFFFF,
1128        0xFFFFFFFF00000000,
1129        0xFFFFFFFF0F0F0F0F,
1130        0xFFFFFFFFF0F0F0F0,
1131        0xFFFFFFFFEDCBA987
1132    })
1133    Name (P040, Package (0x05)
1134    {
1135        0xFFFFFFFFFFFFFFFF,
1136        0x00,
1137        0x0F0F0F0F0F0F0F0F,
1138        0xF0F0F0F0F0F0F0F0,
1139        0xEDCBA987F5064312
1140    })
1141    Method (NOT0, 0, Serialized)
1142    {
1143        Debug = "TEST: NOT0, Integer Bitwise Not"
1144        If ((F64 == 0x01))
1145        {
1146            M002 (__METHOD__, C001, "p032", P032, P02F, 0x02)
1147            M002 (__METHOD__, C001, "p033", P033, P040, 0x02)
1148        }
1149        Else
1150        {
1151            M002 (__METHOD__, C001, "p032", P032, P02E, 0x02)
1152        }
1153    }
1154
1155    /* ===================================== Or */
1156
1157    Name (P041, Package (0x02)
1158    {
1159        0x9A3353AC,
1160        0x39A966CA
1161    })
1162    Name (P042, Package (0x01)
1163    {
1164        0xBBBB77EE
1165    })
1166    Name (P043, Package (0x02)
1167    {
1168        0x9A3353AC99A3DCEB,
1169        0x39A966CA12887634
1170    })
1171    Name (P044, Package (0x01)
1172    {
1173        0xBBBB77EE9BABFEFF
1174    })
1175    Name (P045, Package (0x0A)
1176    {
1177        0x00,
1178        0xFFFFFFFF,
1179        0xFFFFFFFF,
1180        0xFFFFFFFF,
1181        0xFFFFFFFF,
1182        0xF0F0F0F0,
1183        0x0F0F0F0F,
1184        0xF1F1F1F1,
1185        0x1F1F1F1F,
1186        0x97EFCFFF
1187    })
1188    Name (P046, Package (0x0A)
1189    {
1190        0x00,
1191        0xFFFFFFFFFFFFFFFF,
1192        0xFFFFFFFFFFFFFFFF,
1193        0xFFFFFFFFFFFFFFFF,
1194        0xFFFFFFFFFFFFFFFF,
1195        0xF0F0F0F0F0F0F0F0,
1196        0x0F0F0F0F0F0F0F0F,
1197        0xF1F1F1F1F1F1F1F1,
1198        0x1F1F1F1F1F1F1F1F,
1199        0x97EF67A9FF99CDFE
1200    })
1201    Method (OR00, 0, Serialized)
1202    {
1203        Debug = "TEST: OR00, Integer Bitwise Or"
1204        If ((F64 == 0x01))
1205        {
1206            M000 (__METHOD__, 0x01, "p041", P041, P042, 0x06)
1207            M000 (__METHOD__, 0x01, "p043", P043, P044, 0x06)
1208            M000 (__METHOD__, C000, "p030", P030, P045, 0x06)
1209            M000 (__METHOD__, C000, "p031", P031, P046, 0x06)
1210        }
1211        Else
1212        {
1213            M000 (__METHOD__, 0x01, "p041", P041, P042, 0x06)
1214            M000 (__METHOD__, C000, "p030", P030, P045, 0x06)
1215        }
1216    }
1217
1218    /* ===================================== Xor */
1219
1220    Name (P047, Package (0x02)
1221    {
1222        0x9A3653AC,
1223        0x39A966CA
1224    })
1225    Name (P048, Package (0x01)
1226    {
1227        0xA39F3566
1228    })
1229    Name (P049, Package (0x02)
1230    {
1231        0x9A3653AC19283745,
1232        0x39A966CABBAAEF45
1233    })
1234    Name (P04A, Package (0x01)
1235    {
1236        0xA39F3566A282D800
1237    })
1238    Name (P04B, Package (0x0A)
1239    {
1240        0x00,
1241        0xFFFFFFFF,
1242        0x00,
1243        0x0F0F0F0F,
1244        0xF0F0F0F0,
1245        0xF0F0F0F0,
1246        0x0F0F0F0F,
1247        0xE1E1E1E1,
1248        0x1E1E1E1E,
1249        0x17CE8EDF
1250    })
1251    Name (P04C, Package (0x0A)
1252    {
1253        0x00,
1254        0xFFFFFFFFFFFFFFFF,
1255        0x00,
1256        0x0F0F0F0F0F0F0F0F,
1257        0xF0F0F0F0F0F0F0F0,
1258        0xF0F0F0F0F0F0F0F0,
1259        0x0F0F0F0F0F0F0F0F,
1260        0xE1E1E1E1E1E1E1E1,
1261        0x1E1E1E1E1E1E1E1E,
1262        0x17CE25A9EE8845DC
1263    })
1264    Name (P04D, Package (0x0A)
1265    {
1266        0x00,
1267        0xFFFFFFFF,
1268        0x00,
1269        0x0F0F0F0F,
1270        0xF0F0F0F0,
1271        0xF0F0F0F0,
1272        0x0F0F0F0F,
1273        0xE1E1E1E1,
1274        0x1E1E1E1E,
1275        0x17CE8EDF
1276    })
1277    Method (XOR0, 0, Serialized)
1278    {
1279        Debug = "TEST: XOR0, Integer Bitwise Xor"
1280        If ((F64 == 0x01))
1281        {
1282            M000 (__METHOD__, 0x01, "p047", P047, P048, 0x07)
1283            M000 (__METHOD__, 0x01, "p049", P049, P04A, 0x07)
1284            M000 (__METHOD__, C000, "p030", P030, P04B, 0x07)
1285            M000 (__METHOD__, 0x01, "p031", P031, P04C, 0x07)
1286            M000 (__METHOD__, C000, "p031", P031, P04C, 0x07)
1287        }
1288        Else
1289        {
1290            M000 (__METHOD__, 0x01, "p047", P047, P048, 0x07)
1291            M000 (__METHOD__, C000, "p030", P030, P04D, 0x07)
1292        }
1293    }
1294
1295    /* ===================================== Mod */
1296
1297    Name (P04E, Package (0x08)
1298    {
1299        /* remainder */
1300
1301        0x0678,
1302        0x003FFFFF,
1303        0x78123456,
1304        0x00,
1305        0x00,
1306        0x0022CD7A,
1307        0x00,
1308        0x7FFFFFFF
1309    })
1310    Name (P04F, Package (0x08)
1311    {
1312        /* remainder */
1313
1314        0x0344,
1315        0x3FFFFFFFFFFFFFFF,
1316        0x7812345699887766,
1317        0x00,
1318        0x00,
1319        0x0111412A4033D841,
1320        0x00,
1321        0x7FFFFFFFFFFFFFFF
1322    })
1323    Method (MOD0, 0, Serialized)
1324    {
1325        Debug = "TEST: MOD0, Integer Modulo"
1326        If ((F64 == 0x01))
1327        {
1328            M000 (__METHOD__, 0x08, "p00c", P00C, P04E, 0x08)
1329            M000 (__METHOD__, 0x08, "p00e", P00E, P04F, 0x08)
1330        }
1331        Else
1332        {
1333            M000 (__METHOD__, 0x08, "p00c", P00C, P04E, 0x08)
1334        }
1335    }
1336
1337    /* ===================================== ShiftLeft */
1338
1339    Name (P050, Package (0x34)
1340    {
1341        0x00,
1342        0x00,
1343        0x00,
1344        0x01,
1345        0x00,
1346        0x11,
1347        0x00,
1348        0x1F,
1349        0x00,
1350        0x20,
1351        0x00,
1352        0x21,
1353        0x00,
1354        0x40,
1355        0x00,
1356        0x41,
1357        0xFFFFFFFF,
1358        0x00,
1359        0xFFFFFFFF,
1360        0x01,
1361        0xFFFFFFFF,
1362        0x0E,
1363        0xFFFFFFFF,
1364        0x1F,
1365        0xFFFFFFFF,
1366        0x20,
1367        0xFFFFFFFF,
1368        0x21,
1369        0xFFFFFFFF,
1370        0x40,
1371        0xFFFFFFFF,
1372        0x41,
1373        0xF0F0F0F0,
1374        0x00,
1375        0xF0F0F0F0,
1376        0x01,
1377        0xF0F0F0F0,
1378        0x11,
1379        0xF0F0F0F0,
1380        0x1F,
1381        0xF0F0F0F0,
1382        0x20,
1383        0x87654321,
1384        0x00,
1385        0x87654321,
1386        0x01,
1387        0x87654321,
1388        0x11,
1389        0x87654321,
1390        0x1F,
1391        0x87654321,
1392        0x20
1393    })
1394    Name (P051, Package (0x1A)
1395    {
1396        0x00,
1397        0x00,
1398        0x00,
1399        0x00,
1400        0x00,
1401        0x00,
1402        0x00,
1403        0x00,
1404        0xFFFFFFFF,
1405        0xFFFFFFFE,
1406        0xFFFFC000,
1407        0x80000000,
1408        0x00,
1409        0x00,
1410        0x00,
1411        0x00,
1412        0xF0F0F0F0,
1413        0xE1E1E1E0,
1414        0xE1E00000,
1415        0x00,
1416        0x00,
1417        0x87654321,
1418        0x0ECA8642,
1419        0x86420000,
1420        0x80000000,
1421        0x00
1422    })
1423    Name (P052, Package (0x1A)
1424    {
1425        0x00,
1426        0x00,
1427        0x00,
1428        0x00,
1429        0x00,
1430        0x00,
1431        0x00,
1432        0x00,
1433        0xFFFFFFFF,
1434        0x00000001FFFFFFFE,
1435        0x00003FFFFFFFC000,
1436        0x7FFFFFFF80000000,
1437        0xFFFFFFFF00000000,
1438        0xFFFFFFFE00000000,
1439        0x00,
1440        0x00,
1441        0xF0F0F0F0,
1442        0x00000001E1E1E1E0,
1443        0x0001E1E1E1E00000,
1444        0x7878787800000000,
1445        0xF0F0F0F000000000,
1446        0x87654321,
1447        0x000000010ECA8642,
1448        0x00010ECA86420000,
1449        0x43B2A19080000000,
1450        0x8765432100000000
1451    })
1452    Name (P053, Package (0x14)
1453    {
1454        0xFFFFFFFFFFFFFFFF,
1455        0x00,
1456        0xFFFFFFFFFFFFFFFF,
1457        0x01,
1458        0xFFFFFFFFFFFFFFFF,
1459        0x11,
1460        0xFFFFFFFFFFFFFFFF,
1461        0x31,
1462        0xFFFFFFFFFFFFFFFF,
1463        0x40,
1464        0xFFFFFFFFFFFFFFFF,
1465        0x41,
1466        0xF0F0F0F0F0F0F0F0,
1467        0x0F,
1468        0xF0F0F0F0F0F0F0F0,
1469        0x23,
1470        0x87654321BCDEF098,
1471        0x0B,
1472        0x87654321BCDEF098,
1473        0x32
1474    })
1475    Name (P054, Package (0x0A)
1476    {
1477        0xFFFFFFFFFFFFFFFF,
1478        0xFFFFFFFFFFFFFFFE,
1479        0xFFFFFFFFFFFE0000,
1480        0xFFFE000000000000,
1481        0x00,
1482        0x00,
1483        0x7878787878780000,
1484        0x8787878000000000,
1485        0x2A190DE6F784C000,
1486        0xC260000000000000
1487    })
1488    Method (SHL0, 0, Serialized)
1489    {
1490        Debug = "TEST: SHL0, Integer shift value left"
1491        If ((F64 == 0x01))
1492        {
1493            M000 (__METHOD__, 0x1A, "p050", P050, P052, 0x09)
1494            M000 (__METHOD__, 0x0A, "p053", P053, P054, 0x09)
1495        }
1496        Else
1497        {
1498            M000 (__METHOD__, 0x1A, "p050", P050, P051, 0x09)
1499        }
1500    }
1501
1502    /* ===================================== ShiftRight */
1503
1504    Name (P055, Package (0x1A)
1505    {
1506        0x00,
1507        0x00,
1508        0x00,
1509        0x00,
1510        0x00,
1511        0x00,
1512        0x00,
1513        0x00,
1514        0xFFFFFFFF,
1515        0x7FFFFFFF,
1516        0x0003FFFF,
1517        0x01,
1518        0x00,
1519        0x00,
1520        0x00,
1521        0x00,
1522        0xF0F0F0F0,
1523        0x78787878,
1524        0x7878,
1525        0x01,
1526        0x00,
1527        0x87654321,
1528        0x43B2A190,
1529        0x43B2,
1530        0x01,
1531        0x00
1532    })
1533    Name (P056, Package (0x0A)
1534    {
1535        0xFFFFFFFFFFFFFFFF,
1536        0x7FFFFFFFFFFFFFFF,
1537        0x00007FFFFFFFFFFF,
1538        0x7FFF,
1539        0x00,
1540        0x00,
1541        0x0001E1E1E1E1E1E1,
1542        0x1E1E1E1E,
1543        0x0010ECA864379BDE,
1544        0x21D9
1545    })
1546    Method (SHR0, 0, Serialized)
1547    {
1548        Debug = "TEST: SHR0, Integer shift value right"
1549        If ((F64 == 0x01))
1550        {
1551            M000 (__METHOD__, 0x1A, "p050", P050, P055, 0x0A)
1552            M000 (__METHOD__, 0x0A, "p053", P053, P056, 0x0A)
1553        }
1554        Else
1555        {
1556            M000 (__METHOD__, 0x1A, "p050", P050, P055, 0x0A)
1557        }
1558    }
1559
1560    /* ===================================== FindSetLeftBit */
1561
1562    Name (P057, Package (0x06)
1563    {
1564        0x00,
1565        0xFFFFFFFF,
1566        0x80000000,
1567        0x01,
1568        0x02A0FD40,
1569        0x0456F200
1570    })
1571    Name (P058, Package (0x06)
1572    {
1573        0x00,
1574        0x20,
1575        0x20,
1576        0x01,
1577        0x1A,
1578        0x1B
1579    })
1580    Name (P059, Package (0x06)
1581    {
1582        0x00,
1583        0xFFFFFFFFFFFFFFFF,
1584        0x8000000000000000,
1585        0x01,
1586        0x02A0FD4119FD0560,
1587        0x0456F2007CED8400
1588    })
1589    Name (P05A, Package (0x06)
1590    {
1591        0x00,
1592        0x40,
1593        0x40,
1594        0x01,
1595        0x3A,
1596        0x3B
1597    })
1598    Method (FSL0, 0, Serialized)
1599    {
1600        Debug = "TEST: FSL0, Index of first least significant bit set"
1601        If ((F64 == 0x01))
1602        {
1603            M002 (__METHOD__, 0x06, "p057", P057, P058, 0x03)
1604            M002 (__METHOD__, 0x06, "p059", P059, P05A, 0x03)
1605        }
1606        Else
1607        {
1608            M002 (__METHOD__, 0x06, "p057", P057, P058, 0x03)
1609        }
1610
1611        If ((F64 == 0x01))
1612        {
1613            Local0 = 0x40
1614        }
1615        Else
1616        {
1617            Local0 = 0x20
1618        }
1619
1620        Local1 = 0x00
1621        Local5 = 0x00
1622        While (Local0)
1623        {
1624            If ((Local1 == 0x00))
1625            {
1626                Local2 = 0x01
1627            }
1628            Else
1629            {
1630                Local2 = (0x03 << Local5)
1631                Local5++
1632            }
1633
1634            FindSetLeftBit (Local2, Local3)
1635            Local4 = (Local1 + 0x01)
1636            If ((Local3 != Local4))
1637            {
1638                ERR (__METHOD__, Z083, __LINE__, 0x00, 0x00, Local0, 0x00)
1639            }
1640
1641            Local1++
1642            Local0--
1643        }
1644    }
1645
1646    /* ===================================== FindSetRightBit */
1647
1648    Name (P05B, Package (0x06)
1649    {
1650        0x00,
1651        0x01,
1652        0x20,
1653        0x01,
1654        0x07,
1655        0x0A
1656    })
1657    Name (P05C, Package (0x06)
1658    {
1659        0x00,
1660        0x01,
1661        0x40,
1662        0x01,
1663        0x06,
1664        0x0B
1665    })
1666    Method (FSR0, 0, Serialized)
1667    {
1668        Debug = "TEST: FSR0, Index of first most significant bit set"
1669        If ((F64 == 0x01))
1670        {
1671            M002 (__METHOD__, 0x06, "p057", P057, P05B, 0x04)
1672            M002 (__METHOD__, 0x06, "p059", P059, P05C, 0x04)
1673        }
1674        Else
1675        {
1676            M002 (__METHOD__, 0x06, "p057", P057, P05B, 0x04)
1677        }
1678
1679        If ((F64 == 0x01))
1680        {
1681            Local0 = 0x40
1682        }
1683        Else
1684        {
1685            Local0 = 0x20
1686        }
1687
1688        Local1 = 0x00
1689        Local5 = 0x00
1690        While (Local0)
1691        {
1692            If ((Local1 == 0x00))
1693            {
1694                Local2 = 0x01
1695                Local4 = 0x01
1696            }
1697            Else
1698            {
1699                Local2 = (0x03 << Local5)
1700                Local4 = Local1
1701                Local5++
1702            }
1703
1704            FindSetRightBit (Local2, Local3)
1705            If ((Local3 != Local4))
1706            {
1707                ERR (__METHOD__, Z083, __LINE__, 0x00, 0x00, Local0, 0x00)
1708            }
1709
1710            Local1++
1711            Local0--
1712        }
1713    }
1714