diff -urN test4.official/Documentation/Configure.help test4.official.kdb/Documentation/Configure.help --- test4.official/Documentation/Configure.help Thu Jul 13 09:42:51 2000 +++ test4.official.kdb/Documentation/Configure.help Fri Aug 11 11:25:45 2000 @@ -14001,6 +14001,19 @@ keys are documented in Documentation/sysrq.txt. Don't say Y unless you really know what this hack does. +Kernel Debugging support +CONFIG_KDB + This option provides a built-in kernel debugger. The built-in + kernel debugger contains commands which allow memory to be examined, + instructions to be disassembled and breakpoints to be set. + +Kernel Debugging backtrace framepointer support +CONFIG_KDB_FRAMEPTR + This option causes the system to use the frame pointer as a + real frame pointer rather than as a general purpose register. Set + this option to get accurate stack tracebacks when using the + built-in kernel debugger. + ISDN subsystem CONFIG_ISDN ISDN ("Integrated Services Digital Networks", called RNIS in France) diff -urN test4.official/Documentation/kdb/kdb.mm test4.official.kdb/Documentation/kdb/kdb.mm --- test4.official/Documentation/kdb/kdb.mm Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/Documentation/kdb/kdb.mm Fri Aug 11 11:25:45 2000 @@ -0,0 +1,98 @@ +.ND "March 10, 1999" +.TL +Built-in Kernel Debugger for Linux +.AU "Scott Lurndal" SL 8U500 OS 33158 +.AT "Member Technical Staff" +.AF "Silicon Graphics, Inc." +.MT 2 +.AS +These programmer notes describe the built-in kernel debugger +for linux. +.AE +.H 1 "Overview" +This document describes the built-in kernel debugger available +for linux. This debugger allows the programmer to interactivly +examine kernel memory, disassemble kernel functions, set breakpoints +in the kernel code and display and modify register contents. +.P +A symbol table is included in the kernel image which enables all +symbols with global scope (including static symbols) to be used +as arguments to the kernel debugger commands. +.H 1 "Getting Started" +To include the kernel debugger in a linux kernel, use a +configuration mechanism (e.g. xconfig, menuconfig, et. al.) +to enable the \fBCONFIG_KDB\fP option. Additionally, for accurate +stack tracebacks, it is recommended that the \fBCONFIG_KDB_FRAMEPTR\fP +option be enabled. \fBCONFIG_KDB_FRAMEPTR\fP changes the compiler +flags so that the frame pointer register will be used as a frame +pointer rather than a general purpose register. +.P +After linux has been configured to include the kernel debugger, +make a new kernel with the new configuration file (a make clean +is recommended before making the kernel), and install the kernel +as normal. +.P +When booting the new kernel using \fIlilo\fP(1), the 'kdb' flag +may be added after the image name on the \fBLILO\fP boot line to +force the kernel to stop in the kernel debugger early in the +kernel initialization process. If the kdb flag isn't provided, +then kdb will automatically be invoked upon system panic or +when the +\fBPAUSE\fP +key is used from the keyboard. +.P +Kdb can also be used via the serial port. Set up the system to +have a serial console (see \fIDocumentation/serial-console.txt\fP). +The \fBControl-A\fP key sequence on the serial port will cause the +kernel debugger to be entered with input from the serial port and +output to the serial console. +.H 2 "Basic Commands" +There are several categories of commands available to the +kernel debugger user including commands providing memory +display and modification, register display and modification, +instruction disassemble, breakpoints and stack tracebacks. +.P +The following table shows the currently implemented commands: +.DS +.TS +box, center; +l | l +l | l. +Command Description +_ +bc Clear Breakpoint +bd Disable Breakpoint +be Enable Breakpoint +bl Display breakpoints +bp Set or Display breakpoint +bpa Set or Display breakpoint globally +cpu Switch cpus +env Show environment +go Restart execution +help Display help message +id Disassemble Instructions +ll Follow Linked Lists +md Display memory contents +mds Display memory contents symbolically +mm Modify memory contents +reboot Reboot the machine +rd Display register contents +rm Modify register contents +set Add/change environment variable +.TE +.DE +.P +Further information on the above commands can be found in +the appropriate manual pages. Some commands can be abbreviated, such +commands are indicated by a non-zero \fIminlen\fP parameter to +\fBkdb_register\fP; the value of \fIminlen\fP being the minimum length +to which the command can be abbreviated (for example, the \fBgo\fP +command can be abbreviated legally to \fBg\fP). +.P +If an input string does not match a command in the command table, +it is treated as an address expression and the corresponding address +value and nearest symbol are shown. +.H 1 Writing new commands +.H 2 Writing a built-in command +.H 2 Writing a modular command + diff -urN test4.official/Documentation/kdb/kdb_bp.man test4.official.kdb/Documentation/kdb/kdb_bp.man --- test4.official/Documentation/kdb/kdb_bp.man Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/Documentation/kdb/kdb_bp.man Fri Aug 11 11:25:45 2000 @@ -0,0 +1,132 @@ +.TH BD 1 "09 March 1999" +.SH NAME +bc, bd, be, bl, bp, bpa \- breakpoint commands +.SH SYNOPSIS +bp \fIaddress-expression\fP [\f(CWDATAR|DATAW|IO\fP [\fIlength\fP]] +.LP +bpa \fIaddress-expression\fP [\f(CWDATAR|DATAW|IO\fP [\fIlength\fP]] +.LP +bd \fIbreakpoint-number\fP +.LP +bc \fIbreakpoint-number\fP +.LP +be \fIbreakpoint-number\fP +.LP +bl +.SH DESCRIPTION +The +.B bp +command is used to establish a breakpoint. +The \fIaddress-expression\fP may be a numeric value (decimal or +hexidecimal), a symbol name, a register name preceeded by a +percent symbol '%', or a simple expression consisting of a +symbol name, an addition or subtraction character and a numeric +value (decimal or hexidecimal). +.P +The \fIaddress-expression\fP may also consist of a single +asterisk '*' symbol which indicates that the command should +operate on all existing breakpoints (valid only for \fBbc\fP, +\fBbd\fP and \fBbe\fP). +.P +Three different types of +breakpoints may be set: + +.TP 8 +Instruction +Causes the kernel debugger to be invoked from the debug exception +path when an instruction is fetched from the specified address. This +is the default if no other type of breakpoint is requested. + +.TP 8 +DATAR +Causes the kernel debugger to be entered when data of length +\fIlength\fP is read from or written to the specified address. +This type of breakpoint must use a processor debug register +thus placing a limit of four on the number of data and I/O +breakpoints that may be established. + +.TP 8 +DATAW +Enters the kernel debugger when data of length \fIlength\fP +is written to the specified address. \fIlength\fP defaults +to four bytes if it is not explicitly specified. Note that the +processor will have already overwritten the prior data at the +breakpoint location before the kernel debugger is invoked. The +prior data should be saved before establishing the +breakpoint, if required. + +.TP 8 +IO +Enters the kernel debugger when an \fBin\fP or \fBout\fP instruction +targets the specified I/O address. + +.P +The +.B bpa +command will establish a breakpoint on all processors in an +SMP system. This command is not available in an uniprocessor +kernel. +.P +The +.B bd +command will disable a breakpoint without removing it from +the kernel debuggers breakpoint table. This can be used to +keep more than 4 breakpoints in the breakpoint table without +exceeding the processor breakpoint register count. +.P +The +.B be +command will re-enable a disabled breakpoint. +.P +The +.B bc +command will clear a breakpoint from the breakpoint table. +.P +The +.B bl +command will list the existing set of breakpoints. +.SH LIMITATIONS +Currently the kernel debugger does not use the int 03 method +of establishing instruction breakpoints, so there may only be +four active instruction and data breakpoints at any given time. +.P +There is a compile time limit of sixteen entries in the +breakpoint table at any one time. +.SH ENVIRONMENT +The breakpoint subsystem does not currently use any environment +variables. +.SH SMP CONSIDERATIONS +Breakpoints which use the processor breakpoint registers +are only established on the processor which is +currently active. If you wish breakpoints to be universal +use the 'bpa' command. +.SH EXAMPLES +.TP 8 +bp schedule +Sets an instruction breakpoint at the begining of the +function \fBschedule\fP. + +.TP 8 +bp schedule+0x12e +Sets an instruction breakpoint at the instruction located +at \fBschedule\fP+\fI0x12e\fP. + +.TP 8 +bp ttybuffer+0x24 dataw +Sets a data write breakpoint at the location referenced by +\fBttybuffer\fP+\fI0x24\fP for a length of four bytes. + +.TP 8 +bp 0xc0254010 datar 1 +Establishes a data reference breakpoint at address \fB0xc0254010\fP +for a length of one byte. + +.TP 8 +bp +List current breakpoint table. + +.TP 8 +bd 0 +Disable breakpoint #0. + + diff -urN test4.official/Documentation/kdb/kdb_bt.man test4.official.kdb/Documentation/kdb/kdb_bt.man --- test4.official/Documentation/kdb/kdb_bt.man Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/Documentation/kdb/kdb_bt.man Fri Aug 11 11:25:45 2000 @@ -0,0 +1,68 @@ +.TH BT 1 "15 March 1999" +.SH NAME +bt \- Stack Traceback command +.SH SYNOPSIS +bt [ ] +.LP +btp +.SH DESCRIPTION +The +.B bt +command is used to print a stack traceback. It uses the +current registers (see \fBrd\fP command) to determine +the starting context and attempts to provide a complete +stack traceback for the active thread. If \fIstack-frame-address\fP +is supplied, it is assumed to point to the start of a valid +stack frame and the stack will be traced back from that +point (e.g. on i386 architecture, \fIstack-frame-address\fP +should be the stack address of a saved \fB%eip\fP value from a \fBcall\fP +instruction). +.P +A kernel configuration option \fBCONFIG_KDB_FRAMEPTR\fP should +be enabled so that the compiler will utilize the frame pointer +register properly to maintain a stack which can be correctly +analyzed. +.P +The \fBbt\fP command will attempt to analyze the stack without +frame pointers if the \fBCONFIG_KDB_FRAMEPTR\fP option is not +enabled, but the analysis is difficult and may not produce +accurate nor complete results. +.P +The \fBbtp\fP command will analyze the stack for the given +process identification (see the \fBps\fP command). +.SH LIMITATIONS +If the kernel is compiled without frame pointers, stack tracebacks +may be incomplete. The \fBmds %esp\fP command may be useful in +attemping to determine the actual stack traceback manually. +.P +The \fBbt\fP command may print more arguments for a function +than that function accepts; this happens when the C compiler +doesn't immediately pop the arguments off the stack upon return +from a called function. When this is this case, these extra +stack words will be considered additional arguments by the \fBbt\fP +command. +.SH ENVIRONMENT +The \fBBTARGS\fP environment variable governs the maximum number +of arguments that are printed for any single function. +.SH SMP CONSIDERATIONS +None. +.SH EXAMPLES +.nf +.na +.ft CW +[root@host /root]# cat /proc/partitions +Entering kdb on processor 0 due to Debug Exception @ 0xc01845e3 +Read/Write breakpoint #1 at 0xc024ddf4 +kdb> bt + EBP Caller Function(args) +0xc74f5f44 0xc0146166 get_partition_list(0xc74d8000) +0xc74f5f8c 0xc01463f3 get_root_array(0xc74d8000, 0x13, 0xc74f5f88, 0xf3, 0xc00) +0xc74f5fbc 0xc0126138 array_read(0xc76cd80, 0x804aef8, 0xc00, 0xc76cdf94) +0xbffffcd4 0xc0108b30 sys_read(0x3, 0x804aef8, 0x1000, 0x1000, 0x804aef8) +kdb> bp +Instruction Breakpoint #0 at 0xc0111ab8 (schedule) in dr0 is disabled on cpu 0 +Data Access Breakpoint #1 at 0xc024ddf4 (gendisk_head) in dr1 is enabled on cpu 0 +for 4 bytes +kdb> go +[root@host /root]# + diff -urN test4.official/Documentation/kdb/kdb_env.man test4.official.kdb/Documentation/kdb/kdb_env.man --- test4.official/Documentation/kdb/kdb_env.man Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/Documentation/kdb/kdb_env.man Fri Aug 11 11:25:45 2000 @@ -0,0 +1,47 @@ +.TH ENV 1 "09 March 1999" +.SH NAME +env, set \- Environment manipulation commands +.SH SYNOPSIS +env +.LP +set \fIenvironment-variable\fP=\fIvalue\fP +.SH DESCRIPTION +The kernel debugger contains an environment which contains a series +of name-value pairs. Some environment variables are known to the +various kernel debugger commands and have specific meaning to the +command; such are enumerated on the respective reference material. +.P +Arbitrary environment variables may be created and used with +many commands (those which require an \fIaddress-expression\fP). +.P +The +.B env +command is used to display the current environment. +.P +The +.B set +command is used to alter an existing environment variable or +establish a new environment variable. +.SH LIMITATIONS +There is a compile-time limit of 33 environment variables. +.P +There is a compile-time limit of 512 bytes (\fBKDB_ENVBUFSIZE\fP) +of heap space available for new environment variables and for +environment variables changed from their compile-time values. +.SH ENVIRONMENT +These commands explicitly manipulate the environment. +.SH SMP CONSIDERATIONS +None. +.SH FUTURE +Allow compile-time initialization of customized environment +settings. +.SH EXAMPLES +.TP 8 +env +Display current environment settings. + +.TP 8 +set IDCOUNT=100 +Set the number of lines to display for the \fBid\fP command +to the value \fI100\fP. + diff -urN test4.official/Documentation/kdb/kdb_ll.man test4.official.kdb/Documentation/kdb/kdb_ll.man --- test4.official/Documentation/kdb/kdb_ll.man Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/Documentation/kdb/kdb_ll.man Fri Aug 11 11:25:45 2000 @@ -0,0 +1,135 @@ +.TH LL 1 "19 April 1999" +.SH NAME +ll \- Linked List examination +.SH SYNOPSIS +ll +.SH DESCRIPTION +The +.B ll +command is used to execute a single command repetitively for +each element of a linked list. +.P +The command specified by will be executed with a single +argument, the address of the current element. +.SH LIMITATIONS +Be careful if using this command recursively. +.SH ENVIRONMENT +None. +.SH SMP CONSIDERATIONS +None. +.SH EXAMPLES +.nf +.na +.ft CW +# cd modules +# insmod kdbm_vm.o +# Entering kdb on processor 0 due to PAUSE +kdb> ps +Task Addr Pid Parent cpu lcpu Tss Command +0xc03de000 0000000001 0000000000 0000 0000 0xc03de2d4 init +0xc0090000 0000000002 0000000001 0000 0000 0xc00902d4 kflushd +0xc000e000 0000000003 0000000001 0000 0000 0xc000e2d4 kpiod +0xc000c000 0000000004 0000000001 0000 0000 0xc000c2d4 kswapd +0xc7de2000 0000000056 0000000001 0000 0000 0xc7de22d4 kerneld +0xc7d3a000 0000000179 0000000001 0000 0000 0xc7d3a2d4 syslogd +0xc7a7e000 0000000188 0000000001 0000 0000 0xc7a7e2d4 klogd +0xc7a04000 0000000199 0000000001 0000 0000 0xc7a042d4 atd +0xc7b84000 0000000210 0000000001 0000 0000 0xc7b842d4 crond +0xc79d6000 0000000221 0000000001 0000 0000 0xc79d62d4 portmap +0xc798e000 0000000232 0000000001 0000 0000 0xc798e2d4 snmpd +0xc7904000 0000000244 0000000001 0000 0000 0xc79042d4 inetd +0xc78fc000 0000000255 0000000001 0000 0000 0xc78fc2d4 lpd +0xc77ec000 0000000270 0000000001 0000 0000 0xc77ec2d4 sendmail +0xc77b8000 0000000282 0000000001 0000 0000 0xc77b82d4 gpm +0xc7716000 0000000300 0000000001 0000 0000 0xc77162d4 smbd +0xc7ee2000 0000000322 0000000001 0000 0000 0xc7ee22d4 mingetty +0xc7d6e000 0000000323 0000000001 0000 0000 0xc7d6e2d4 login +0xc778c000 0000000324 0000000001 0000 0000 0xc778c2d4 mingetty +0xc78b6000 0000000325 0000000001 0000 0000 0xc78b62d4 mingetty +0xc77e8000 0000000326 0000000001 0000 0000 0xc77e82d4 mingetty +0xc7708000 0000000327 0000000001 0000 0000 0xc77082d4 mingetty +0xc770e000 0000000328 0000000001 0000 0000 0xc770e2d4 mingetty +0xc76b0000 0000000330 0000000001 0000 0000 0xc76b02d4 update +0xc7592000 0000000331 0000000323 0000 0000 0xc75922d4 ksh +0xc7546000 0000000338 0000000331 0000 0000 0xc75462d4 su +0xc74dc000 0000000339 0000000338 0000 0000 0xc74dc2d4 ksh +kdb> md 0xc74dc2d4 +c74dc2d4: 00000000 c74de000 00000018 00000000 .....`MG........ +c74dc2e4: 00000000 00000000 00000000 074de000 .............`M. +c74dc2f4: c01123ff 00000000 00000000 00000000 #.@............ +c74dc304: 00000000 00000000 c74dded0 00000000 ........P^MG.... +[omitted] +c74dc474: 00000000 00000000 00000000 00000000 ................ +c74dc484: 00000000 c7c15d00 c77b0900 c026fbe0 .....]AG..{G`{&@ +c74dc494: 00000000 c76c2000 00000000 00000000 ..... lG........ +c74dc4a4: 00000000 00000000 00000000 c74dc4ac ............,DMG +kdb> md 0xc026fbe0 +c026fbe0: c0262b60 00000000 c7594940 c74de000 @HYG....@IYG.`MG +[omitted] +kdb> md 0xc0262b60 +c0262b60: c0266660 08048000 0804c000 c7bec360 `f&@.....@..`C>G +kdb> ll c0262b60 12 md +c0262b60: c0266660 08048000 0804c000 c7bec360 `f&@.....@..`C>G +c7bec360: c0266660 0804c000 0804d000 c7becb20 `f&@.@...P.. K>G +c7becb20: c0266660 0804d000 08050000 c7bec3a0 `f&@.P...... C>G +c7bec3a0: c0266660 40000000 40009000 c7bec420 `f&@...@...@ D>G +c7bec420: c0266660 40009000 4000b000 c7bec4a0 `f&@...@.0.@ D>G +c7bec4a0: c0266660 4000b000 40010000 c7bec8e0 `f&@.0.@...@`H>G +c7bec8e0: c0266660 40010000 400a1000 c7becbe0 `f&@...@...@`K>G +c7becbe0: c0266660 400a1000 400a8000 c7becc60 `f&@...@...@`L>G +c7becc60: c0266660 400a8000 400b4000 c7952300 `f&@...@.@.@.#.G +c7952300: c0266660 400b5000 400bc000 c79521c0 `f&@.P.@.@.@@!.G +c79521c0: c0266660 400bc000 400bd000 c7bec6e0 `f&@.@.@.P.@`F>G +c7bec6e0: c0266660 bffff000 c0000000 00000000 `f&@.p?...@.... +kdb> +kdb> ll c0262b60 12 vm +struct vm_area_struct at 0xc0262b60 for 56 bytes +vm_start = 0x8048000 vm_end = 0x804c000 +page_prot = 0x25 avl_height = 2244 vm_offset = 0x0 +flags: READ EXEC MAYREAD MAYWRITE MAYEXEC DENYWRITE EXECUTABLE +struct vm_area_struct at 0xc7bec360 for 56 bytes +vm_start = 0x804c000 vm_end = 0x804d000 +page_prot = 0x25 avl_height = -31808 vm_offset = 0x3000 +flags: READ WRITE MAYREAD MAYWRITE MAYEXEC DENYWRITE EXECUTABLE +struct vm_area_struct at 0xc7becb20 for 56 bytes +vm_start = 0x804d000 vm_end = 0x8050000 +page_prot = 0x25 avl_height = -28664 vm_offset = 0x0 +flags: READ WRITE EXEC MAYREAD MAYWRITE MAYEXEC +struct vm_area_struct at 0xc7bec3a0 for 56 bytes +vm_start = 0x40000000 vm_end = 0x40009000 +page_prot = 0x25 avl_height = 30126 vm_offset = 0x0 +flags: READ EXEC MAYREAD MAYWRITE MAYEXEC DENYWRITE +struct vm_area_struct at 0xc7bec420 for 56 bytes +vm_start = 0x40009000 vm_end = 0x4000b000 +page_prot = 0x25 avl_height = 30126 vm_offset = 0x8000 +flags: READ WRITE MAYREAD MAYWRITE MAYEXEC DENYWRITE +struct vm_area_struct at 0xc7bec4a0 for 56 bytes +vm_start = 0x4000b000 vm_end = 0x40010000 +page_prot = 0x25 avl_height = 26853 vm_offset = 0x0 +flags: READ MAYREAD MAYWRITE MAYEXEC +struct vm_area_struct at 0xc7bec8e0 for 56 bytes +vm_start = 0x40010000 vm_end = 0x400a1000 +page_prot = 0x25 avl_height = 2244 vm_offset = 0x0 +flags: READ EXEC MAYREAD MAYWRITE MAYEXEC +struct vm_area_struct at 0xc7becbe0 for 56 bytes +vm_start = 0x400a1000 vm_end = 0x400a8000 +page_prot = 0x25 avl_height = 30126 vm_offset = 0x90000 +flags: READ WRITE MAYREAD MAYWRITE MAYEXEC +struct vm_area_struct at 0xc7becc60 for 56 bytes +vm_start = 0x400a8000 vm_end = 0x400b4000 +page_prot = 0x25 avl_height = 2244 vm_offset = 0x0 +flags: READ WRITE MAYREAD MAYWRITE MAYEXEC +struct vm_area_struct at 0xc7952300 for 56 bytes +vm_start = 0x400b5000 vm_end = 0x400bc000 +page_prot = 0x25 avl_height = 30126 vm_offset = 0x0 +flags: READ EXEC MAYREAD MAYWRITE MAYEXEC +struct vm_area_struct at 0xc79521c0 for 56 bytes +vm_start = 0x400bc000 vm_end = 0x400bd000 +page_prot = 0x25 avl_height = -16344 vm_offset = 0x6000 +flags: READ WRITE MAYREAD MAYWRITE MAYEXEC +struct vm_area_struct at 0xc7bec6e0 for 56 bytes +vm_start = 0xbffff000 vm_end = 0xc0000000 +page_prot = 0x25 avl_height = 2244 vm_offset = 0x0 +flags: READ WRITE EXEC MAYREAD MAYWRITE MAYEXEC GROWSDOWN +kdb> + diff -urN test4.official/Documentation/kdb/kdb_md.man test4.official.kdb/Documentation/kdb/kdb_md.man --- test4.official/Documentation/kdb/kdb_md.man Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/Documentation/kdb/kdb_md.man Fri Aug 11 11:25:45 2000 @@ -0,0 +1,87 @@ +.TH MD 1 "09 March 1999" +.SH NAME +md, mds, mm\- Memory manipulation commands +.SH SYNOPSIS +md [ \fIaddress-expression\fP [ \fIline-count\fP [\fIoutput-radix\fP ] ] ] +.LP +mds [ \fIaddress-expression\fP [ \fIline-count\fP [\fIoutput-radix\fP ] ] ] +.LP +mm \fIaddress-expression\fP \fInew-contents\fP +.SH DESCRIPTION +The +.B md +command is used to display the contents of memory. +The \fIaddress-expression\fP may be a numeric value (decimal or +hexidecimal), a symbol name, a register name preceeded by one or more +percent symbols '%', an environment variable name preceeded by +a currency symbol '$', or a simple expression consisting of a +symbol name, an addition or subtraction character and a numeric +value (decimal or hexidecimal). +.P +If the \fIline-count\fP or \fIradix\fP arguments are omitted, +they default to the values of the \fBMDCOUNT\fP and \fBRADIX\fP +environment variables respectively. If the \fBMDCOUNT\fP or +\fBRADIX\fP environment variables are unset, the appropriate +defaults will be used [see \fBENVIRONMENT\fP below]. +.P +The +.B mds +command displays the contents of memory one word per line and +attempts to correlate the contents of each word with a symbol +in the symbol table. If no symbol is found, the ascii representation +of the word is printed, otherwise the symbol name and offset from +symbol value are printed. +.P +The +.B mm +command allows modification of memory. The word at the address +represented by \fIaddress-expression\fP is changed to +\fInew-contents\fP. \fInew-contents\fP is allowed to be an +\fIaddress-expression\fP. +.SH LIMITATIONS +None. +.SH ENVIRONMENT +.TP 8 +MDCOUNT +This environment variable (default=8) defines the number of lines +that will be displayed by each invocation of the \fBmd\fP command. + +.TP 8 +RADIX +This environment variable (default=16) defines the radix used to +print the memory contents. + +.TP 8 +BYTESPERWORD +This environment variable (default=4) selects the width of output +data when printing memory contents. Select the value two to get +16-bit word output, select the value one to get byte output. + +.TP 8 +LINES +This environment variable governs the number of lines of output +that will be presented before the kernel debugger built-in pager +pauses the output. This variable only affects the functioning +of the \fBmd\fP and \fBmds\fP if the \fBMDCOUNT\fP variable +is set to a value greater than the \fBLINES\fP variable. +.SH SMP CONSIDERATIONS +None. +.SH EXAMPLES +.TP 8 +md %edx +Display memory starting at the address contained in register \fB%edx\fP. + +.TP 8 +mds %esp +Display stack contents symbolically. This command is quite useful +in manual stack traceback. + +.TP 8 +mm 0xc0252110 0x25 +Change the memory location at 0xc0252110 to the value 0x25. + +.TP 8 +md chrdev_table 15 +Display 15 lines (at 16 bytes per line) starting at address +represented by the symbol \fIchrdev_table\fP. + diff -urN test4.official/Documentation/kdb/kdb_rd.man test4.official.kdb/Documentation/kdb/kdb_rd.man --- test4.official/Documentation/kdb/kdb_rd.man Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/Documentation/kdb/kdb_rd.man Fri Aug 11 11:25:45 2000 @@ -0,0 +1,55 @@ +.TH RD 1 "09 March 1999" +.SH NAME +rd, rm\- Register manipulation commands +.SH SYNOPSIS +rd [c|d|u] +.LP +rm \fIregister-name\fP \fInew-contents\fP +.SH DESCRIPTION +The +.B rd +command is used to display the contents of processor registers. +Without any arguments, the rd command displays the contents of +the general register set at the point at which the kernel debugger +was entered. With the 'c' argument, the processor control registers +%cr0, %cr1, %cr2 and %cr4 are displayed, while with the 'd' argument +the processor debug registers are displayed. If the 'u' argument +is supplied, the registers for the current task as of the last +time the current task entered the kernel are displayed. +.P +The +.B rm +command allows modification of a register. The following +register names are valid: \fB%eax\fP, \fB%ebx\fP, \fB%ecx\fP, +\fB%edx\fP, \fB%esi\fP, \fB%edi\fP, \fB%esp\fP, \fB%eip\fP, +and \fB%ebp\fP. Note that if two '%' symbols are used +consecutively, the register set displayed by the 'u' argument +to the \fBrd\fP command is modified. +.SH LIMITATIONS +Currently the 'rm' command will not allow modification of the +control or debug registers. +.P +Currently neither the 'rd' command nor the 'rm' command will +display or modify the model specific registers on the Pentium +and Pentium Pro families. +.SH ENVIRONMENT +None. +.SH SMP CONSIDERATIONS +None. +.SH EXAMPLES +.TP 8 +rd +Display general register set. + +.TP 8 +rm %eax 0 +Set the contents of \fB%eax\fP to zero. This will be the +value of %eax when kdb returns from the condition which +invoked it. + +.TP 8 +rm %%eax 0 +Set the value of the \fB%eax\fP register to zero. This will +be the value the user-mode application will see upon returning +from the kernel. + diff -urN test4.official/Documentation/kdb/kdb_ss.man test4.official.kdb/Documentation/kdb/kdb_ss.man --- test4.official/Documentation/kdb/kdb_ss.man Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/Documentation/kdb/kdb_ss.man Fri Aug 11 11:25:45 2000 @@ -0,0 +1,72 @@ +.TH SS 1 "29 March 1999" +.SH NAME +ss, ssb \- Single Step +.SH SYNOPSIS +ss [] +.LP +ssb +.SH DESCRIPTION +The +.B ss +command is used to execute a single instruction and return +to the kernel debugger. +.P +Both the instruction that was single-stepped and the next +instruction to execute are printed. +.P +The \fBssb\fP command will execute instructions from the +current value of the instruction pointer. Each instruction +will be printed as it is executed; execution will stop at +any instruction which would cause the flow of control to +change (e.g. branch, call, interrupt instruction, return, etc.) +.SH LIMITATIONS +None. +.SH ENVIRONMENT +None. +.SH SMP CONSIDERATIONS +Other processors will be released from the kernel debugger +when the instruction is traced, and will be brought back to +a barrier in the kernel debugger when the traced instruction +completes. +.SH EXAMPLES +.nf +.na +.ft CW +kdb> bp gendisk_head datar 4 +Data Access Breakpoint #0 at 0xc024ddf4 (gendisk_head) in dr0 is enabled on cpu 0 +for 4 bytes +kdb> go +... +[root@host /root]# cat /proc/partitions +Entering kdb on processor 0 due to Debug Exception @ 0xc01845e3 +Read/Write breakpoint #0 at 0xc024ddf4 +[0]kdb> ssb +sd_finish+0x7b: movzbl 0xc02565d4,%edx +sd_finish+0x82: leal 0xf(%edx),%eax +sd_finish+0x85: sarl $0x4,%eax +sd_finish+0x88: movl 0xc0256654,%ecx +sd_finish+0x8e: leal (%eax,%eax,4),%edx +sd_finish+0x91: leal (%eax,%edx,2),%edx +sd_finish+0x94: movl 0xc0251108,%eax +sd_finish+0x99: movl %eax,0xffffffc(%ecx,%edx,4) +sd_finish+0x9d: movl %ecx,0xc0251108 +sd_finish+0xa3: xorl %ebx,%ebx +sd_finish+0xa5: cmpb $0x0,0xc02565d4 +[0]kdb> go +[root@host /root]# + +[0]kdb> ss +sys_read: pushl %ebp +SS trap at 0xc01274c1 +sys_read+0x1: movl %esp,%ebp +[0]kdb> ss +sys_read+0x1: movl %esp,%ebp +SS trap at 0xc01274c3 +sys_read+0x3: subl $0xc,%esp +[0]kdb> ss +sys_read+0x3: subl $0xc,%esp +SS trap at 0xc01274c6 +sys_read+0x6: pushl %edi +[0]kdb> + + diff -urN test4.official/Makefile test4.official.kdb/Makefile --- test4.official/Makefile Fri Aug 11 17:32:39 2000 +++ test4.official.kdb/Makefile Fri Aug 11 11:25:45 2000 @@ -37,6 +37,7 @@ GENKSYMS = /sbin/genksyms MODFLAGS = -DMODULE PERL = perl +AWK = awk export VERSION PATCHLEVEL SUBLEVEL EXTRAVERSION KERNELRELEASE ARCH \ CONFIG_SHELL TOPDIR HPATH HOSTCC HOSTCFLAGS CROSS_COMPILE AS LD CC \ @@ -82,6 +83,12 @@ CPPFLAGS := -D__KERNEL__ -I$(HPATH) +ifdef CONFIG_KDB_FRAMEPTR +CFLAGS := $(CPPFLAGS) -Wall -Wstrict-prototypes -g -O2 +else +CFLAGS := $(CPPFLAGS) -Wall -Wstrict-prototypes -g -O2 -fomit-frame-pointer +endif + CFLAGS := $(CPPFLAGS) -Wall -Wstrict-prototypes -g -O2 -fomit-frame-pointer AFLAGS := -D__ASSEMBLY__ $(CPPFLAGS) @@ -120,7 +127,7 @@ drivers/net/net.o \ drivers/parport/parport.a LIBS =$(TOPDIR)/lib/lib.a -SUBDIRS =kernel drivers mm fs net ipc lib +SUBDIRS =kernel drivers mm fs net ipc lib kdb DRIVERS-n := DRIVERS-y := @@ -140,6 +147,7 @@ DRIVERS-$(CONFIG_IDE) += drivers/ide/idedriver.o DRIVERS-$(CONFIG_SCSI) += drivers/scsi/scsidrv.o DRIVERS-$(CONFIG_IEEE1394) += drivers/ieee1394/ieee1394.a +DRIVERS-$(CONFIG_KDB) += kdb/kdb.o ifneq ($(CONFIG_CD_NO_IDESCSI)$(CONFIG_BLK_DEV_IDECD)$(CONFIG_BLK_DEV_SR)$(CONFIG_PARIDE_PCD),) DRIVERS-y += drivers/cdrom/cdrom.a @@ -192,6 +200,36 @@ boot: vmlinux @$(MAKE) -C arch/$(ARCH)/boot +ifeq ($(CONFIG_KDB),y) +vmlinux: $(CONFIGURATION) init/main.o init/version.o linuxsubdirs + echo "c0000000 t firstaddr\n" > System.map + rm -f map map.out + $(AWK) -f scripts/genkdbsym.awk System.map > dummy_sym.c + $(CC) -Iinclude -c -o dummy_sym.o dummy_sym.c + $(LD) $(LINKFLAGS) $(HEAD) -Map map init/main.o init/version.o \ + --start-group \ + $(CORE_FILES) \ + $(NETWORKS) \ + $(DRIVERS) \ + $(LIBS) \ + dummy_sym.o \ + --end-group \ + -o vmlinux + $(NM) vmlinux | grep -v '\(compiled\)\|\(\.o$$\)\|\( [aU] \)\|\(\.\.ng$$\)\|\(LASH[RL]DI\)' | sort > System.map + cp System.map System.map.sv + $(AWK) -f scripts/genkdbsym.awk System.map > ksym.c + $(CC) -Iinclude -c -o ksym.o ksym.c > ksym.o + $(LD) $(LINKFLAGS) $(HEAD) -Map map.out init/main.o init/version.o \ + --start-group \ + $(CORE_FILES) \ + $(NETWORKS) \ + $(DRIVERS) \ + $(LIBS) \ + ksym.o \ + --end-group \ + -o vmlinux + $(NM) vmlinux | grep -v '\(compiled\)\|\(\.o$$\)\|\( [aU] \)\|\(\.\.ng$$\)\|\(LASH[RL]DI\)' | sort > System.map +else vmlinux: $(CONFIGURATION) init/main.o init/version.o linuxsubdirs $(LD) $(LINKFLAGS) $(HEAD) init/main.o init/version.o \ --start-group \ @@ -202,6 +240,7 @@ --end-group \ -o vmlinux $(NM) vmlinux | grep -v '\(compiled\)\|\(\.o$$\)\|\( [aU] \)\|\(\.\.ng$$\)\|\(LASH[RL]DI\)' | sort > System.map +endif symlinks: rm -f include/asm diff -urN test4.official/arch/ia64/Makefile test4.official.kdb/arch/ia64/Makefile --- test4.official/arch/ia64/Makefile Fri Aug 11 17:32:39 2000 +++ test4.official.kdb/arch/ia64/Makefile Fri Aug 11 11:25:45 2000 @@ -69,6 +69,11 @@ CORE_FILES := arch/$(ARCH)/ia32/ia32.o $(CORE_FILES) endif +ifdef CONFIG_KDB + LIBS := $(LIBS) $(TOPDIR)/arch/$(ARCH)/kdb/kdba.o + SUBDIRS := $(SUBDIRS) arch/$(ARCH)/kdb +endif + HEAD := arch/$(ARCH)/kernel/head.o arch/ia64/kernel/init_task.o SUBDIRS := arch/$(ARCH)/tools arch/$(ARCH)/kernel arch/$(ARCH)/mm arch/$(ARCH)/lib $(SUBDIRS) diff -urN test4.official/arch/ia64/config.in test4.official.kdb/arch/ia64/config.in --- test4.official/arch/ia64/config.in Fri Aug 11 17:32:39 2000 +++ test4.official.kdb/arch/ia64/config.in Fri Aug 11 11:25:45 2000 @@ -219,5 +219,9 @@ bool 'Turn on irq debug checks (slow!)' CONFIG_IA64_DEBUG_IRQ bool 'Print possible IA64 hazards to console' CONFIG_IA64_PRINT_HAZARDS bool 'Enable new unwind support' CONFIG_IA64_NEW_UNWIND +bool 'Built-in Kernel Debugger support' CONFIG_KDB +if [ "$CONFIG_KDB" = "y" ]; then + int 'KDB Kernel Symbol Table size?' CONFIG_KDB_STBSIZE 20000 +fi endmenu diff -urN test4.official/arch/ia64/kdb/Makefile test4.official.kdb/arch/ia64/kdb/Makefile --- test4.official/arch/ia64/kdb/Makefile Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/arch/ia64/kdb/Makefile Fri Aug 11 11:25:45 2000 @@ -0,0 +1,5 @@ +O_TARGET := kdba.o +O_OBJS = kdb_traps.o kdba_bt.o kdba_bp.o kdba_io.o kdbasupport.o \ + cpu-ia64-opc.o ia64-dis.o ia64-opc.o kdba_dis.o + +include $(TOPDIR)/Rules.make diff -urN test4.official/arch/ia64/kdb/cpu-ia64-opc.c test4.official.kdb/arch/ia64/kdb/cpu-ia64-opc.c --- test4.official/arch/ia64/kdb/cpu-ia64-opc.c Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/arch/ia64/kdb/cpu-ia64-opc.c Fri Aug 11 11:25:45 2000 @@ -0,0 +1,586 @@ +/* Copyright (C) 1998, 1999 Free Software Foundation, Inc. + Contributed by David Mosberger-Tang + +This file is part of BFD, the Binary File Descriptor library. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + + +/* Logically, this code should be part of libopcode but since some of + the operand insertion/extraction functions help bfd to implement + relocations, this code is included as part of elf64-ia64.c. This + avoids circular dependencies between libopcode and libbfd and also + obviates the need for applications to link in libopcode when all + they really want is libbfd. + + --davidm Mon Apr 13 22:14:02 1998 */ + +#include "ia64-opc.h" + +#define NELEMS(a) ((int) (sizeof (a) / sizeof ((a)[0]))) + +static const char* +ins_rsvd (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) +{ + return "internal error---this shouldn't happen"; +} + +static const char* +ext_rsvd (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) +{ + return "internal error---this shouldn't happen"; +} + +static const char* +ins_const (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) +{ + return 0; +} + +static const char* +ext_const (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) +{ + return 0; +} + +static const char* +ins_reg (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) +{ + if (value >= 1u << self->field[0].bits) + return "register number out of range"; + + *code |= value << self->field[0].shift; + return 0; +} + +static const char* +ext_reg (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) +{ + *valuep = ((code >> self->field[0].shift) + & ((1u << self->field[0].bits) - 1)); + return 0; +} + +static const char* +ins_immu (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) +{ + ia64_insn new = 0; + int i; + + for (i = 0; i < NELEMS (self->field) && self->field[i].bits; ++i) + { + new |= ((value & ((((ia64_insn) 1) << self->field[i].bits) - 1)) + << self->field[i].shift); + value >>= self->field[i].bits; + } + if (value) + return "integer operand out of range"; + + *code |= new; + return 0; +} + +static const char* +ext_immu (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) +{ + BFD_HOST_U_64_BIT value = 0; + int i, bits = 0, total = 0; + + for (i = 0; i < NELEMS (self->field) && self->field[i].bits; ++i) + { + bits = self->field[i].bits; + value |= ((code >> self->field[i].shift) + & ((((BFD_HOST_U_64_BIT) 1) << bits) - 1)) << total; + total += bits; + } + *valuep = value; + return 0; +} + +static const char* +ins_immus8 (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) +{ + if (value & 0x7) + return "value not an integer multiple of 8"; + return ins_immu (self, value >> 3, code); +} + +static const char* +ext_immus8 (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) +{ + const char *result; + + result = ext_immu (self, code, valuep); + if (result) + return result; + + *valuep = *valuep << 3; + return 0; +} + +static const char* +ins_imms_scaled (const struct ia64_operand *self, ia64_insn value, + ia64_insn *code, int scale) +{ + BFD_HOST_64_BIT svalue = value, sign_bit = 0; + ia64_insn new = 0; + int i; + + svalue >>= scale; + + for (i = 0; i < NELEMS (self->field) && self->field[i].bits; ++i) + { + new |= ((svalue & ((((ia64_insn) 1) << self->field[i].bits) - 1)) + << self->field[i].shift); + sign_bit = (svalue >> (self->field[i].bits - 1)) & 1; + svalue >>= self->field[i].bits; + } + if ((!sign_bit && svalue != 0) || (sign_bit && svalue != -1)) + return "integer operand out of range"; + + *code |= new; + return 0; +} + +static const char* +ext_imms_scaled (const struct ia64_operand *self, ia64_insn code, + ia64_insn *valuep, int scale) +{ + int i, bits = 0, total = 0, shift; + BFD_HOST_64_BIT val = 0; + + for (i = 0; i < NELEMS (self->field) && self->field[i].bits; ++i) + { + bits = self->field[i].bits; + val |= ((code >> self->field[i].shift) + & ((((BFD_HOST_U_64_BIT) 1) << bits) - 1)) << total; + total += bits; + } + /* sign extend: */ + shift = 8*sizeof (val) - total; + val = (val << shift) >> shift; + + *valuep = (val << scale); + return 0; +} + +static const char* +ins_imms (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) +{ + return ins_imms_scaled (self, value, code, 0); +} + +static const char* +ins_immsu4 (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) +{ + if (value == (BFD_HOST_U_64_BIT) 0x100000000) + value = 0; + else + value = (((BFD_HOST_64_BIT)value << 32) >> 32); + + return ins_imms_scaled (self, value, code, 0); +} + +static const char* +ext_imms (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) +{ + return ext_imms_scaled (self, code, valuep, 0); +} + +static const char* +ins_immsm1 (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) +{ + --value; + return ins_imms_scaled (self, value, code, 0); +} + +static const char* +ins_immsm1u4 (const struct ia64_operand *self, ia64_insn value, + ia64_insn *code) +{ + if (value == (BFD_HOST_U_64_BIT) 0x100000000) + value = 0; + else + value = (((BFD_HOST_64_BIT)value << 32) >> 32); + + --value; + return ins_imms_scaled (self, value, code, 0); +} + +static const char* +ext_immsm1 (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) +{ + const char *res = ext_imms_scaled (self, code, valuep, 0); + + ++*valuep; + return res; +} + +static const char* +ins_imms1 (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) +{ + return ins_imms_scaled (self, value, code, 1); +} + +static const char* +ext_imms1 (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) +{ + return ext_imms_scaled (self, code, valuep, 1); +} + +static const char* +ins_imms4 (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) +{ + return ins_imms_scaled (self, value, code, 4); +} + +static const char* +ext_imms4 (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) +{ + return ext_imms_scaled (self, code, valuep, 4); +} + +static const char* +ins_imms16 (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) +{ + return ins_imms_scaled (self, value, code, 16); +} + +static const char* +ext_imms16 (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) +{ + return ext_imms_scaled (self, code, valuep, 16); +} + +static const char* +ins_cimmu (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) +{ + ia64_insn mask = (((ia64_insn) 1) << self->field[0].bits) - 1; + return ins_immu (self, value ^ mask, code); +} + +static const char* +ext_cimmu (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) +{ + const char *result; + ia64_insn mask; + + mask = (((ia64_insn) 1) << self->field[0].bits) - 1; + result = ext_immu (self, code, valuep); + if (!result) + { + mask = (((ia64_insn) 1) << self->field[0].bits) - 1; + *valuep ^= mask; + } + return result; +} + +static const char* +ins_cnt (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) +{ + --value; + if (value >= ((BFD_HOST_U_64_BIT) 1) << self->field[0].bits) + return "count out of range"; + + *code |= value << self->field[0].shift; + return 0; +} + +static const char* +ext_cnt (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) +{ + *valuep = ((code >> self->field[0].shift) + & ((((BFD_HOST_U_64_BIT) 1) << self->field[0].bits) - 1)) + 1; + return 0; +} + +static const char* +ins_cnt2b (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) +{ + --value; + + if (value > 2) + return "count must be in range 1..3"; + + *code |= value << self->field[0].shift; + return 0; +} + +static const char* +ext_cnt2b (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) +{ + *valuep = ((code >> self->field[0].shift) & 0x3) + 1; + return 0; +} + +static const char* +ins_cnt2c (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) +{ + switch (value) + { + case 0: value = 0; break; + case 7: value = 1; break; + case 15: value = 2; break; + case 16: value = 3; break; + default: return "count must be 0, 7, 15, or 16"; + } + *code |= value << self->field[0].shift; + return 0; +} + +static const char* +ext_cnt2c (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) +{ + ia64_insn value; + + value = (code >> self->field[0].shift) & 0x3; + switch (value) + { + case 0: value = 0; break; + case 1: value = 7; break; + case 2: value = 15; break; + case 3: value = 16; break; + } + *valuep = value; + return 0; +} + +static const char* +ins_inc3 (const struct ia64_operand *self, ia64_insn value, ia64_insn *code) +{ + BFD_HOST_64_BIT val = value; + BFD_HOST_U_64_BIT sign = 0; + + if (val < 0) + { + sign = 0x4; + value = -value; + } + switch (value) + { + case 1: value = 3; break; + case 4: value = 2; break; + case 8: value = 1; break; + case 16: value = 0; break; + default: return "count must be +/- 1, 4, 8, or 16"; + } + *code |= (sign | value) << self->field[0].shift; + return 0; +} + +static const char* +ext_inc3 (const struct ia64_operand *self, ia64_insn code, ia64_insn *valuep) +{ + BFD_HOST_64_BIT val; + int negate; + + val = (code >> self->field[0].shift) & 0x7; + negate = val & 0x4; + switch (val & 0x3) + { + case 0: val = 16; break; + case 1: val = 8; break; + case 2: val = 4; break; + case 3: val = 1; break; + } + if (negate) + val = -val; + + *valuep = val; + return 0; +} + +#define CST IA64_OPND_CLASS_CST +#define REG IA64_OPND_CLASS_REG +#define IND IA64_OPND_CLASS_IND +#define ABS IA64_OPND_CLASS_ABS +#define REL IA64_OPND_CLASS_REL + +#define SDEC IA64_OPND_FLAG_DECIMAL_SIGNED +#define UDEC IA64_OPND_FLAG_DECIMAL_UNSIGNED + +const struct ia64_operand elf64_ia64_operands[IA64_OPND_COUNT] = + { + /* constants: */ + { CST, ins_const, ext_const, "NIL", {{ 0, }}, 0, "" }, + { CST, ins_const, ext_const, "ar.ccv", {{ 0, }}, 0, "ar.ccv" }, + { CST, ins_const, ext_const, "ar.pfs", {{ 0, }}, 0, "ar.pfs" }, + { CST, ins_const, ext_const, "1", {{ 0, }}, 0, "1" }, + { CST, ins_const, ext_const, "8", {{ 0, }}, 0, "1" }, + { CST, ins_const, ext_const, "16", {{ 0, }}, 0, "16" }, + { CST, ins_const, ext_const, "r0", {{ 0, }}, 0, "r0" }, + { CST, ins_const, ext_const, "ip", {{ 0, }}, 0, "ip" }, + { CST, ins_const, ext_const, "pr", {{ 0, }}, 0, "pr" }, + { CST, ins_const, ext_const, "pr.rot", {{ 0, }}, 0, "pr.rot" }, + { CST, ins_const, ext_const, "psr", {{ 0, }}, 0, "psr" }, + { CST, ins_const, ext_const, "psr.l", {{ 0, }}, 0, "psr.l" }, + { CST, ins_const, ext_const, "psr.um", {{ 0, }}, 0, "psr.um" }, + + /* register operands: */ + { REG, ins_reg, ext_reg, "ar", {{ 7, 20}}, 0, /* AR3 */ + "an application register" }, + { REG, ins_reg, ext_reg, "b", {{ 3, 6}}, 0, /* B1 */ + "a branch register" }, + { REG, ins_reg, ext_reg, "b", {{ 3, 13}}, 0, /* B2 */ + "a branch register"}, + { REG, ins_reg, ext_reg, "cr", {{ 7, 20}}, 0, /* CR */ + "a control register"}, + { REG, ins_reg, ext_reg, "f", {{ 7, 6}}, 0, /* F1 */ + "a floating-point register" }, + { REG, ins_reg, ext_reg, "f", {{ 7, 13}}, 0, /* F2 */ + "a floating-point register" }, + { REG, ins_reg, ext_reg, "f", {{ 7, 20}}, 0, /* F3 */ + "a floating-point register" }, + { REG, ins_reg, ext_reg, "f", {{ 7, 27}}, 0, /* F4 */ + "a floating-point register" }, + { REG, ins_reg, ext_reg, "p", {{ 6, 6}}, 0, /* P1 */ + "a predicate register" }, + { REG, ins_reg, ext_reg, "p", {{ 6, 27}}, 0, /* P2 */ + "a predicate register" }, + { REG, ins_reg, ext_reg, "r", {{ 7, 6}}, 0, /* R1 */ + "a general register" }, + { REG, ins_reg, ext_reg, "r", {{ 7, 13}}, 0, /* R2 */ + "a general register" }, + { REG, ins_reg, ext_reg, "r", {{ 7, 20}}, 0, /* R3 */ + "a general register" }, + { REG, ins_reg, ext_reg, "r", {{ 2, 20}}, 0, /* R3_2 */ + "a general register r0-r3" }, + + /* indirect operands: */ + { IND, ins_reg, ext_reg, "cpuid", {{7, 20}}, 0, /* CPUID_R3 */ + "a cpuid register" }, + { IND, ins_reg, ext_reg, "dbr", {{7, 20}}, 0, /* DBR_R3 */ + "a dbr register" }, + { IND, ins_reg, ext_reg, "dtr", {{7, 20}}, 0, /* DTR_R3 */ + "a dtr register" }, + { IND, ins_reg, ext_reg, "itr", {{7, 20}}, 0, /* ITR_R3 */ + "an itr register" }, + { IND, ins_reg, ext_reg, "ibr", {{7, 20}}, 0, /* IBR_R3 */ + "an ibr register" }, + { IND, ins_reg, ext_reg, "", {{7, 20}}, 0, /* MR3 */ + "an indirect memory address" }, + { IND, ins_reg, ext_reg, "msr", {{7, 20}}, 0, /* MSR_R3 */ + "an msr register" }, + { IND, ins_reg, ext_reg, "pkr", {{7, 20}}, 0, /* PKR_R3 */ + "a pkr register" }, + { IND, ins_reg, ext_reg, "pmc", {{7, 20}}, 0, /* PMC_R3 */ + "a pmc register" }, + { IND, ins_reg, ext_reg, "pmd", {{7, 20}}, 0, /* PMD_R3 */ + "a pmd register" }, + { IND, ins_reg, ext_reg, "rr", {{7, 20}}, 0, /* RR_R3 */ + "an rr register" }, + + /* immediate operands: */ + { ABS, ins_cimmu, ext_cimmu, 0, {{ 5, 20 }}, UDEC, /* CCNT5 */ + "a 5-bit count (0-31)" }, + { ABS, ins_cnt, ext_cnt, 0, {{ 2, 27 }}, UDEC, /* CNT2a */ + "a 2-bit count (1-4)" }, + { ABS, ins_cnt2b, ext_cnt2b, 0, {{ 2, 27 }}, UDEC, /* CNT2b */ + "a 2-bit count (1-3)" }, + { ABS, ins_cnt2c, ext_cnt2c, 0, {{ 2, 30 }}, UDEC, /* CNT2c */ + "a count (0, 7, 15, or 16)" }, + { ABS, ins_immu, ext_immu, 0, {{ 5, 14}}, UDEC, /* CNT5 */ + "a 5-bit count (0-31)" }, + { ABS, ins_immu, ext_immu, 0, {{ 6, 27}}, UDEC, /* CNT6 */ + "a 6-bit count (0-63)" }, + { ABS, ins_cimmu, ext_cimmu, 0, {{ 6, 20}}, UDEC, /* CPOS6a */ + "a 6-bit bit pos (0-63)" }, + { ABS, ins_cimmu, ext_cimmu, 0, {{ 6, 14}}, UDEC, /* CPOS6b */ + "a 6-bit bit pos (0-63)" }, + { ABS, ins_cimmu, ext_cimmu, 0, {{ 6, 31}}, UDEC, /* CPOS6c */ + "a 6-bit bit pos (0-63)" }, + { ABS, ins_imms, ext_imms, 0, {{ 1, 36}}, SDEC, /* IMM1 */ + "a 1-bit integer (-1, 0)" }, + { ABS, ins_immu, ext_immu, 0, {{ 2, 13}}, UDEC, /* IMMU2 */ + "a 2-bit unsigned (0-3)" }, + { ABS, ins_immu, ext_immu, 0, {{ 7, 13}}, 0, /* IMMU7a */ + "a 7-bit unsigned (0-127)" }, + { ABS, ins_immu, ext_immu, 0, {{ 7, 20}}, 0, /* IMMU7b */ + "a 7-bit unsigned (0-127)" }, + { ABS, ins_immu, ext_immu, 0, {{ 7, 13}}, UDEC, /* SOF */ + "a frame size (register count)" }, + { ABS, ins_immu, ext_immu, 0, {{ 7, 20}}, UDEC, /* SOL */ + "a local register count" }, + { ABS, ins_immus8,ext_immus8,0, {{ 4, 27}}, UDEC, /* SOR */ + "a rotating register count (integer multiple of 8)" }, + { ABS, ins_imms, ext_imms, 0, /* IMM8 */ + {{ 7, 13}, { 1, 36}}, SDEC, + "an 8-bit integer (-128-127)" }, + { ABS, ins_immsu4, ext_imms, 0, /* IMM8U4 */ + {{ 7, 13}, { 1, 36}}, SDEC, + "an 8-bit signed integer for 32-bit unsigned compare (-128-127)" }, + { ABS, ins_immsm1, ext_immsm1, 0, /* IMM8M1 */ + {{ 7, 13}, { 1, 36}}, SDEC, + "an 8-bit integer (-127-128)" }, + { ABS, ins_immsm1u4, ext_immsm1, 0, /* IMM8M1U4 */ + {{ 7, 13}, { 1, 36}}, SDEC, + "an 8-bit integer for 32-bit unsigned compare (-127-(-1),1-128,0x100000000)" }, + { ABS, ins_immsm1, ext_immsm1, 0, /* IMM8M1U8 */ + {{ 7, 13}, { 1, 36}}, SDEC, + "an 8-bit integer for 64-bit unsigned compare (-127-(-1),1-128,0x10000000000000000)" }, + { ABS, ins_immu, ext_immu, 0, {{ 2, 33}, { 7, 20}}, 0, /* IMMU9 */ + "a 9-bit unsigned (0-511)" }, + { ABS, ins_imms, ext_imms, 0, /* IMM9a */ + {{ 7, 6}, { 1, 27}, { 1, 36}}, SDEC, + "a 9-bit integer (-256-255)" }, + { ABS, ins_imms, ext_imms, 0, /* IMM9b */ + {{ 7, 13}, { 1, 27}, { 1, 36}}, SDEC, + "a 9-bit integer (-256-255)" }, + { ABS, ins_imms, ext_imms, 0, /* IMM14 */ + {{ 7, 13}, { 6, 27}, { 1, 36}}, SDEC, + "a 14-bit integer (-8192-8191)" }, + { ABS, ins_imms1, ext_imms1, 0, /* IMM17 */ + {{ 7, 6}, { 8, 24}, { 1, 36}}, 0, + "a 17-bit integer (-65536-65535)" }, + { ABS, ins_immu, ext_immu, 0, {{20, 6}, { 1, 36}}, 0, /* IMMU21 */ + "a 21-bit unsigned" }, + { ABS, ins_imms, ext_imms, 0, /* IMM22 */ + {{ 7, 13}, { 9, 27}, { 5, 22}, { 1, 36}}, SDEC, + "a 22-bit integer" }, + { ABS, ins_immu, ext_immu, 0, /* IMMU24 */ + {{21, 6}, { 2, 31}, { 1, 36}}, 0, + "a 24-bit unsigned" }, + { ABS, ins_imms16,ext_imms16,0, {{27, 6}, { 1, 36}}, 0, /* IMM44 */ + "a 44-bit unsigned (least 16 bits ignored/zeroes)" }, + { ABS, ins_rsvd, ext_rsvd, 0, {{0, 0}}, 0, /* IMMU62 */ + "a 62-bit unsigned" }, + { ABS, ins_rsvd, ext_rsvd, 0, {{0, 0}}, 0, /* IMMU64 */ + "a 64-bit unsigned" }, + { ABS, ins_inc3, ext_inc3, 0, {{ 3, 13}}, SDEC, /* INC3 */ + "an increment (+/- 1, 4, 8, or 16)" }, + { ABS, ins_cnt, ext_cnt, 0, {{ 4, 27}}, UDEC, /* LEN4 */ + "a 4-bit length (1-16)" }, + { ABS, ins_cnt, ext_cnt, 0, {{ 6, 27}}, UDEC, /* LEN6 */ + "a 6-bit length (1-64)" }, + { ABS, ins_immu, ext_immu, 0, {{ 4, 20}}, 0, /* MBTYPE4 */ + "a mix type (@rev, @mix, @shuf, @alt, or @brcst)" }, + { ABS, ins_immu, ext_immu, 0, {{ 8, 20}}, 0, /* MBTYPE8 */ + "an 8-bit mix type" }, + { ABS, ins_immu, ext_immu, 0, {{ 6, 14}}, UDEC, /* POS6 */ + "a 6-bit bit pos (0-63)" }, + { REL, ins_imms4, ext_imms4, 0, {{ 7, 6}, { 2, 33}}, 0, /* TAG13 */ + "a branch tag" }, + { REL, ins_imms4, ext_imms4, 0, {{ 9, 24}}, 0, /* TAG13b */ + "a branch tag" }, + { REL, ins_imms4, ext_imms4, 0, {{20, 6}, { 1, 36}}, 0, /* TGT25 */ + "a branch target" }, + { REL, ins_imms4, ext_imms4, 0, /* TGT25b */ + {{ 7, 6}, {13, 20}, { 1, 36}}, 0, + "a branch target" }, + { REL, ins_imms4, ext_imms4, 0, {{20, 13}, { 1, 36}}, 0, /* TGT25c */ + "a branch target" }, + { REL, ins_rsvd, ext_rsvd, 0, {{0, 0}}, 0, /* TGT64 */ + "a branch target" }, + }; diff -urN test4.official/arch/ia64/kdb/dis-asm.h test4.official.kdb/arch/ia64/kdb/dis-asm.h --- test4.official/arch/ia64/kdb/dis-asm.h Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/arch/ia64/kdb/dis-asm.h Fri Aug 11 11:25:45 2000 @@ -0,0 +1,260 @@ +/* Interface between the opcode library and its callers. + Written by Cygnus Support, 1993. + + The opcode library (libopcodes.a) provides instruction decoders for + a large variety of instruction sets, callable with an identical + interface, for making instruction-processing programs more independent + of the instruction set being processed. */ + +#ifndef DIS_ASM_H +#define DIS_ASM_H + +#include +#include "minbfd.h" + +typedef int (*fprintf_ftype) PARAMS((PTR, const char*, ...)); + +enum dis_insn_type { + dis_noninsn, /* Not a valid instruction */ + dis_nonbranch, /* Not a branch instruction */ + dis_branch, /* Unconditional branch */ + dis_condbranch, /* Conditional branch */ + dis_jsr, /* Jump to subroutine */ + dis_condjsr, /* Conditional jump to subroutine */ + dis_dref, /* Data reference instruction */ + dis_dref2 /* Two data references in instruction */ +}; + +/* This struct is passed into the instruction decoding routine, + and is passed back out into each callback. The various fields are used + for conveying information from your main routine into your callbacks, + for passing information into the instruction decoders (such as the + addresses of the callback functions), or for passing information + back from the instruction decoders to their callers. + + It must be initialized before it is first passed; this can be done + by hand, or using one of the initialization macros below. */ + +typedef struct disassemble_info { + fprintf_ftype fprintf_func; + PTR stream; + PTR application_data; + + /* Target description. We could replace this with a pointer to the bfd, + but that would require one. There currently isn't any such requirement + so to avoid introducing one we record these explicitly. */ + /* The bfd_flavour. This can be bfd_target_unknown_flavour. */ + enum bfd_flavour flavour; + /* The bfd_arch value. */ + enum bfd_architecture arch; + /* The bfd_mach value. */ + unsigned long mach; + /* Endianness (for bi-endian cpus). Mono-endian cpus can ignore this. */ + enum bfd_endian endian; + + /* An array of pointers to symbols either at the location being disassembled + or at the start of the function being disassembled. The array is sorted + so that the first symbol is intended to be the one used. The others are + present for any misc. purposes. This is not set reliably, but if it is + not NULL, it is correct. */ + asymbol **symbols; + /* Number of symbols in array. */ + int num_symbols; + + /* For use by the disassembler. + The top 16 bits are reserved for public use (and are documented here). + The bottom 16 bits are for the internal use of the disassembler. */ + unsigned long flags; +#define INSN_HAS_RELOC 0x80000000 + PTR private_data; + + /* Function used to get bytes to disassemble. MEMADDR is the + address of the stuff to be disassembled, MYADDR is the address to + put the bytes in, and LENGTH is the number of bytes to read. + INFO is a pointer to this struct. + Returns an errno value or 0 for success. */ + int (*read_memory_func) + PARAMS ((bfd_vma memaddr, bfd_byte *myaddr, int length, + struct disassemble_info *info)); + + /* Function which should be called if we get an error that we can't + recover from. STATUS is the errno value from read_memory_func and + MEMADDR is the address that we were trying to read. INFO is a + pointer to this struct. */ + void (*memory_error_func) + PARAMS ((int status, bfd_vma memaddr, struct disassemble_info *info)); + + /* Function called to print ADDR. */ + void (*print_address_func) + PARAMS ((bfd_vma addr, struct disassemble_info *info)); + + /* Function called to determine if there is a symbol at the given ADDR. + If there is, the function returns 1, otherwise it returns 0. + This is used by ports which support an overlay manager where + the overlay number is held in the top part of an address. In + some circumstances we want to include the overlay number in the + address, (normally because there is a symbol associated with + that address), but sometimes we want to mask out the overlay bits. */ + int (* symbol_at_address_func) + PARAMS ((bfd_vma addr, struct disassemble_info * info)); + + /* These are for buffer_read_memory. */ + bfd_byte *buffer; + bfd_vma buffer_vma; + int buffer_length; + + /* This variable may be set by the instruction decoder. It suggests + the number of bytes objdump should display on a single line. If + the instruction decoder sets this, it should always set it to + the same value in order to get reasonable looking output. */ + int bytes_per_line; + + /* the next two variables control the way objdump displays the raw data */ + /* For example, if bytes_per_line is 8 and bytes_per_chunk is 4, the */ + /* output will look like this: + 00: 00000000 00000000 + with the chunks displayed according to "display_endian". */ + int bytes_per_chunk; + enum bfd_endian display_endian; + + /* Number of host bytes per incremented target address + Normally one, but some DSPs have byte sizes of 16 or 32 + */ + int octets_per_byte; + + /* Results from instruction decoders. Not all decoders yet support + this information. This info is set each time an instruction is + decoded, and is only valid for the last such instruction. + + To determine whether this decoder supports this information, set + insn_info_valid to 0, decode an instruction, then check it. */ + + char insn_info_valid; /* Branch info has been set. */ + char branch_delay_insns; /* How many sequential insn's will run before + a branch takes effect. (0 = normal) */ + char data_size; /* Size of data reference in insn, in bytes */ + enum dis_insn_type insn_type; /* Type of instruction */ + bfd_vma target; /* Target address of branch or dref, if known; + zero if unknown. */ + bfd_vma target2; /* Second target address for dref2 */ + + /* Command line options specific to the target disassembler. */ + char * disassembler_options; + +} disassemble_info; + + +/* Standard disassemblers. Disassemble one instruction at the given + target address. Return number of bytes processed. */ +typedef int (*disassembler_ftype) + PARAMS((bfd_vma, disassemble_info *)); + +extern int print_insn_big_mips PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_little_mips PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_i386_att PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_i386_intel PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_ia64 PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_m68k PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_z8001 PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_z8002 PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_h8300 PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_h8300h PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_h8300s PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_h8500 PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_alpha PARAMS ((bfd_vma, disassemble_info*)); +extern disassembler_ftype arc_get_disassembler PARAMS ((int, int)); +extern int print_insn_big_arm PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_little_arm PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_sparc PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_big_a29k PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_little_a29k PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_i960 PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_sh PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_shl PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_hppa PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_fr30 PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_m32r PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_m88k PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_mcore PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_mn10200 PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_mn10300 PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_ns32k PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_big_powerpc PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_little_powerpc PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_rs6000 PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_w65 PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_d10v PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_d30v PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_v850 PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_tic30 PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_tic54x PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_vax PARAMS ((bfd_vma, disassemble_info*)); +extern int print_insn_tic80 PARAMS ((bfd_vma, disassemble_info*)); + +extern void print_arm_disassembler_options PARAMS ((FILE *)); +extern void parse_arm_disassembler_option PARAMS ((char *)); + +/* Fetch the disassembler for a given BFD, if that support is available. */ +extern disassembler_ftype disassembler PARAMS ((bfd *)); + +/* Document any target specific options available from the disassembler. */ +extern void disassembler_usage PARAMS ((FILE *)); + + +/* This block of definitions is for particular callers who read instructions + into a buffer before calling the instruction decoder. */ + +/* Here is a function which callers may wish to use for read_memory_func. + It gets bytes from a buffer. */ +extern int buffer_read_memory + PARAMS ((bfd_vma, bfd_byte *, int, struct disassemble_info *)); + +/* This function goes with buffer_read_memory. + It prints a message using info->fprintf_func and info->stream. */ +extern void perror_memory PARAMS ((int, bfd_vma, struct disassemble_info *)); + + +/* Just print the address in hex. This is included for completeness even + though both GDB and objdump provide their own (to print symbolic + addresses). */ +extern void generic_print_address + PARAMS ((bfd_vma, struct disassemble_info *)); + +/* Always true. */ +extern int generic_symbol_at_address + PARAMS ((bfd_vma, struct disassemble_info *)); + +/* Macro to initialize a disassemble_info struct. This should be called + by all applications creating such a struct. */ +#define INIT_DISASSEMBLE_INFO(INFO, STREAM, FPRINTF_FUNC) \ + (INFO).flavour = bfd_target_unknown_flavour, \ + (INFO).arch = bfd_arch_unknown, \ + (INFO).mach = 0, \ + (INFO).endian = BFD_ENDIAN_UNKNOWN, \ + (INFO).octets_per_byte = 1, \ + INIT_DISASSEMBLE_INFO_NO_ARCH(INFO, STREAM, FPRINTF_FUNC) + +/* Call this macro to initialize only the internal variables for the + disassembler. Architecture dependent things such as byte order, or machine + variant are not touched by this macro. This makes things much easier for + GDB which must initialize these things seperatly. */ + +#define INIT_DISASSEMBLE_INFO_NO_ARCH(INFO, STREAM, FPRINTF_FUNC) \ + (INFO).fprintf_func = (fprintf_ftype)(FPRINTF_FUNC), \ + (INFO).stream = (PTR)(STREAM), \ + (INFO).symbols = NULL, \ + (INFO).num_symbols = 0, \ + (INFO).buffer = NULL, \ + (INFO).buffer_vma = 0, \ + (INFO).buffer_length = 0, \ + (INFO).read_memory_func = buffer_read_memory, \ + (INFO).memory_error_func = perror_memory, \ + (INFO).print_address_func = generic_print_address, \ + (INFO).symbol_at_address_func = generic_symbol_at_address, \ + (INFO).flags = 0, \ + (INFO).bytes_per_line = 0, \ + (INFO).bytes_per_chunk = 0, \ + (INFO).display_endian = BFD_ENDIAN_UNKNOWN, \ + (INFO).insn_info_valid = 0 + +#endif /* ! defined (DIS_ASM_H) */ diff -urN test4.official/arch/ia64/kdb/ia64-asmtab.c test4.official.kdb/arch/ia64/kdb/ia64-asmtab.c --- test4.official/arch/ia64/kdb/ia64-asmtab.c Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/arch/ia64/kdb/ia64-asmtab.c Fri Aug 11 11:25:45 2000 @@ -0,0 +1,6562 @@ +/* This file is automatically generated by ia64-gen. Do not edit! */ +static const char *ia64_strings[] = { + "", "0", "1", "a", "acq", "add", "addl", "addp4", "adds", "alloc", "and", + "andcm", "b", "bias", "br", "break", "brl", "brp", "bsw", "c", "call", + "cexit", "chk", "cloop", "clr", "clrrrb", "cmp", "cmp4", "cmpxchg1", + "cmpxchg2", "cmpxchg4", "cmpxchg8", "cond", "cover", "ctop", "czx1", + "czx2", "d", "dc", "dep", "dpnt", "dptk", "e", "epc", "eq", "excl", + "exit", "exp", "extr", "f", "fabs", "fadd", "famax", "famin", "fand", + "fandcm", "fault", "fc", "fchkf", "fclass", "fclrf", "fcmp", "fcvt", + "fetchadd4", "fetchadd8", "few", "fill", "flushrs", "fma", "fmax", + "fmerge", "fmin", "fmix", "fmpy", "fms", "fneg", "fnegabs", "fnma", + "fnmpy", "fnorm", "for", "fpabs", "fpack", "fpamax", "fpamin", "fpcmp", + "fpcvt", "fpma", "fpmax", "fpmerge", "fpmin", "fpmpy", "fpms", "fpneg", + "fpnegabs", "fpnma", "fpnmpy", "fprcpa", "fprsqrta", "frcpa", "frsqrta", + "fselect", "fsetc", "fsub", "fswap", "fsxt", "fwb", "fx", "fxor", "fxu", + "g", "ga", "ge", "getf", "geu", "gt", "gtu", "h", "hu", "i", "ia", "imp", + "invala", "itc", "itr", "l", "ld1", "ld2", "ld4", "ld8", "ldf", "ldf8", + "ldfd", "ldfe", "ldfp8", "ldfpd", "ldfps", "ldfs", "le", "leu", "lfetch", + "loadrs", "loop", "lr", "lt", "ltu", "lu", "m", "many", "mf", "mix1", + "mix2", "mix4", "mov", "movl", "mux1", "mux2", "nc", "ne", "neq", "nge", + "ngt", "nl", "nle", "nlt", "nm", "nop", "nr", "ns", "nt", "nt1", "nt2", + "nta", "nz", "or", "orcm", "ord", "pack2", "pack4", "padd1", "padd2", + "padd4", "pavg1", "pavg2", "pavgsub1", "pavgsub2", "pcmp1", "pcmp2", + "pcmp4", "pmax1", "pmax2", "pmin1", "pmin2", "pmpy2", "pmpyshr2", + "popcnt", "pr", "probe", "psad1", "pshl2", "pshl4", "pshladd2", "pshr2", + "pshr4", "pshradd2", "psub1", "psub2", "psub4", "ptc", "ptr", "r", "raz", + "rel", "ret", "rfi", "rsm", "rum", "rw", "s", "s0", "s1", "s2", "s3", + "sa", "se", "setf", "shl", "shladd", "shladdp4", "shr", "shrp", "sig", + "spill", "spnt", "sptk", "srlz", "ssm", "sss", "st1", "st2", "st4", "st8", + "stf", "stf8", "stfd", "stfe", "stfs", "sub", "sum", "sxt1", "sxt2", + "sxt4", "sync", "tak", "tbit", "thash", "tk", "tnat", "tpa", "trunc", + "ttag", "u", "unc", "unord", "unpack1", "unpack2", "unpack4", "uss", + "uus", "uuu", "w", "wexit", "wtop", "x", "xchg1", "xchg2", "xchg4", + "xchg8", "xf", "xma", "xmpy", "xor", "xuf", "z", "zxt1", "zxt2", "zxt4", +}; + +static const struct ia64_dependency +dependencies[] = { + { "ALAT", 0, 0, 0, -1, }, + { "AR[BSP]", 25, 0, 2, 17, }, + { "AR[BSPSTORE]", 25, 0, 2, 18, }, + { "AR[CCV]", 25, 0, 2, 32, }, + { "AR[EC]", 25, 0, 2, 66, }, + { "AR[FPSR].sf0.controls", 29, 0, 2, -1, }, + { "AR[FPSR].sf1.controls", 29, 0, 2, -1, }, + { "AR[FPSR].sf2.controls", 29, 0, 2, -1, }, + { "AR[FPSR].sf3.controls", 29, 0, 2, -1, }, + { "AR[FPSR].sf0.flags", 29, 0, 2, -1, }, + { "AR[FPSR].sf1.flags", 29, 0, 2, -1, }, + { "AR[FPSR].sf2.flags", 29, 0, 2, -1, }, + { "AR[FPSR].sf3.flags", 29, 0, 2, -1, }, + { "AR[FPSR].traps", 29, 0, 2, -1, }, + { "AR[FPSR].rv", 29, 0, 2, -1, }, + { "AR[ITC]", 25, 0, 2, 44, }, + { "AR[K%], % in 0 - 7", 1, 0, 2, -1, }, + { "AR[LC]", 25, 0, 2, 65, }, + { "AR[PFS]", 25, 0, 2, 64, }, + { "AR[PFS]", 25, 0, 2, 64, }, + { "AR[PFS]", 25, 0, 0, 64, }, + { "AR[RNAT]", 25, 0, 2, 19, }, + { "AR[RSC]", 25, 0, 2, 16, }, + { "AR[UNAT]{%}, % in 0 - 63", 2, 0, 2, -1, }, + { "AR%, % in 8-15, 20, 22-23, 31, 33-35, 37-39, 41-43, 45-47, 67-111", 3, 0, 0, -1, }, + { "AR%, % in 48-63, 112-127", 4, 0, 2, -1, }, + { "BR%, % in 0 - 7", 5, 0, 2, -1, }, + { "BR%, % in 0 - 7", 5, 0, 0, -1, }, + { "BR%, % in 0 - 7", 5, 0, 2, -1, }, + { "CFM", 6, 0, 2, -1, }, + { "CFM", 6, 0, 2, -1, }, + { "CFM", 6, 0, 2, -1, }, + { "CFM", 6, 0, 2, -1, }, + { "CFM", 6, 0, 0, -1, }, + { "CPUID#", 7, 0, 5, -1, }, + { "CR[CMCV]", 26, 0, 3, 74, }, + { "CR[DCR]", 26, 0, 3, 0, }, + { "CR[EOI]", 26, 0, 6, 67, "SC Section 10.8.3.4", }, + { "CR[GPTA]", 26, 0, 3, 9, }, + { "CR[IFA]", 26, 0, 1, 20, }, + { "CR[IFA]", 26, 0, 3, 20, }, + { "CR[IFS]", 26, 0, 3, 23, }, + { "CR[IFS]", 26, 0, 1, 23, }, + { "CR[IFS]", 26, 0, 1, 23, }, + { "CR[IHA]", 26, 0, 3, 25, }, + { "CR[IIM]", 26, 0, 3, 24, }, + { "CR[IIP]", 26, 0, 3, 19, }, + { "CR[IIP]", 26, 0, 1, 19, }, + { "CR[IIPA]", 26, 0, 3, 22, }, + { "CR[IPSR]", 26, 0, 3, 16, }, + { "CR[IPSR]", 26, 0, 1, 16, }, + { "CR[IRR%], % in 0 - 3", 8, 0, 3, -1, }, + { "CR[ISR]", 26, 0, 3, 17, }, + { "CR[ITIR]", 26, 0, 3, 21, }, + { "CR[ITIR]", 26, 0, 1, 21, }, + { "CR[ITM]", 26, 0, 3, 1, }, + { "CR[ITV]", 26, 0, 3, 72, }, + { "CR[IVA]", 26, 0, 4, 2, }, + { "CR[IVR]", 26, 0, 6, 65, "SC Section 10.8.3.2", }, + { "CR[LID]", 26, 0, 6, 64, "SC Section 10.8.3.1", }, + { "CR[LRR%], % in 0 - 1", 9, 0, 3, -1, }, + { "CR[PMV]", 26, 0, 3, 73, }, + { "CR[PTA]", 26, 0, 3, 8, }, + { "CR[TPR]", 26, 0, 3, 66, }, + { "CR[TPR]", 26, 0, 6, 66, "SC Section 10.8.3.3", }, + { "CR%, % in 3-7, 10-15, 18, 26-63, 75-79, 82-127", 10, 0, 0, -1, }, + { "DBR#", 11, 0, 2, -1, }, + { "DBR#", 11, 0, 3, -1, }, + { "DTC", 0, 0, 3, -1, }, + { "DTC", 0, 0, 2, -1, }, + { "DTC", 0, 0, 0, -1, }, + { "DTC", 0, 0, 2, -1, }, + { "DTC_LIMIT*", 0, 0, 2, -1, }, + { "DTR", 0, 0, 3, -1, }, + { "DTR", 0, 0, 2, -1, }, + { "DTR", 0, 0, 3, -1, }, + { "DTR", 0, 0, 0, -1, }, + { "DTR", 0, 0, 2, -1, }, + { "FR%, % in 0 - 1", 12, 0, 0, -1, }, + { "FR%, % in 2 - 127", 13, 0, 2, -1, }, + { "FR%, % in 2 - 127", 13, 0, 0, -1, }, + { "GR0", 14, 0, 0, -1, }, + { "GR%, % in 1 - 127", 15, 0, 0, -1, }, + { "GR%, % in 1 - 127", 15, 0, 2, -1, }, + { "IBR#", 16, 0, 2, -1, }, + { "InService*", 17, 0, 3, -1, }, + { "InService*", 17, 0, 2, -1, }, + { "InService*", 17, 0, 2, -1, }, + { "IP", 0, 0, 0, -1, }, + { "ITC", 0, 0, 4, -1, }, + { "ITC", 0, 0, 2, -1, }, + { "ITC", 0, 0, 0, -1, }, + { "ITC", 0, 0, 4, -1, }, + { "ITC", 0, 0, 2, -1, }, + { "ITC_LIMIT*", 0, 0, 2, -1, }, + { "ITR", 0, 0, 2, -1, }, + { "ITR", 0, 0, 4, -1, }, + { "ITR", 0, 0, 2, -1, }, + { "ITR", 0, 0, 0, -1, }, + { "ITR", 0, 0, 4, -1, }, + { "memory", 0, 0, 0, -1, }, + { "MSR#", 18, 0, 5, -1, }, + { "PKR#", 19, 0, 3, -1, }, + { "PKR#", 19, 0, 0, -1, }, + { "PKR#", 19, 0, 2, -1, }, + { "PKR#", 19, 0, 2, -1, }, + { "PMC#", 20, 0, 2, -1, }, + { "PMC#", 20, 0, 6, -1, "SC+3 Section 12.1.1", }, + { "PMD#", 21, 0, 2, -1, }, + { "PR0", 0, 0, 0, -1, }, + { "PR%, % in 1 - 62", 22, 0, 2, -1, }, + { "PR%, % in 1 - 62", 22, 0, 2, -1, }, + { "PR%, % in 1 - 62", 22, 0, 0, -1, }, + { "PR63", 23, 0, 2, -1, }, + { "PR63", 23, 0, 2, -1, }, + { "PR63", 23, 0, 0, -1, }, + { "PSR.ac", 27, 0, 1, 3, }, + { "PSR.ac", 27, 0, 3, 3, }, + { "PSR.ac", 27, 0, 2, 3, }, + { "PSR.be", 27, 0, 1, 1, }, + { "PSR.be", 27, 0, 3, 1, }, + { "PSR.be", 27, 0, 2, 1, }, + { "PSR.bn", 27, 0, 2, 44, }, + { "PSR.cpl", 27, 0, 1, 32, }, + { "PSR.da", 27, 0, 3, 38, }, + { "PSR.db", 27, 0, 3, 24, }, + { "PSR.db", 27, 0, 2, 24, }, + { "PSR.db", 27, 0, 3, 24, }, + { "PSR.dd", 27, 0, 3, 39, }, + { "PSR.dfh", 27, 0, 3, 19, }, + { "PSR.dfh", 27, 0, 2, 19, }, + { "PSR.dfl", 27, 0, 3, 18, }, + { "PSR.dfl", 27, 0, 2, 18, }, + { "PSR.di", 27, 0, 3, 22, }, + { "PSR.di", 27, 0, 2, 22, }, + { "PSR.dt", 27, 0, 3, 17, }, + { "PSR.dt", 27, 0, 2, 17, }, + { "PSR.ed", 27, 0, 3, 43, }, + { "PSR.i", 27, 0, 2, 14, }, + { "PSR.i", 27, 0, 3, 14, }, + { "PSR.ia", 27, 0, 0, 14, }, + { "PSR.ic", 27, 0, 2, 13, }, + { "PSR.ic", 27, 0, 3, 13, }, + { "PSR.id", 27, 0, 0, 14, }, + { "PSR.is", 27, 0, 0, 14, }, + { "PSR.it", 27, 0, 3, 14, }, + { "PSR.lp", 27, 0, 2, 25, }, + { "PSR.lp", 27, 0, 3, 25, }, + { "PSR.lp", 27, 0, 3, 25, }, + { "PSR.mc", 27, 0, 0, 35, }, + { "PSR.mfh", 27, 0, 2, 5, }, + { "PSR.mfl", 27, 0, 2, 4, }, + { "PSR.pk", 27, 0, 3, 15, }, + { "PSR.pk", 27, 0, 2, 15, }, + { "PSR.pp", 27, 0, 2, 21, }, + { "PSR.ri", 27, 0, 0, 41, }, + { "PSR.rt", 27, 0, 2, 27, }, + { "PSR.rt", 27, 0, 3, 27, }, + { "PSR.rt", 27, 0, 3, 27, }, + { "PSR.si", 27, 0, 2, 23, }, + { "PSR.si", 27, 0, 3, 23, }, + { "PSR.sp", 27, 0, 2, 20, }, + { "PSR.sp", 27, 0, 3, 20, }, + { "PSR.ss", 27, 0, 3, 40, }, + { "PSR.tb", 27, 0, 3, 26, }, + { "PSR.tb", 27, 0, 2, 26, }, + { "PSR.up", 27, 0, 2, 2, }, + { "RR#", 24, 0, 3, -1, }, + { "RR#", 24, 0, 2, -1, }, + { "RSE", 28, 0, 2, -1, }, + { "ALAT", 0, 1, 0, -1, }, + { "AR[BSP]", 25, 1, 2, 17, }, + { "AR[BSPSTORE]", 25, 1, 2, 18, }, + { "AR[CCV]", 25, 1, 2, 32, }, + { "AR[EC]", 25, 1, 2, 66, }, + { "AR[FPSR].sf0.controls", 29, 1, 2, -1, }, + { "AR[FPSR].sf1.controls", 29, 1, 2, -1, }, + { "AR[FPSR].sf2.controls", 29, 1, 2, -1, }, + { "AR[FPSR].sf3.controls", 29, 1, 2, -1, }, + { "AR[FPSR].sf0.flags", 29, 1, 0, -1, }, + { "AR[FPSR].sf0.flags", 29, 1, 2, -1, }, + { "AR[FPSR].sf0.flags", 29, 1, 2, -1, }, + { "AR[FPSR].sf1.flags", 29, 1, 0, -1, }, + { "AR[FPSR].sf1.flags", 29, 1, 2, -1, }, + { "AR[FPSR].sf1.flags", 29, 1, 2, -1, }, + { "AR[FPSR].sf2.flags", 29, 1, 0, -1, }, + { "AR[FPSR].sf2.flags", 29, 1, 2, -1, }, + { "AR[FPSR].sf2.flags", 29, 1, 2, -1, }, + { "AR[FPSR].sf3.flags", 29, 1, 0, -1, }, + { "AR[FPSR].sf3.flags", 29, 1, 2, -1, }, + { "AR[FPSR].sf3.flags", 29, 1, 2, -1, }, + { "AR[FPSR].rv", 29, 1, 2, -1, }, + { "AR[FPSR].traps", 29, 1, 2, -1, }, + { "AR[ITC]", 25, 1, 2, 44, }, + { "AR[K%], % in 0 - 7", 1, 1, 2, -1, }, + { "AR[LC]", 25, 1, 2, 65, }, + { "AR[PFS]", 25, 1, 0, 64, }, + { "AR[PFS]", 25, 1, 2, 64, }, + { "AR[PFS]", 25, 1, 2, 64, }, + { "AR[RNAT]", 25, 1, 2, 19, }, + { "AR[RSC]", 25, 1, 2, 16, }, + { "AR[UNAT]{%}, % in 0 - 63", 2, 1, 2, -1, }, + { "AR%, % in 8-15, 20, 22-23, 31, 33-35, 37-39, 41-43, 45-47, 67-111", 3, 1, 0, -1, }, + { "AR%, % in 48 - 63, 112-127", 4, 1, 2, -1, }, + { "BR%, % in 0 - 7", 5, 1, 2, -1, }, + { "BR%, % in 0 - 7", 5, 1, 2, -1, }, + { "BR%, % in 0 - 7", 5, 1, 2, -1, }, + { "BR%, % in 0 - 7", 5, 1, 0, -1, }, + { "CFM", 6, 1, 2, -1, }, + { "CPUID#", 7, 1, 0, -1, }, + { "CR[CMCV]", 26, 1, 2, 74, }, + { "CR[DCR]", 26, 1, 2, 0, }, + { "CR[EOI]", 26, 1, 6, 67, "SC Section 10.8.3.4", }, + { "CR[GPTA]", 26, 1, 2, 9, }, + { "CR[IFA]", 26, 1, 2, 20, }, + { "CR[IFS]", 26, 1, 2, 23, }, + { "CR[IHA]", 26, 1, 2, 25, }, + { "CR[IIM]", 26, 1, 2, 24, }, + { "CR[IIP]", 26, 1, 2, 19, }, + { "CR[IIPA]", 26, 1, 2, 22, }, + { "CR[IPSR]", 26, 1, 2, 16, }, + { "CR[IRR%], % in 0 - 3", 8, 1, 2, -1, }, + { "CR[ISR]", 26, 1, 2, 17, }, + { "CR[ITIR]", 26, 1, 2, 21, }, + { "CR[ITM]", 26, 1, 2, 1, }, + { "CR[ITV]", 26, 1, 2, 72, }, + { "CR[IVA]", 26, 1, 2, 2, }, + { "CR[IVR]", 26, 1, 6, 65, "SC", }, + { "CR[LID]", 26, 1, 6, 64, "SC", }, + { "CR[LRR%], % in 0 - 1", 9, 1, 2, -1, }, + { "CR[PMV]", 26, 1, 2, 73, }, + { "CR[PTA]", 26, 1, 2, 8, }, + { "CR[TPR]", 26, 1, 2, 66, }, + { "CR%, % in 3-7, 10-15, 18, 26-63, 75-79, 82-127", 10, 1, 0, -1, }, + { "DBR#", 11, 1, 2, -1, }, + { "DTC", 0, 1, 0, -1, }, + { "DTC", 0, 1, 2, -1, }, + { "DTC", 0, 1, 2, -1, }, + { "DTC_LIMIT*", 0, 1, 2, -1, }, + { "DTR", 0, 1, 2, -1, }, + { "DTR", 0, 1, 2, -1, }, + { "DTR", 0, 1, 2, -1, }, + { "DTR", 0, 1, 0, -1, }, + { "FR%, % in 0 - 1", 12, 1, 0, -1, }, + { "FR%, % in 2 - 127", 13, 1, 2, -1, }, + { "GR0", 14, 1, 0, -1, }, + { "GR%, % in 1 - 127", 15, 1, 2, -1, }, + { "IBR#", 16, 1, 2, -1, }, + { "InService*", 17, 1, 6, -1, "SC", }, + { "IP", 0, 1, 0, -1, }, + { "ITC", 0, 1, 0, -1, }, + { "ITC", 0, 1, 2, -1, }, + { "ITC", 0, 1, 2, -1, }, + { "ITR", 0, 1, 2, -1, }, + { "ITR", 0, 1, 2, -1, }, + { "ITR", 0, 1, 0, -1, }, + { "memory", 0, 1, 0, -1, }, + { "MSR#", 18, 1, 6, -1, "SC", }, + { "PKR#", 19, 1, 0, -1, }, + { "PKR#", 19, 1, 0, -1, }, + { "PKR#", 19, 1, 2, -1, }, + { "PMC#", 20, 1, 2, -1, }, + { "PMD#", 21, 1, 2, -1, }, + { "PR0", 0, 1, 0, -1, }, + { "PR%, % in 1 - 62", 22, 1, 0, -1, }, + { "PR%, % in 1 - 62", 22, 1, 0, -1, }, + { "PR%, % in 1 - 62", 22, 1, 2, -1, }, + { "PR%, % in 1 - 62", 22, 1, 2, -1, }, + { "PR63", 23, 1, 0, -1, }, + { "PR63", 23, 1, 0, -1, }, + { "PR63", 23, 1, 2, -1, }, + { "PR63", 23, 1, 2, -1, }, + { "PSR.ac", 27, 1, 2, 3, }, + { "PSR.be", 27, 1, 2, 1, }, + { "PSR.bn", 27, 1, 2, 44, }, + { "PSR.cpl", 27, 1, 2, 32, }, + { "PSR.da", 27, 1, 2, 38, }, + { "PSR.db", 27, 1, 2, 24, }, + { "PSR.dd", 27, 1, 2, 39, }, + { "PSR.dfh", 27, 1, 2, 19, }, + { "PSR.dfl", 27, 1, 2, 18, }, + { "PSR.di", 27, 1, 2, 22, }, + { "PSR.dt", 27, 1, 2, 17, }, + { "PSR.ed", 27, 1, 2, 43, }, + { "PSR.i", 27, 1, 2, 14, }, + { "PSR.ia", 27, 1, 2, 14, }, + { "PSR.ic", 27, 1, 2, 13, }, + { "PSR.id", 27, 1, 2, 14, }, + { "PSR.is", 27, 1, 2, 14, }, + { "PSR.it", 27, 1, 2, 14, }, + { "PSR.lp", 27, 1, 2, 25, }, + { "PSR.mc", 27, 1, 2, 35, }, + { "PSR.mfh", 27, 1, 0, 5, }, + { "PSR.mfh", 27, 1, 2, 5, }, + { "PSR.mfh", 27, 1, 2, 5, }, + { "PSR.mfl", 27, 1, 0, 4, }, + { "PSR.mfl", 27, 1, 2, 4, }, + { "PSR.mfl", 27, 1, 2, 4, }, + { "PSR.pk", 27, 1, 2, 15, }, + { "PSR.pp", 27, 1, 2, 21, }, + { "PSR.ri", 27, 1, 2, 41, }, + { "PSR.rt", 27, 1, 2, 27, }, + { "PSR.si", 27, 1, 2, 23, }, + { "PSR.sp", 27, 1, 2, 20, }, + { "PSR.ss", 27, 1, 2, 40, }, + { "PSR.tb", 27, 1, 2, 26, }, + { "PSR.up", 27, 1, 2, 2, }, + { "RR#", 24, 1, 2, -1, }, + { "RSE", 28, 1, 2, -1, }, + { "PR63", 23, 2, 2, -1, }, +}; + +static const short dep0[] = { + 88, 249, 2131, 2294, +}; + +static const short dep1[] = { + 32, 33, 88, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2294, 4127, 20602, + +}; + +static const short dep2[] = { + 2131, 2294, +}; + +static const short dep3[] = { + 32, 33, 2129, 2130, 2131, 2294, 4127, 20602, +}; + +static const short dep4[] = { + 32, 33, 81, 88, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2294, 4127, + 20602, +}; + +static const short dep5[] = { + 88, 249, 2157, 2158, 2160, 2161, 2163, 2311, 2314, 2315, 2318, 2319, +}; + +static const short dep6[] = { + 32, 33, 88, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2311, 2314, 2315, + 2318, 2319, 4127, 20602, +}; + +static const short dep7[] = { + 88, 249, 22637, 22638, 22640, 22641, 22643, 22791, 22794, 22795, 22798, 22799, + +}; + +static const short dep8[] = { + 32, 33, 88, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 4127, 20602, 22791, + 22794, 22795, 22798, 22799, +}; + +static const short dep9[] = { + 88, 249, 2312, 2314, 2316, 2318, +}; + +static const short dep10[] = { + 32, 33, 88, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2312, 2315, 2316, + 2319, 4127, 20602, +}; + +static const short dep11[] = { + 88, 249, 2313, 2315, 2317, 2319, +}; + +static const short dep12[] = { + 32, 33, 88, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2313, 2314, 2317, + 2318, 4127, 20602, +}; + +static const short dep13[] = { + 88, 249, 2312, 2313, 2314, 2315, 2316, 2317, 2318, 2319, +}; + +static const short dep14[] = { + 32, 33, 88, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2312, 2313, 2314, + 2315, 2316, 2317, 2318, 2319, 4127, 20602, +}; + +static const short dep15[] = { + 88, 249, 2357, +}; + +static const short dep16[] = { + 32, 33, 88, 145, 163, 164, 249, 2074, 2075, 2157, 2159, 2160, 2162, 2163, + 4127, +}; + +static const short dep17[] = { + 88, 144, 249, 288, 2357, 28841, 28980, +}; + +static const short dep18[] = { + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21, 22, + 23, 24, 25, 32, 33, 88, 133, 145, 163, 164, 249, 288, 2074, 2075, 2157, 2159, + 2160, 2162, 2163, 4127, 28841, 28980, +}; + +static const short dep19[] = { + 1, 4, 32, 88, 123, 171, 174, 208, 249, 275, 2357, 28841, 28980, +}; + +static const short dep20[] = { + 1, 18, 20, 30, 32, 33, 88, 145, 147, 148, 163, 164, 171, 174, 208, 249, 275, + 2074, 2075, 2157, 2159, 2160, 2162, 2163, 4127, 28841, 28980, +}; + +static const short dep21[] = { + 1, 32, 43, 88, 171, 208, 215, 249, 28841, 28980, +}; + +static const short dep22[] = { + 1, 30, 32, 33, 88, 142, 163, 171, 208, 215, 249, 4127, 28841, 28980, +}; + +static const short dep23[] = { + 32, 88, 208, 249, +}; + +static const short dep24[] = { + 88, 163, 208, 249, +}; + +static const short dep25[] = { + 1, 32, 88, 117, 118, 120, 121, 122, 123, 124, 127, 128, 129, 130, 131, 132, + 133, 134, 135, 136, 137, 139, 140, 141, 142, 143, 144, 145, 148, 149, 150, + 151, 152, 153, 154, 155, 158, 159, 160, 161, 162, 163, 164, 165, 166, 171, + 208, 249, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 293, 294, 296, 297, 298, 299, 300, 301, + 302, 303, 304, 305, 306, 28841, 28980, +}; + +static const short dep26[] = { + 1, 30, 32, 33, 42, 43, 47, 50, 64, 88, 123, 163, 171, 208, 249, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, 293, 294, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 4127, 28841, 28980, +}; + +static const short dep27[] = { + 88, 122, 249, 274, +}; + +static const short dep28[] = { + 88, 123, 163, 249, 274, +}; + +static const short dep29[] = { + 88, 123, 249, 275, +}; + +static const short dep30[] = { + 18, 19, 88, 89, 92, 96, 99, 123, 145, 163, 249, 275, +}; + +static const short dep31[] = { + 32, 33, 88, 163, 249, 2157, 2159, 2160, 2162, 2163, 4127, +}; + +static const short dep32[] = { + 1, 18, 32, 88, 171, 196, 197, 208, 249, 2074, 2252, 2255, 2357, 28841, 28980, + +}; + +static const short dep33[] = { + 1, 4, 30, 32, 33, 88, 123, 145, 163, 164, 171, 196, 198, 208, 249, 2074, 2075, + 2157, 2159, 2160, 2162, 2163, 2253, 2255, 4127, 28841, 28980, +}; + +static const short dep34[] = { + 88, 249, +}; + +static const short dep35[] = { + 88, 163, 249, 2074, 2076, +}; + +static const short dep36[] = { + 32, 33, 88, 145, 163, 164, 249, 2157, 2159, 2160, 2162, 2163, 4127, +}; + +static const short dep37[] = { + 4, 29, 30, 31, 88, 113, 114, 174, 208, 249, 270, 271, 2357, +}; + +static const short dep38[] = { + 4, 29, 32, 33, 88, 145, 163, 164, 174, 208, 249, 270, 271, 309, 2157, 2159, + 2160, 2162, 2163, 4127, +}; + +static const short dep39[] = { + 17, 88, 195, 249, 2357, +}; + +static const short dep40[] = { + 17, 32, 33, 88, 145, 163, 164, 195, 249, 2157, 2159, 2160, 2162, 2163, 4127, + +}; + +static const short dep41[] = { + 4, 17, 29, 30, 31, 88, 113, 114, 174, 195, 208, 249, 270, 271, 2357, +}; + +static const short dep42[] = { + 4, 17, 29, 32, 33, 88, 145, 163, 164, 174, 195, 208, 249, 270, 271, 309, 2157, + 2159, 2160, 2162, 2163, 4127, +}; + +static const short dep43[] = { + 1, 4, 30, 32, 33, 88, 123, 145, 163, 164, 171, 196, 198, 208, 249, 2157, 2159, + 2160, 2162, 2163, 2253, 2255, 4127, 28841, 28980, +}; + +static const short dep44[] = { + 88, 163, 249, +}; + +static const short dep45[] = { + 9, 88, 179, 180, 249, 2127, 2292, 18582, 18583, 18724, 18725, 18727, 18728, + 22637, 22638, 22639, 22641, 22642, 22791, 22794, 22795, 22798, 22799, +}; + +static const short dep46[] = { + 5, 13, 14, 32, 33, 88, 163, 179, 181, 249, 2126, 2127, 2128, 2157, 2158, 2161, + 2292, 4127, 16513, 16515, 18724, 18726, 18727, 18729, 22791, 22794, 22795, + 22798, 22799, +}; + +static const short dep47[] = { + 9, 10, 11, 12, 88, 179, 180, 182, 183, 185, 186, 188, 189, 249, 2127, 2292, + 18582, 18583, 18724, 18725, 18727, 18728, 22637, 22638, 22639, 22641, 22642, + 22791, 22794, 22795, 22798, 22799, +}; + +static const short dep48[] = { + 5, 6, 7, 8, 13, 14, 32, 33, 88, 163, 179, 181, 182, 184, 185, 187, 188, 190, + 249, 2126, 2127, 2128, 2157, 2158, 2161, 2292, 4127, 16513, 16515, 18724, + 18726, 18727, 18729, 22791, 22794, 22795, 22798, 22799, +}; + +static const short dep49[] = { + 10, 88, 182, 183, 249, 2127, 2292, 18582, 18583, 18724, 18725, 18727, 18728, + 22637, 22638, 22639, 22641, 22642, 22791, 22794, 22795, 22798, 22799, +}; + +static const short dep50[] = { + 6, 13, 14, 32, 33, 88, 163, 182, 184, 249, 2126, 2127, 2128, 2157, 2158, 2161, + 2292, 4127, 16513, 16515, 18724, 18726, 18727, 18729, 22791, 22794, 22795, + 22798, 22799, +}; + +static const short dep51[] = { + 11, 88, 185, 186, 249, 2127, 2292, 18582, 18583, 18724, 18725, 18727, 18728, + 22637, 22638, 22639, 22641, 22642, 22791, 22794, 22795, 22798, 22799, +}; + +static const short dep52[] = { + 7, 13, 14, 32, 33, 88, 163, 185, 187, 249, 2126, 2127, 2128, 2157, 2158, 2161, + 2292, 4127, 16513, 16515, 18724, 18726, 18727, 18729, 22791, 22794, 22795, + 22798, 22799, +}; + +static const short dep53[] = { + 12, 88, 188, 189, 249, 2127, 2292, 18582, 18583, 18724, 18725, 18727, 18728, + 22637, 22638, 22639, 22641, 22642, 22791, 22794, 22795, 22798, 22799, +}; + +static const short dep54[] = { + 8, 13, 14, 32, 33, 88, 163, 188, 190, 249, 2126, 2127, 2128, 2157, 2158, 2161, + 2292, 4127, 16513, 16515, 18724, 18726, 18727, 18729, 22791, 22794, 22795, + 22798, 22799, +}; + +static const short dep55[] = { + 9, 88, 179, 180, 249, 2127, 2292, 18582, 18583, 18724, 18725, 18727, 18728, + +}; + +static const short dep56[] = { + 5, 13, 14, 32, 33, 88, 163, 179, 181, 249, 2126, 2127, 2128, 2157, 2158, 2161, + 2292, 4127, 16513, 16515, 18724, 18726, 18727, 18729, +}; + +static const short dep57[] = { + 9, 10, 11, 12, 88, 179, 180, 182, 183, 185, 186, 188, 189, 249, 2127, 2292, + 18582, 18583, 18724, 18725, 18727, 18728, +}; + +static const short dep58[] = { + 5, 6, 7, 8, 13, 14, 32, 33, 88, 163, 179, 181, 182, 184, 185, 187, 188, 190, + 249, 2126, 2127, 2128, 2157, 2158, 2161, 2292, 4127, 16513, 16515, 18724, + 18726, 18727, 18729, +}; + +static const short dep59[] = { + 10, 88, 182, 183, 249, 2127, 2292, 18582, 18583, 18724, 18725, 18727, 18728, + +}; + +static const short dep60[] = { + 6, 13, 14, 32, 33, 88, 163, 182, 184, 249, 2126, 2127, 2128, 2157, 2158, 2161, + 2292, 4127, 16513, 16515, 18724, 18726, 18727, 18729, +}; + +static const short dep61[] = { + 11, 88, 185, 186, 249, 2127, 2292, 18582, 18583, 18724, 18725, 18727, 18728, + +}; + +static const short dep62[] = { + 7, 13, 14, 32, 33, 88, 163, 185, 187, 249, 2126, 2127, 2128, 2157, 2158, 2161, + 2292, 4127, 16513, 16515, 18724, 18726, 18727, 18729, +}; + +static const short dep63[] = { + 12, 88, 188, 189, 249, 2127, 2292, 18582, 18583, 18724, 18725, 18727, 18728, + +}; + +static const short dep64[] = { + 8, 13, 14, 32, 33, 88, 163, 188, 190, 249, 2126, 2127, 2128, 2157, 2158, 2161, + 2292, 4127, 16513, 16515, 18724, 18726, 18727, 18729, +}; + +static const short dep65[] = { + 88, 249, 2127, 2292, 18582, 18583, 18724, 18725, 18727, 18728, +}; + +static const short dep66[] = { + 32, 33, 88, 163, 249, 2126, 2127, 2128, 2157, 2158, 2161, 2292, 4127, 16513, + 16515, 18724, 18726, 18727, 18729, +}; + +static const short dep67[] = { + 5, 88, 175, 249, +}; + +static const short dep68[] = { + 5, 32, 33, 88, 163, 175, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep69[] = { + 5, 32, 33, 88, 163, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep70[] = { + 6, 88, 176, 249, +}; + +static const short dep71[] = { + 5, 32, 33, 88, 163, 176, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep72[] = { + 7, 88, 177, 249, +}; + +static const short dep73[] = { + 5, 32, 33, 88, 163, 177, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep74[] = { + 8, 88, 178, 249, +}; + +static const short dep75[] = { + 5, 32, 33, 88, 163, 178, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep76[] = { + 9, 88, 180, 181, 249, +}; + +static const short dep77[] = { + 32, 33, 88, 163, 180, 181, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep78[] = { + 32, 33, 88, 163, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep79[] = { + 10, 88, 183, 184, 249, +}; + +static const short dep80[] = { + 32, 33, 88, 163, 183, 184, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep81[] = { + 11, 88, 186, 187, 249, +}; + +static const short dep82[] = { + 32, 33, 88, 163, 186, 187, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep83[] = { + 12, 88, 189, 190, 249, +}; + +static const short dep84[] = { + 32, 33, 88, 163, 189, 190, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep85[] = { + 9, 13, 14, 32, 33, 88, 145, 163, 164, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep86[] = { + 9, 10, 13, 14, 32, 33, 88, 145, 163, 164, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep87[] = { + 9, 11, 13, 14, 32, 33, 88, 145, 163, 164, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep88[] = { + 9, 12, 13, 14, 32, 33, 88, 145, 163, 164, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep89[] = { + 9, 88, 179, 180, 249, +}; + +static const short dep90[] = { + 5, 13, 14, 32, 33, 88, 163, 179, 181, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep91[] = { + 9, 10, 11, 12, 88, 179, 180, 182, 183, 185, 186, 188, 189, 249, +}; + +static const short dep92[] = { + 5, 6, 7, 8, 13, 14, 32, 33, 88, 163, 179, 181, 182, 184, 185, 187, 188, 190, + 249, 2157, 2158, 2161, 4127, +}; + +static const short dep93[] = { + 10, 88, 182, 183, 249, +}; + +static const short dep94[] = { + 6, 13, 14, 32, 33, 88, 163, 182, 184, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep95[] = { + 11, 88, 185, 186, 249, +}; + +static const short dep96[] = { + 7, 13, 14, 32, 33, 88, 163, 185, 187, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep97[] = { + 12, 88, 188, 189, 249, +}; + +static const short dep98[] = { + 8, 13, 14, 32, 33, 88, 163, 188, 190, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep99[] = { + 9, 88, 179, 180, 249, 2157, 2158, 2159, 2161, 2162, 2311, 2314, 2315, 2318, + 2319, +}; + +static const short dep100[] = { + 5, 13, 14, 32, 33, 88, 163, 179, 181, 249, 2126, 2127, 2128, 2157, 2158, 2161, + 2311, 2314, 2315, 2318, 2319, 4127, 16513, 16515, +}; + +static const short dep101[] = { + 9, 10, 11, 12, 88, 179, 180, 182, 183, 185, 186, 188, 189, 249, 2157, 2158, + 2159, 2161, 2162, 2311, 2314, 2315, 2318, 2319, +}; + +static const short dep102[] = { + 5, 6, 7, 8, 13, 14, 32, 33, 88, 163, 179, 181, 182, 184, 185, 187, 188, 190, + 249, 2126, 2127, 2128, 2157, 2158, 2161, 2311, 2314, 2315, 2318, 2319, 4127, + 16513, 16515, +}; + +static const short dep103[] = { + 10, 88, 182, 183, 249, 2157, 2158, 2159, 2161, 2162, 2311, 2314, 2315, 2318, + 2319, +}; + +static const short dep104[] = { + 6, 13, 14, 32, 33, 88, 163, 182, 184, 249, 2126, 2127, 2128, 2157, 2158, 2161, + 2311, 2314, 2315, 2318, 2319, 4127, 16513, 16515, +}; + +static const short dep105[] = { + 11, 88, 185, 186, 249, 2157, 2158, 2159, 2161, 2162, 2311, 2314, 2315, 2318, + 2319, +}; + +static const short dep106[] = { + 7, 13, 14, 32, 33, 88, 163, 185, 187, 249, 2126, 2127, 2128, 2157, 2158, 2161, + 2311, 2314, 2315, 2318, 2319, 4127, 16513, 16515, +}; + +static const short dep107[] = { + 12, 88, 188, 189, 249, 2157, 2158, 2159, 2161, 2162, 2311, 2314, 2315, 2318, + 2319, +}; + +static const short dep108[] = { + 8, 13, 14, 32, 33, 88, 163, 188, 190, 249, 2126, 2127, 2128, 2157, 2158, 2161, + 2311, 2314, 2315, 2318, 2319, 4127, 16513, 16515, +}; + +static const short dep109[] = { + 9, 88, 179, 180, 249, 22637, 22638, 22639, 22641, 22642, 22791, 22794, 22795, + 22798, 22799, +}; + +static const short dep110[] = { + 5, 13, 14, 32, 33, 88, 163, 179, 181, 249, 2126, 2127, 2128, 2157, 2158, 2161, + 4127, 16513, 16515, 22791, 22794, 22795, 22798, 22799, +}; + +static const short dep111[] = { + 9, 10, 11, 12, 88, 179, 180, 182, 183, 185, 186, 188, 189, 249, 22637, 22638, + 22639, 22641, 22642, 22791, 22794, 22795, 22798, 22799, +}; + +static const short dep112[] = { + 5, 6, 7, 8, 13, 14, 32, 33, 88, 163, 179, 181, 182, 184, 185, 187, 188, 190, + 249, 2126, 2127, 2128, 2157, 2158, 2161, 4127, 16513, 16515, 22791, 22794, + 22795, 22798, 22799, +}; + +static const short dep113[] = { + 10, 88, 182, 183, 249, 22637, 22638, 22639, 22641, 22642, 22791, 22794, 22795, + 22798, 22799, +}; + +static const short dep114[] = { + 6, 13, 14, 32, 33, 88, 163, 182, 184, 249, 2126, 2127, 2128, 2157, 2158, 2161, + 4127, 16513, 16515, 22791, 22794, 22795, 22798, 22799, +}; + +static const short dep115[] = { + 11, 88, 185, 186, 249, 22637, 22638, 22639, 22641, 22642, 22791, 22794, 22795, + 22798, 22799, +}; + +static const short dep116[] = { + 7, 13, 14, 32, 33, 88, 163, 185, 187, 249, 2126, 2127, 2128, 2157, 2158, 2161, + 4127, 16513, 16515, 22791, 22794, 22795, 22798, 22799, +}; + +static const short dep117[] = { + 12, 88, 188, 189, 249, 22637, 22638, 22639, 22641, 22642, 22791, 22794, 22795, + 22798, 22799, +}; + +static const short dep118[] = { + 8, 13, 14, 32, 33, 88, 163, 188, 190, 249, 2126, 2127, 2128, 2157, 2158, 2161, + 4127, 16513, 16515, 22791, 22794, 22795, 22798, 22799, +}; + +static const short dep119[] = { + 88, 249, 2157, 2158, 2159, 2161, 2162, 2311, 2314, 2315, 2318, 2319, +}; + +static const short dep120[] = { + 32, 33, 88, 163, 249, 2126, 2127, 2128, 2157, 2158, 2161, 2311, 2314, 2315, + 2318, 2319, 4127, 16513, 16515, +}; + +static const short dep121[] = { + 88, 249, 22637, 22638, 22639, 22641, 22642, 22791, 22794, 22795, 22798, 22799, + +}; + +static const short dep122[] = { + 32, 33, 88, 163, 249, 2126, 2127, 2128, 2157, 2158, 2161, 4127, 16513, 16515, + 22791, 22794, 22795, 22798, 22799, +}; + +static const short dep123[] = { + 13, 14, 32, 33, 88, 163, 249, 2126, 2127, 2128, 2157, 2158, 2161, 2292, 4127, + 16513, 16515, 18724, 18726, 18727, 18729, +}; + +static const short dep124[] = { + 32, 33, 88, 145, 163, 164, 249, 2129, 2130, 2131, 2157, 2158, 2161, 4127, + 20602, +}; + +static const short dep125[] = { + 88, 249, 2075, 2076, 2253, 2254, +}; + +static const short dep126[] = { + 32, 33, 88, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2252, 2254, 4127, + 20602, +}; + +static const short dep127[] = { + 32, 33, 88, 163, 249, 2074, 2076, 2157, 2158, 2161, 2294, 4127, 20602, +}; + +static const short dep128[] = { + 88, 249, 14446, 14448, 14449, 14451, 14602, 14603, 14606, 14607, +}; + +static const short dep129[] = { + 32, 33, 88, 163, 249, 2129, 2130, 2131, 4127, 14602, 14603, 14606, 14607, + 20602, 24685, 24686, 24689, +}; + +static const short dep130[] = { + 88, 110, 112, 113, 115, 249, 14602, 14603, 14606, 14607, +}; + +static const short dep131[] = { + 32, 33, 88, 163, 249, 4127, 14602, 14603, 14606, 14607, 24685, 24686, 24689, + +}; + +static const short dep132[] = { + 32, 33, 88, 163, 249, 2157, 2158, 2161, 2294, 4127, 20602, +}; + +static const short dep133[] = { + 32, 33, 88, 110, 113, 163, 249, 2294, 4127, 20602, 24685, +}; + +static const short dep134[] = { + 4, 17, 19, 20, 88, 174, 195, 198, 249, 2073, 2251, +}; + +static const short dep135[] = { + 32, 33, 88, 163, 174, 195, 197, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2251, + 4127, 20602, +}; + +static const short dep136[] = { + 4, 17, 18, 19, 32, 33, 88, 163, 249, 2073, 2157, 2158, 2161, 2294, 4127, 20602, + +}; + +static const short dep137[] = { + 0, 32, 33, 88, 145, 163, 164, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep138[] = { + 0, 88, 170, 249, +}; + +static const short dep139[] = { + 0, 32, 33, 88, 145, 163, 164, 170, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep140[] = { + 32, 33, 88, 163, 170, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep141[] = { + 2, 21, 88, 172, 199, 249, 28841, 28980, +}; + +static const short dep142[] = { + 1, 2, 21, 22, 88, 157, 158, 163, 172, 199, 249, 28841, 28980, +}; + +static const short dep143[] = { + 1, 21, 22, 30, 32, 33, 88, 157, 158, 163, 172, 199, 249, 4127, 28841, 28980, + +}; + +static const short dep144[] = { + 0, 32, 33, 88, 163, 170, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep145[] = { + 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 21, 22, 23, 88, 171, 172, + 173, 175, 176, 177, 178, 180, 181, 183, 184, 186, 187, 189, 190, 191, 192, + 193, 199, 200, 201, 249, 2064, 2073, 2242, 2251, 28841, 28980, +}; + +static const short dep146[] = { + 22, 32, 33, 88, 123, 163, 171, 172, 173, 175, 176, 177, 178, 180, 181, 183, + 184, 186, 187, 189, 190, 191, 192, 193, 199, 200, 201, 249, 2129, 2130, 2131, + 2157, 2158, 2161, 2242, 2251, 4127, 20602, 28841, 28980, +}; + +static const short dep147[] = { + 88, 249, 14452, 14454, 14455, 14457, 14486, 14487, 14502, 14608, 14609, 14629, + 14630, 14632, 14633, 14642, +}; + +static const short dep148[] = { + 32, 33, 88, 162, 163, 249, 2157, 2158, 2161, 4127, 14608, 14609, 14629, 14630, + 14632, 14633, 14642, +}; + +static const short dep149[] = { + 14452, 14454, 14455, 14457, 14486, 14487, 14502, 14608, 14609, 14629, 14630, + 14632, 14633, 14642, +}; + +static const short dep150[] = { + 162, 14608, 14609, 14629, 14630, 14632, 14633, 14642, +}; + +static const short dep151[] = { + 88, 249, 14453, 14454, 14456, 14457, 14465, 14466, 14467, 14468, 14469, 14470, + 14471, 14472, 14474, 14477, 14478, 14486, 14487, 14488, 14489, 14490, 14495, + 14496, 14497, 14498, 14502, 14608, 14609, 14615, 14616, 14617, 14618, 14620, + 14622, 14629, 14630, 14632, 14633, 14634, 14635, 14638, 14639, 14642, +}; + +static const short dep152[] = { + 32, 33, 64, 88, 123, 163, 249, 2157, 2158, 2161, 4127, 14608, 14609, 14615, + 14616, 14617, 14618, 14620, 14622, 14629, 14630, 14632, 14633, 14634, 14635, + 14638, 14639, 14642, +}; + +static const short dep153[] = { + 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 21, 22, 23, 32, 33, 88, 123, + 160, 163, 249, 2064, 2073, 2157, 2158, 2161, 2294, 4127, 20602, 28841, +}; + +static const short dep154[] = { + 35, 36, 37, 38, 39, 40, 41, 42, 44, 45, 46, 47, 48, 49, 50, 52, 53, 54, 55, + 56, 57, 59, 61, 62, 63, 64, 85, 87, 88, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, 220, 222, 223, 224, 225, 226, 228, 230, 231, 232, 248, 249, + 2108, 2277, +}; + +static const short dep155[] = { + 32, 33, 87, 88, 123, 142, 163, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, 220, 222, 223, 224, 225, 226, 228, 230, 231, 232, 248, 249, 2129, 2130, + 2131, 2157, 2158, 2161, 2277, 4127, 20602, +}; + +static const short dep156[] = { + 51, 86, 88, 221, 248, 249, 2131, 2294, +}; + +static const short dep157[] = { + 32, 33, 35, 36, 38, 40, 41, 43, 44, 45, 46, 48, 49, 52, 53, 55, 56, 57, 58, + 59, 61, 62, 63, 85, 86, 88, 123, 142, 163, 221, 248, 249, 2099, 2108, 2157, + 2158, 2161, 2294, 4127, 20602, +}; + +static const short dep158[] = { + 2, 21, 33, 88, 172, 199, 208, 249, 2131, 2294, 28841, 28980, +}; + +static const short dep159[] = { + 2, 18, 19, 21, 22, 30, 32, 33, 88, 157, 158, 163, 172, 199, 208, 249, 2294, + 4127, 20602, 28841, 28980, +}; + +static const short dep160[] = { + 88, 117, 118, 120, 121, 125, 126, 129, 130, 131, 132, 133, 134, 135, 136, + 138, 141, 142, 146, 147, 150, 151, 152, 153, 154, 156, 157, 159, 160, 161, + 162, 164, 165, 166, 249, 272, 273, 277, 279, 280, 281, 282, 284, 286, 290, + 293, 294, 296, 297, 298, 299, 301, 302, 303, 305, 306, +}; + +static const short dep161[] = { + 32, 33, 64, 88, 123, 163, 249, 272, 273, 277, 279, 280, 281, 282, 284, 286, + 290, 293, 294, 296, 297, 298, 299, 301, 302, 303, 305, 306, 2129, 2130, 2131, + 2157, 2158, 2161, 4127, 20602, +}; + +static const short dep162[] = { + 88, 116, 118, 119, 121, 150, 151, 166, 249, 272, 273, 293, 294, 296, 297, + 306, +}; + +static const short dep163[] = { + 32, 33, 88, 162, 163, 249, 272, 273, 293, 294, 296, 297, 306, 2129, 2130, + 2131, 2157, 2158, 2161, 4127, 20602, +}; + +static const short dep164[] = { + 32, 33, 88, 118, 121, 123, 126, 127, 130, 132, 134, 136, 138, 139, 141, 145, + 146, 148, 149, 150, 151, 153, 154, 156, 158, 159, 161, 163, 165, 166, 249, + 2157, 2158, 2161, 2294, 4127, 20602, +}; + +static const short dep165[] = { + 32, 33, 88, 118, 121, 150, 151, 163, 166, 249, 2157, 2158, 2161, 2294, 4127, + 20602, +}; + +static const short dep166[] = { + 32, 33, 67, 68, 73, 75, 88, 102, 123, 152, 163, 167, 249, 2129, 2130, 2131, + 2157, 2158, 2161, 2294, 4127, 20602, +}; + +static const short dep167[] = { + 32, 33, 67, 68, 73, 75, 88, 102, 123, 124, 125, 127, 128, 152, 163, 167, 249, + 2129, 2130, 2131, 2157, 2158, 2161, 4127, 20602, +}; + +static const short dep168[] = { + 68, 69, 88, 92, 93, 236, 237, 249, 251, 252, +}; + +static const short dep169[] = { + 32, 33, 39, 54, 69, 71, 77, 88, 90, 93, 123, 142, 163, 167, 236, 237, 249, + 251, 252, 2129, 2130, 2131, 2157, 2158, 2161, 4127, 20602, +}; + +static const short dep170[] = { + 32, 33, 39, 54, 69, 71, 88, 90, 93, 95, 97, 123, 142, 163, 167, 236, 237, + 249, 251, 252, 2129, 2130, 2131, 2157, 2158, 2161, 4127, 20602, +}; + +static const short dep171[] = { + 88, 249, 12455, 12456, 12595, +}; + +static const short dep172[] = { + 32, 33, 88, 123, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 4127, 12595, + 20602, +}; + +static const short dep173[] = { + 88, 249, 6210, 6211, 6378, +}; + +static const short dep174[] = { + 32, 33, 88, 123, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 4127, 6378, + 20602, +}; + +static const short dep175[] = { + 88, 249, 6228, 6391, +}; + +static const short dep176[] = { + 32, 33, 88, 123, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 4127, 6391, + 20602, +}; + +static const short dep177[] = { + 88, 249, 6246, 6247, 6248, 6249, 6402, 6404, 8451, +}; + +static const short dep178[] = { + 32, 33, 88, 123, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 4127, 6249, + 6403, 6404, 8295, 8450, 20602, +}; + +static const short dep179[] = { + 88, 249, 6250, 6251, 6405, +}; + +static const short dep180[] = { + 32, 33, 88, 123, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 4127, 6405, + 20602, +}; + +static const short dep181[] = { + 88, 249, 6252, 6406, +}; + +static const short dep182[] = { + 32, 33, 88, 123, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 4127, 6406, + 20602, +}; + +static const short dep183[] = { + 88, 249, 10341, 10497, +}; + +static const short dep184[] = { + 32, 33, 88, 123, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 4127, 10497, + 20602, +}; + +static const short dep185[] = { + 68, 69, 73, 74, 88, 92, 93, 236, 237, 239, 240, 249, 251, 252, +}; + +static const short dep186[] = { + 32, 33, 39, 69, 71, 74, 77, 88, 90, 93, 123, 142, 163, 167, 236, 237, 239, + 241, 249, 251, 252, 2129, 2130, 2131, 2157, 2158, 2161, 4127, 20602, +}; + +static const short dep187[] = { + 68, 69, 88, 92, 93, 95, 96, 236, 237, 249, 251, 252, 253, 254, +}; + +static const short dep188[] = { + 32, 33, 39, 54, 69, 71, 88, 90, 93, 95, 97, 123, 142, 163, 167, 236, 237, + 249, 251, 252, 253, 254, 2129, 2130, 2131, 2157, 2158, 2161, 4127, 20602, + +}; + +static const short dep189[] = { + 32, 33, 88, 123, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2294, 4127, + 12456, 20602, +}; + +static const short dep190[] = { + 32, 33, 88, 123, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2294, 4127, + 6210, 20602, +}; + +static const short dep191[] = { + 32, 33, 88, 123, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2294, 4127, + 6228, 20602, +}; + +static const short dep192[] = { + 32, 33, 88, 123, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2294, 4127, + 6248, 8294, 20602, +}; + +static const short dep193[] = { + 32, 33, 88, 123, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2294, 4127, + 6250, 20602, +}; + +static const short dep194[] = { + 32, 33, 88, 123, 162, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2294, + 4127, 6251, 6252, 20602, +}; + +static const short dep195[] = { + 32, 33, 88, 123, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2294, 4127, + 10341, 20602, +}; + +static const short dep196[] = { + 32, 33, 88, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2294, 4127, 6178, + 20602, +}; + +static const short dep197[] = { + 68, 70, 71, 88, 89, 90, 91, 235, 236, 249, 250, 251, +}; + +static const short dep198[] = { + 32, 33, 69, 70, 74, 76, 88, 91, 93, 95, 98, 123, 163, 167, 235, 237, 249, + 250, 252, 2129, 2130, 2131, 2157, 2158, 2161, 4127, 20602, +}; + +static const short dep199[] = { + 68, 70, 71, 72, 88, 89, 90, 91, 94, 235, 236, 238, 249, 250, 251, +}; + +static const short dep200[] = { + 32, 33, 69, 70, 72, 74, 76, 88, 91, 93, 94, 95, 98, 123, 163, 167, 235, 237, + 238, 249, 250, 252, 2129, 2130, 2131, 2157, 2158, 2161, 4127, 20602, +}; + +static const short dep201[] = { + 68, 70, 71, 75, 76, 77, 88, 89, 90, 91, 235, 236, 241, 242, 249, 250, 251, + +}; + +static const short dep202[] = { + 32, 33, 69, 70, 74, 76, 88, 91, 93, 123, 163, 167, 235, 237, 240, 242, 249, + 250, 252, 2129, 2130, 2131, 2157, 2158, 2161, 4127, 20602, +}; + +static const short dep203[] = { + 68, 70, 71, 88, 89, 90, 91, 97, 98, 99, 235, 236, 249, 250, 251, 254, 255, + +}; + +static const short dep204[] = { + 32, 33, 69, 70, 88, 91, 93, 95, 98, 123, 163, 167, 235, 237, 249, 250, 252, + 253, 255, 2129, 2130, 2131, 2157, 2158, 2161, 4127, 20602, +}; + +static const short dep205[] = { + 32, 33, 38, 62, 88, 163, 167, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2294, + 4127, 20602, +}; + +static const short dep206[] = { + 32, 33, 88, 163, 167, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2294, 4127, + 20602, +}; + +static const short dep207[] = { + 32, 33, 68, 73, 75, 88, 123, 163, 167, 249, 2129, 2130, 2131, 2157, 2158, + 2161, 2294, 4127, 20602, +}; + +static const short dep208[] = { + 32, 33, 88, 145, 163, 164, 249, 2126, 2127, 2128, 2129, 2130, 2131, 2157, + 2158, 2161, 4127, 16513, 16515, 20602, +}; + +static const short dep209[] = { + 32, 33, 68, 73, 75, 88, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 4127, + 20602, +}; + +static const short dep210[] = { + 32, 33, 69, 70, 88, 91, 123, 163, 235, 237, 249, 250, 252, 2129, 2130, 2131, + 2157, 2158, 2161, 4127, 20602, +}; + +static const short dep211[] = { + 32, 33, 67, 68, 73, 75, 88, 100, 102, 116, 117, 119, 120, 123, 124, 125, 127, + 128, 135, 152, 163, 167, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2294, 4127, + 20602, +}; + +static const short dep212[] = { + 32, 33, 36, 67, 68, 73, 75, 88, 100, 102, 116, 117, 119, 120, 123, 124, 125, + 127, 128, 135, 137, 152, 163, 167, 249, 2129, 2130, 2131, 2157, 2158, 2161, + 2294, 4127, 20602, +}; + +static const short dep213[] = { + 0, 88, 170, 249, 2131, 2294, +}; + +static const short dep214[] = { + 0, 32, 33, 67, 68, 73, 75, 88, 100, 102, 116, 117, 119, 120, 123, 124, 125, + 127, 128, 135, 152, 163, 167, 170, 249, 2129, 2130, 2131, 2157, 2158, 2161, + 2294, 4127, 20602, +}; + +static const short dep215[] = { + 0, 32, 33, 36, 67, 68, 73, 75, 88, 100, 102, 116, 117, 119, 120, 123, 124, + 125, 127, 128, 135, 137, 152, 163, 167, 170, 249, 2129, 2130, 2131, 2157, + 2158, 2161, 2294, 4127, 20602, +}; + +static const short dep216[] = { + 23, 32, 33, 67, 68, 73, 75, 88, 100, 102, 116, 117, 119, 120, 123, 124, 125, + 127, 128, 135, 152, 163, 167, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2294, + 4127, 20602, +}; + +static const short dep217[] = { + 0, 88, 170, 249, 2294, 26706, +}; + +static const short dep218[] = { + 0, 88, 100, 170, 249, 256, +}; + +static const short dep219[] = { + 0, 32, 33, 67, 68, 73, 75, 88, 102, 116, 117, 119, 120, 123, 124, 125, 127, + 128, 135, 152, 163, 167, 170, 249, 256, 2129, 2130, 2131, 2157, 2158, 2161, + 4127, 20602, +}; + +static const short dep220[] = { + 0, 23, 88, 100, 170, 201, 249, 256, +}; + +static const short dep221[] = { + 0, 32, 33, 67, 68, 73, 75, 88, 102, 116, 117, 119, 120, 123, 124, 125, 127, + 128, 135, 152, 163, 167, 170, 201, 249, 256, 2129, 2130, 2131, 2157, 2158, + 2161, 4127, 20602, +}; + +static const short dep222[] = { + 0, 88, 100, 170, 249, 256, 2131, 2294, +}; + +static const short dep223[] = { + 0, 3, 32, 33, 67, 68, 73, 75, 88, 100, 102, 116, 117, 119, 120, 123, 124, + 125, 127, 128, 135, 152, 163, 167, 170, 249, 256, 2129, 2130, 2131, 2157, + 2158, 2161, 2294, 4127, 20602, +}; + +static const short dep224[] = { + 0, 32, 33, 67, 68, 73, 75, 88, 100, 102, 116, 117, 119, 120, 123, 124, 125, + 127, 128, 135, 152, 163, 167, 170, 249, 256, 2129, 2130, 2131, 2157, 2158, + 2161, 2294, 4127, 20602, +}; + +static const short dep225[] = { + 32, 33, 88, 163, 249, 2126, 2127, 2128, 2157, 2158, 2161, 2294, 4127, 16513, + 16515, 20602, +}; + +static const short dep226[] = { + 32, 33, 67, 68, 73, 75, 88, 100, 102, 116, 117, 119, 120, 123, 124, 125, 127, + 128, 135, 152, 163, 167, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2292, 4127, + 16513, 16515, 18724, 18726, 18727, 18729, 20602, +}; + +static const short dep227[] = { + 32, 33, 36, 67, 68, 73, 75, 88, 100, 102, 116, 117, 119, 120, 123, 124, 125, + 127, 128, 135, 137, 152, 163, 167, 249, 2129, 2130, 2131, 2157, 2158, 2161, + 2292, 4127, 16513, 16515, 18724, 18726, 18727, 18729, 20602, +}; + +static const short dep228[] = { + 0, 88, 170, 249, 2127, 2292, 18582, 18583, 18724, 18725, 18727, 18728, +}; + +static const short dep229[] = { + 0, 32, 33, 67, 68, 73, 75, 88, 100, 102, 116, 117, 119, 120, 123, 124, 125, + 127, 128, 135, 152, 163, 167, 170, 249, 2129, 2130, 2131, 2157, 2158, 2161, + 2292, 4127, 16513, 16515, 18724, 18726, 18727, 18729, 20602, +}; + +static const short dep230[] = { + 0, 32, 33, 36, 67, 68, 73, 75, 88, 100, 102, 116, 117, 119, 120, 123, 124, + 125, 127, 128, 135, 137, 152, 163, 167, 170, 249, 2129, 2130, 2131, 2157, + 2158, 2161, 2292, 4127, 16513, 16515, 18724, 18726, 18727, 18729, 20602, +}; + +static const short dep231[] = { + 0, 88, 170, 249, 2128, 2292, 18582, 18583, 18724, 18725, 18727, 18728, +}; + +static const short dep232[] = { + 32, 33, 67, 88, 123, 137, 163, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep233[] = { + 32, 33, 67, 88, 123, 124, 128, 137, 163, 249, 2157, 2158, 2161, 4127, +}; + +static const short dep234[] = { + 32, 33, 67, 88, 123, 137, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 2294, + 4127, 20602, +}; + +static const short dep235[] = { + 32, 33, 67, 88, 123, 124, 128, 137, 163, 249, 2129, 2130, 2131, 2157, 2158, + 2161, 2294, 4127, 20602, +}; + +static const short dep236[] = { + 32, 33, 88, 163, 249, 2129, 2130, 2131, 2157, 2158, 2161, 4127, 20602, +}; + +static const short dep237[] = { + 32, 33, 88, 163, 249, 2157, 2158, 2159, 2160, 2161, 2162, 2163, 4127, +}; + +static const short dep238[] = { + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 19, 20, 21, 22, 23, + 88, 171, 172, 173, 174, 175, 176, 177, 178, 180, 181, 183, 184, 186, 187, + 189, 190, 191, 192, 193, 195, 198, 199, 200, 201, 249, 2064, 2073, 2131, 2242, + 2251, 2294, 28841, 28980, +}; + +static const short dep239[] = { + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 18, 19, 21, 22, 23, + 32, 33, 88, 123, 160, 163, 171, 172, 173, 174, 175, 176, 177, 178, 180, 181, + 183, 184, 186, 187, 189, 190, 191, 192, 193, 195, 197, 199, 200, 201, 249, + 2064, 2073, 2129, 2130, 2131, 2157, 2158, 2161, 2242, 2251, 2294, 4127, 20602, + 28841, 28980, +}; + +#define NELS(X) (sizeof(X)/sizeof(X[0])) +static const struct ia64_opcode_dependency +op_dependencies[] = { + { NELS(dep1), dep1, NELS(dep0), dep0, }, + { NELS(dep3), dep3, NELS(dep2), dep2, }, + { NELS(dep4), dep4, NELS(dep0), dep0, }, + { NELS(dep6), dep6, NELS(dep5), dep5, }, + { NELS(dep8), dep8, NELS(dep7), dep7, }, + { NELS(dep10), dep10, NELS(dep9), dep9, }, + { NELS(dep12), dep12, NELS(dep11), dep11, }, + { NELS(dep14), dep14, NELS(dep13), dep13, }, + { NELS(dep16), dep16, NELS(dep15), dep15, }, + { NELS(dep18), dep18, NELS(dep17), dep17, }, + { NELS(dep20), dep20, NELS(dep19), dep19, }, + { NELS(dep22), dep22, NELS(dep21), dep21, }, + { NELS(dep24), dep24, NELS(dep23), dep23, }, + { NELS(dep26), dep26, NELS(dep25), dep25, }, + { NELS(dep28), dep28, NELS(dep27), dep27, }, + { NELS(dep30), dep30, NELS(dep29), dep29, }, + { NELS(dep31), dep31, NELS(dep15), dep15, }, + { NELS(dep33), dep33, NELS(dep32), dep32, }, + { NELS(dep35), dep35, NELS(dep34), dep34, }, + { NELS(dep36), dep36, NELS(dep15), dep15, }, + { NELS(dep38), dep38, NELS(dep37), dep37, }, + { NELS(dep40), dep40, NELS(dep39), dep39, }, + { NELS(dep42), dep42, NELS(dep41), dep41, }, + { NELS(dep43), dep43, NELS(dep32), dep32, }, + { NELS(dep44), dep44, NELS(dep34), dep34, }, + { NELS(dep46), dep46, NELS(dep45), dep45, }, + { NELS(dep48), dep48, NELS(dep47), dep47, }, + { NELS(dep50), dep50, NELS(dep49), dep49, }, + { NELS(dep52), dep52, NELS(dep51), dep51, }, + { NELS(dep54), dep54, NELS(dep53), dep53, }, + { NELS(dep56), dep56, NELS(dep55), dep55, }, + { NELS(dep58), dep58, NELS(dep57), dep57, }, + { NELS(dep60), dep60, NELS(dep59), dep59, }, + { NELS(dep62), dep62, NELS(dep61), dep61, }, + { NELS(dep64), dep64, NELS(dep63), dep63, }, + { NELS(dep66), dep66, NELS(dep65), dep65, }, + { NELS(dep68), dep68, NELS(dep67), dep67, }, + { NELS(dep69), dep69, NELS(dep34), dep34, }, + { NELS(dep71), dep71, NELS(dep70), dep70, }, + { NELS(dep73), dep73, NELS(dep72), dep72, }, + { NELS(dep75), dep75, NELS(dep74), dep74, }, + { NELS(dep77), dep77, NELS(dep76), dep76, }, + { NELS(dep78), dep78, NELS(dep34), dep34, }, + { NELS(dep80), dep80, NELS(dep79), dep79, }, + { NELS(dep82), dep82, NELS(dep81), dep81, }, + { NELS(dep84), dep84, NELS(dep83), dep83, }, + { NELS(dep85), dep85, NELS(dep34), dep34, }, + { NELS(dep86), dep86, NELS(dep34), dep34, }, + { NELS(dep87), dep87, NELS(dep34), dep34, }, + { NELS(dep88), dep88, NELS(dep34), dep34, }, + { NELS(dep90), dep90, NELS(dep89), dep89, }, + { NELS(dep92), dep92, NELS(dep91), dep91, }, + { NELS(dep94), dep94, NELS(dep93), dep93, }, + { NELS(dep96), dep96, NELS(dep95), dep95, }, + { NELS(dep98), dep98, NELS(dep97), dep97, }, + { NELS(dep100), dep100, NELS(dep99), dep99, }, + { NELS(dep102), dep102, NELS(dep101), dep101, }, + { NELS(dep104), dep104, NELS(dep103), dep103, }, + { NELS(dep106), dep106, NELS(dep105), dep105, }, + { NELS(dep108), dep108, NELS(dep107), dep107, }, + { NELS(dep110), dep110, NELS(dep109), dep109, }, + { NELS(dep112), dep112, NELS(dep111), dep111, }, + { NELS(dep114), dep114, NELS(dep113), dep113, }, + { NELS(dep116), dep116, NELS(dep115), dep115, }, + { NELS(dep118), dep118, NELS(dep117), dep117, }, + { NELS(dep120), dep120, NELS(dep119), dep119, }, + { NELS(dep122), dep122, NELS(dep121), dep121, }, + { NELS(dep123), dep123, NELS(dep65), dep65, }, + { NELS(dep124), dep124, NELS(dep34), dep34, }, + { NELS(dep126), dep126, NELS(dep125), dep125, }, + { NELS(dep127), dep127, NELS(dep0), dep0, }, + { NELS(dep129), dep129, NELS(dep128), dep128, }, + { NELS(dep131), dep131, NELS(dep130), dep130, }, + { NELS(dep132), dep132, NELS(dep0), dep0, }, + { NELS(dep133), dep133, NELS(dep0), dep0, }, + { NELS(dep135), dep135, NELS(dep134), dep134, }, + { NELS(dep136), dep136, NELS(dep0), dep0, }, + { NELS(dep137), dep137, NELS(dep34), dep34, }, + { NELS(dep139), dep139, NELS(dep138), dep138, }, + { NELS(dep140), dep140, NELS(dep138), dep138, }, + { NELS(dep142), dep142, NELS(dep141), dep141, }, + { NELS(dep143), dep143, NELS(dep141), dep141, }, + { NELS(dep144), dep144, NELS(dep138), dep138, }, + { NELS(dep146), dep146, NELS(dep145), dep145, }, + { NELS(dep148), dep148, NELS(dep147), dep147, }, + { NELS(dep150), dep150, NELS(dep149), dep149, }, + { NELS(dep152), dep152, NELS(dep151), dep151, }, + { NELS(dep153), dep153, NELS(dep0), dep0, }, + { NELS(dep155), dep155, NELS(dep154), dep154, }, + { NELS(dep157), dep157, NELS(dep156), dep156, }, + { NELS(dep159), dep159, NELS(dep158), dep158, }, + { NELS(dep161), dep161, NELS(dep160), dep160, }, + { NELS(dep163), dep163, NELS(dep162), dep162, }, + { NELS(dep164), dep164, NELS(dep0), dep0, }, + { NELS(dep165), dep165, NELS(dep0), dep0, }, + { NELS(dep166), dep166, NELS(dep0), dep0, }, + { NELS(dep167), dep167, NELS(dep34), dep34, }, + { NELS(dep169), dep169, NELS(dep168), dep168, }, + { NELS(dep170), dep170, NELS(dep168), dep168, }, + { NELS(dep172), dep172, NELS(dep171), dep171, }, + { NELS(dep174), dep174, NELS(dep173), dep173, }, + { NELS(dep176), dep176, NELS(dep175), dep175, }, + { NELS(dep178), dep178, NELS(dep177), dep177, }, + { NELS(dep180), dep180, NELS(dep179), dep179, }, + { NELS(dep182), dep182, NELS(dep181), dep181, }, + { NELS(dep184), dep184, NELS(dep183), dep183, }, + { NELS(dep186), dep186, NELS(dep185), dep185, }, + { NELS(dep188), dep188, NELS(dep187), dep187, }, + { NELS(dep189), dep189, NELS(dep0), dep0, }, + { NELS(dep190), dep190, NELS(dep0), dep0, }, + { NELS(dep191), dep191, NELS(dep0), dep0, }, + { NELS(dep192), dep192, NELS(dep0), dep0, }, + { NELS(dep193), dep193, NELS(dep0), dep0, }, + { NELS(dep194), dep194, NELS(dep0), dep0, }, + { NELS(dep195), dep195, NELS(dep0), dep0, }, + { NELS(dep196), dep196, NELS(dep0), dep0, }, + { NELS(dep198), dep198, NELS(dep197), dep197, }, + { NELS(dep200), dep200, NELS(dep199), dep199, }, + { NELS(dep202), dep202, NELS(dep201), dep201, }, + { NELS(dep204), dep204, NELS(dep203), dep203, }, + { NELS(dep205), dep205, NELS(dep0), dep0, }, + { NELS(dep206), dep206, NELS(dep0), dep0, }, + { NELS(dep207), dep207, NELS(dep0), dep0, }, + { NELS(dep208), dep208, NELS(dep34), dep34, }, + { NELS(dep209), dep209, NELS(dep34), dep34, }, + { NELS(dep210), dep210, NELS(dep197), dep197, }, + { NELS(dep211), dep211, NELS(dep0), dep0, }, + { NELS(dep212), dep212, NELS(dep0), dep0, }, + { NELS(dep214), dep214, NELS(dep213), dep213, }, + { NELS(dep215), dep215, NELS(dep213), dep213, }, + { NELS(dep216), dep216, NELS(dep0), dep0, }, + { NELS(dep214), dep214, NELS(dep217), dep217, }, + { NELS(dep219), dep219, NELS(dep218), dep218, }, + { NELS(dep221), dep221, NELS(dep220), dep220, }, + { NELS(dep223), dep223, NELS(dep222), dep222, }, + { NELS(dep224), dep224, NELS(dep222), dep222, }, + { NELS(dep225), dep225, NELS(dep0), dep0, }, + { NELS(dep226), dep226, NELS(dep65), dep65, }, + { NELS(dep227), dep227, NELS(dep65), dep65, }, + { NELS(dep229), dep229, NELS(dep228), dep228, }, + { NELS(dep230), dep230, NELS(dep228), dep228, }, + { NELS(dep229), dep229, NELS(dep231), dep231, }, + { NELS(dep232), dep232, NELS(dep34), dep34, }, + { NELS(dep233), dep233, NELS(dep34), dep34, }, + { NELS(dep234), dep234, NELS(dep0), dep0, }, + { NELS(dep235), dep235, NELS(dep0), dep0, }, + { NELS(dep236), dep236, NELS(dep34), dep34, }, + { NELS(dep237), dep237, NELS(dep15), dep15, }, + { NELS(dep239), dep239, NELS(dep238), dep238, }, +}; + +static const struct ia64_completer_table +completer_table[] = { + { 0x0, 0x0, 0, -1, -1, 0, 1, 0 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 1 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 90 }, + { 0x0, 0x0, 0, 122, -1, 0, 1, 8 }, + { 0x0, 0x0, 0, 127, -1, 0, 1, 19 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 147 }, + { 0x0, 0x0, 0, 724, -1, 0, 1, 12 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 11 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 73 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 15 }, + { 0x1, 0x1, 0, 1008, -1, 13, 1, 0 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 35 }, + { 0x0, 0x0, 0, 141, -1, 0, 1, 31 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 31 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 124 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 46 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 42 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 80 }, + { 0x0, 0x0, 0, 143, -1, 0, 1, 31 }, + { 0x0, 0x0, 0, 145, -1, 0, 1, 31 }, + { 0x0, 0x0, 0, 756, -1, 0, 1, 31 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 26 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 37 }, + { 0x0, 0x0, 0, 553, -1, 0, 1, 35 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 79 }, + { 0x0, 0x0, 0, 77, -1, 0, 1, 126 }, + { 0x0, 0x0, 0, 78, -1, 0, 1, 126 }, + { 0x0, 0x0, 0, 79, -1, 0, 1, 137 }, + { 0x0, 0x0, 0, 326, -1, 0, 1, 142 }, + { 0x0, 0x0, 0, 328, -1, 0, 1, 144 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 81 }, + { 0x0, 0x0, 0, 80, -1, 0, 1, 42 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 2 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 69 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 70 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 71 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 72 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 74 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 88 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 89 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 91 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 92 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 93 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 94 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 99 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 100 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 101 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 102 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 103 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 104 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 105 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 108 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 109 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 110 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 111 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 112 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 113 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 114 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 115 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 148 }, + { 0x0, 0x0, 0, 938, -1, 0, 1, 0 }, + { 0x0, 0x0, 0, 731, -1, 0, 1, 0 }, + { 0x0, 0x0, 0, 1009, -1, 0, 1, 0 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 13 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 86 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 85 }, + { 0x0, 0x0, 0, 696, -1, 0, 1, 132 }, + { 0x0, 0x0, 0, 698, -1, 0, 1, 132 }, + { 0x0, 0x0, 0, 695, -1, 0, 1, 132 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 84 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 122 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 120 }, + { 0x0, 0x0, 0, -1, -1, 0, 1, 121 }, + { 0x0, 0x0, 0, 654, -1, 0, 1, 135 }, + { 0x0, 0x0, 1, 75, -1, 0, 1, 14 }, + { 0x1, 0x1, 2, -1, -1, 27, 1, 14 }, + { 0x0, 0x0, 3, -1, 132, 0, 0, -1 }, + { 0x1, 0x1, 3, 84, 655, 33, 1, 128 }, + { 0x1, 0x1, 3, 85, 655, 33, 1, 128 }, + { 0x1, 0x1, 3, 112, 663, 33, 1, 139 }, + { 0x1, 0x1, 3, -1, -1, 27, 1, 42 }, + { 0x0, 0x0, 4, 732, 653, 0, 1, 134 }, + { 0x0, 0x0, 4, 733, 654, 0, 1, 135 }, + { 0x1, 0x1, 4, 657, 657, 33, 1, 131 }, + { 0x5, 0x5, 4, 108, 656, 32, 1, 126 }, + { 0x5, 0x5, 4, 109, 656, 32, 1, 126 }, + { 0x1, 0x21, 10, 701, -1, 33, 1, 5 }, + { 0x200001, 0x200001, 10, 702, -1, 12, 1, 5 }, + { 0x1, 0x1, 10, 703, -1, 33, 1, 5 }, + { 0x0, 0x0, 10, 704, -1, 0, 1, 5 }, + { 0x1, 0x1, 10, 705, -1, 12, 1, 5 }, + { 0x0, 0x0, 10, -1, 712, 0, 0, -1 }, + { 0x0, 0x0, 10, -1, 713, 0, 0, -1 }, + { 0x0, 0x0, 10, -1, 714, 0, 0, -1 }, + { 0x0, 0x0, 10, -1, 715, 0, 0, -1 }, + { 0x1000001, 0x1000001, 10, 706, -1, 12, 1, 5 }, + { 0x1, 0x1, 10, 707, -1, 36, 1, 5 }, + { 0x0, 0x0, 10, 105, 716, 0, 0, -1 }, + { 0x0, 0x0, 10, 106, 718, 0, 0, -1 }, + { 0x2, 0x3, 11, -1, -1, 37, 1, 7 }, + { 0x1, 0x1, 11, 708, -1, 12, 1, 5 }, + { 0x0, 0x0, 11, 709, -1, 0, 1, 5 }, + { 0x200001, 0x200001, 11, 710, -1, 12, 1, 5 }, + { 0x1, 0x1, 11, 711, -1, 33, 1, 5 }, + { 0x1, 0x1, 11, -1, -1, 36, 1, 7 }, + { 0x1, 0x1, 11, 717, -1, 36, 1, 5 }, + { 0x1000001, 0x1000001, 11, 719, -1, 12, 1, 5 }, + { 0x0, 0x0, 12, -1, -1, 0, 1, 16 }, + { 0x1, 0x1, 13, 110, 656, 34, 1, 126 }, + { 0x1, 0x1, 13, 111, 656, 34, 1, 126 }, + { 0x0, 0x0, 19, 660, 133, 0, 0, -1 }, + { 0x0, 0x0, 19, 399, 133, 0, 0, -1 }, + { 0x0, 0x0, 19, 667, 134, 0, 0, -1 }, + { 0x0, 0x0, 20, -1, 266, 0, 0, -1 }, + { 0x0, 0x0, 20, -1, 267, 0, 0, -1 }, + { 0x0, 0x0, 20, -1, 280, 0, 0, -1 }, + { 0x0, 0x0, 20, -1, 281, 0, 0, -1 }, + { 0x0, 0x0, 21, 139, 276, 0, 0, -1 }, + { 0x0, 0x0, 21, 140, 278, 0, 0, -1 }, + { 0x0, 0x0, 23, -1, 274, 0, 0, -1 }, + { 0x0, 0x0, 23, -1, 275, 0, 0, -1 }, + { 0x1, 0x1, 24, -1, -1, 35, 1, 8 }, + { 0x1, 0x1, 24, 339, -1, 35, 1, 8 }, + { 0x1, 0x1, 24, -1, -1, 35, 1, 9 }, + { 0x1, 0x1, 24, -1, -1, 35, 1, 10 }, + { 0x1, 0x1, 24, -1, -1, 35, 1, 17 }, + { 0x1, 0x1, 24, -1, -1, 35, 1, 19 }, + { 0x1, 0x1, 24, 355, -1, 35, 1, 19 }, + { 0x1, 0x1, 24, -1, -1, 35, 1, 20 }, + { 0x1, 0x1, 24, -1, -1, 35, 1, 21 }, + { 0x1, 0x1, 24, -1, -1, 35, 1, 22 }, + { 0x1, 0x1, 24, -1, -1, 35, 1, 23 }, + { 0x1, 0x1, 24, 538, -1, 33, 1, 78 }, + { 0x1, 0x1, 24, 539, 83, 35, 1, 131 }, + { 0x1, 0x1, 24, 540, 664, 35, 1, 141 }, + { 0x0, 0x0, 32, 260, 258, 0, 0, -1 }, + { 0x0, 0x0, 32, 263, 261, 0, 0, -1 }, + { 0x0, 0x0, 32, 268, 268, 0, 0, -1 }, + { 0x0, 0x0, 32, 269, 269, 0, 0, -1 }, + { 0x0, 0x0, 34, -1, 277, 0, 0, -1 }, + { 0x0, 0x0, 34, -1, 279, 0, 0, -1 }, + { 0x1, 0x1, 37, 746, 756, 37, 1, 31 }, + { 0x0, 0x0, 37, 747, 774, 0, 0, -1 }, + { 0x1, 0x1, 37, 748, -1, 37, 1, 31 }, + { 0x0, 0x0, 37, 750, 774, 0, 0, -1 }, + { 0x1, 0x1, 37, 751, -1, 37, 1, 31 }, + { 0x3, 0x3, 37, 331, -1, 30, 1, 136 }, + { 0x0, 0x0, 37, 433, -1, 0, 1, 97 }, + { 0x0, 0x0, 37, -1, -1, 0, 1, 106 }, + { 0x0, 0x0, 37, 437, -1, 0, 1, 118 }, + { 0x3, 0x3, 37, 332, -1, 30, 1, 146 }, + { 0x0, 0x0, 37, 438, -1, 0, 1, 42 }, + { 0x5, 0x5, 38, 566, 441, 0, 1, 18 }, + { 0x1, 0x1, 38, 567, 441, 1, 1, 18 }, + { 0x0, 0x0, 38, 568, 565, 0, 0, -1 }, + { 0x1, 0x1, 38, 569, 441, 5, 1, 18 }, + { 0x25, 0x25, 38, 570, 441, 0, 1, 18 }, + { 0x11, 0x11, 38, 571, 441, 1, 1, 18 }, + { 0x0, 0x0, 38, 572, 155, 0, 0, -1 }, + { 0x1, 0x1, 38, 573, 441, 4, 1, 18 }, + { 0x1, 0x1, 38, -1, 441, 4, 1, 18 }, + { 0x0, 0x0, 38, -1, 160, 0, 0, -1 }, + { 0x15, 0x15, 38, 574, 441, 0, 1, 18 }, + { 0x9, 0x9, 38, 575, 441, 1, 1, 18 }, + { 0x0, 0x0, 38, 384, 159, 0, 0, -1 }, + { 0x800001, 0x800001, 38, 577, 441, 4, 1, 18 }, + { 0x800001, 0x800001, 38, -1, 441, 4, 1, 18 }, + { 0x0, 0x0, 38, -1, 166, 0, 0, -1 }, + { 0x8000015, 0x8000015, 38, 578, 441, 0, 1, 18 }, + { 0x4000009, 0x4000009, 38, 579, 441, 1, 1, 18 }, + { 0x0, 0x0, 38, 385, 165, 0, 0, -1 }, + { 0x1, 0x1, 38, 581, 441, 27, 1, 18 }, + { 0x1, 0x1, 38, -1, 441, 27, 1, 18 }, + { 0x0, 0x0, 38, -1, 172, 0, 0, -1 }, + { 0x8000005, 0x8000005, 38, 582, 441, 0, 1, 18 }, + { 0x4000001, 0x4000001, 38, 583, 441, 1, 1, 18 }, + { 0x0, 0x0, 38, 386, 171, 0, 0, -1 }, + { 0x0, 0x0, 38, 565, 441, 0, 1, 18 }, + { 0x0, 0x0, 38, -1, 441, 0, 1, 18 }, + { 0x0, 0x0, 38, -1, 178, 0, 0, -1 }, + { 0x0, 0x0, 38, 387, 177, 0, 0, -1 }, + { 0x5, 0x5, 38, 586, 443, 0, 1, 24 }, + { 0x1, 0x1, 38, 587, 443, 1, 1, 24 }, + { 0x0, 0x0, 38, 588, 585, 0, 0, -1 }, + { 0x1, 0x1, 38, 589, 443, 5, 1, 24 }, + { 0x25, 0x25, 38, 590, 443, 0, 1, 24 }, + { 0x11, 0x11, 38, 591, 443, 1, 1, 24 }, + { 0x0, 0x0, 38, 592, 184, 0, 0, -1 }, + { 0x1, 0x1, 38, 593, 443, 4, 1, 24 }, + { 0x1, 0x1, 38, -1, 443, 4, 1, 24 }, + { 0x0, 0x0, 38, -1, 189, 0, 0, -1 }, + { 0x15, 0x15, 38, 594, 443, 0, 1, 24 }, + { 0x9, 0x9, 38, 595, 443, 1, 1, 24 }, + { 0x0, 0x0, 38, 389, 188, 0, 0, -1 }, + { 0x3, 0x3, 38, 597, 443, 3, 1, 24 }, + { 0x3, 0x3, 38, -1, 443, 3, 1, 24 }, + { 0x0, 0x0, 38, -1, 195, 0, 0, -1 }, + { 0x1d, 0x1d, 38, 598, 443, 0, 1, 24 }, + { 0xd, 0xd, 38, 599, 443, 1, 1, 24 }, + { 0x0, 0x0, 38, 390, 194, 0, 0, -1 }, + { 0x1, 0x1, 38, 601, 443, 3, 1, 24 }, + { 0x1, 0x1, 38, -1, 443, 3, 1, 24 }, + { 0x0, 0x0, 38, -1, 201, 0, 0, -1 }, + { 0xd, 0xd, 38, 602, 443, 0, 1, 24 }, + { 0x5, 0x5, 38, 603, 443, 1, 1, 24 }, + { 0x0, 0x0, 38, 391, 200, 0, 0, -1 }, + { 0x0, 0x0, 38, 585, 443, 0, 1, 24 }, + { 0x0, 0x0, 38, -1, 443, 0, 1, 24 }, + { 0x0, 0x0, 38, -1, 207, 0, 0, -1 }, + { 0x0, 0x0, 38, 392, 206, 0, 0, -1 }, + { 0x1, 0x1, 38, 605, 445, 21, 1, 69 }, + { 0x1005, 0x1005, 38, 606, 445, 9, 1, 69 }, + { 0x801, 0x801, 38, 607, 445, 10, 1, 69 }, + { 0x0, 0x0, 38, 608, 210, 0, 0, -1 }, + { 0x201, 0x201, 38, 609, 445, 12, 1, 69 }, + { 0x100d, 0x100d, 38, 610, 445, 9, 1, 69 }, + { 0x805, 0x805, 38, 611, 445, 10, 1, 69 }, + { 0x0, 0x0, 38, 612, 214, 0, 0, -1 }, + { 0x1, 0x1, 38, 613, 445, 20, 1, 69 }, + { 0x805, 0x805, 38, 614, 445, 9, 1, 69 }, + { 0x401, 0x401, 38, 615, 445, 10, 1, 69 }, + { 0x0, 0x0, 38, 616, 218, 0, 0, -1 }, + { 0x101, 0x101, 38, 617, 445, 12, 1, 69 }, + { 0x80d, 0x80d, 38, 618, 445, 9, 1, 69 }, + { 0x405, 0x405, 38, 619, 445, 10, 1, 69 }, + { 0x0, 0x0, 38, 620, 222, 0, 0, -1 }, + { 0x3, 0x3, 38, 621, 445, 21, 1, 69 }, + { 0x3005, 0x3005, 38, 622, 445, 9, 1, 69 }, + { 0x1801, 0x1801, 38, 623, 445, 10, 1, 69 }, + { 0x0, 0x0, 38, 624, 226, 0, 0, -1 }, + { 0x601, 0x601, 38, 625, 445, 12, 1, 69 }, + { 0x300d, 0x300d, 38, 626, 445, 9, 1, 69 }, + { 0x1805, 0x1805, 38, 627, 445, 10, 1, 69 }, + { 0x0, 0x0, 38, 628, 230, 0, 0, -1 }, + { 0x5, 0x5, 38, 629, 445, 20, 1, 69 }, + { 0x2805, 0x2805, 38, 630, 445, 9, 1, 69 }, + { 0x1401, 0x1401, 38, 631, 445, 10, 1, 69 }, + { 0x0, 0x0, 38, 632, 234, 0, 0, -1 }, + { 0x501, 0x501, 38, 633, 445, 12, 1, 69 }, + { 0x280d, 0x280d, 38, 634, 445, 9, 1, 69 }, + { 0x1405, 0x1405, 38, 635, 445, 10, 1, 69 }, + { 0x0, 0x0, 38, 636, 238, 0, 0, -1 }, + { 0x1, 0x1, 38, 637, 445, 22, 1, 69 }, + { 0x2005, 0x2005, 38, 638, 445, 9, 1, 69 }, + { 0x1001, 0x1001, 38, 639, 445, 10, 1, 69 }, + { 0x0, 0x0, 38, 640, 242, 0, 0, -1 }, + { 0x401, 0x401, 38, 641, 445, 12, 1, 69 }, + { 0x200d, 0x200d, 38, 642, 445, 9, 1, 69 }, + { 0x1005, 0x1005, 38, 643, 445, 10, 1, 69 }, + { 0x0, 0x0, 38, 644, 246, 0, 0, -1 }, + { 0x0, 0x0, 38, 645, 445, 0, 1, 69 }, + { 0x5, 0x5, 38, 646, 445, 9, 1, 69 }, + { 0x1, 0x1, 38, 647, 445, 10, 1, 69 }, + { 0x0, 0x0, 38, 648, 250, 0, 0, -1 }, + { 0x1, 0x1, 38, 649, 445, 12, 1, 69 }, + { 0xd, 0xd, 38, 650, 445, 9, 1, 69 }, + { 0x5, 0x5, 38, 651, 445, 10, 1, 69 }, + { 0x0, 0x0, 38, 652, 254, 0, 0, -1 }, + { 0x0, 0x0, 40, 282, 340, 0, 0, -1 }, + { 0x0, 0x0, 40, 283, 343, 0, 0, -1 }, + { 0x0, 0x0, 40, 284, 340, 0, 0, -1 }, + { 0x3, 0x3, 40, 285, 121, 33, 1, 8 }, + { 0x18000001, 0x18000001, 40, 286, 123, 6, 1, 9 }, + { 0x3, 0x3, 40, 287, 121, 33, 1, 8 }, + { 0x0, 0x0, 40, 288, 347, 0, 0, -1 }, + { 0x3, 0x3, 40, 289, 124, 33, 1, 10 }, + { 0x0, 0x0, 40, 290, 351, 0, 0, -1 }, + { 0x3, 0x3, 40, 291, 125, 33, 1, 17 }, + { 0x0, 0x0, 40, 292, 356, 0, 0, -1 }, + { 0x3, 0x3, 40, 293, 126, 33, 1, 19 }, + { 0x0, 0x0, 40, 294, 359, 0, 0, -1 }, + { 0x0, 0x0, 40, 295, 363, 0, 0, -1 }, + { 0x3, 0x3, 40, 296, 128, 33, 1, 20 }, + { 0x18000001, 0x18000001, 40, 297, 128, 6, 1, 20 }, + { 0x0, 0x0, 40, 298, 367, 0, 0, -1 }, + { 0x3, 0x3, 40, 299, 129, 33, 1, 21 }, + { 0x0, 0x0, 40, 300, 371, 0, 0, -1 }, + { 0x0, 0x0, 40, 301, 375, 0, 0, -1 }, + { 0x3, 0x3, 40, 302, 130, 33, 1, 22 }, + { 0x18000001, 0x18000001, 40, 303, 130, 6, 1, 22 }, + { 0x0, 0x0, 40, 304, 379, 0, 0, -1 }, + { 0x3, 0x3, 40, 305, 131, 33, 1, 23 }, + { 0x0, 0x0, 41, 884, 341, 0, 0, -1 }, + { 0x0, 0x0, 41, 885, 344, 0, 0, -1 }, + { 0x0, 0x0, 41, 439, 341, 0, 0, -1 }, + { 0x1, 0x1, 41, 886, 121, 34, 1, 8 }, + { 0x10000001, 0x10000001, 41, 887, 123, 6, 1, 9 }, + { 0x1, 0x1, 41, 440, 121, 34, 1, 8 }, + { 0x0, 0x0, 41, 888, 348, 0, 0, -1 }, + { 0x1, 0x1, 41, 889, 124, 34, 1, 10 }, + { 0x0, 0x0, 41, 890, 352, 0, 0, -1 }, + { 0x1, 0x1, 41, 891, 125, 34, 1, 17 }, + { 0x0, 0x0, 41, 892, 357, 0, 0, -1 }, + { 0x1, 0x1, 41, 893, 126, 34, 1, 19 }, + { 0x0, 0x0, 41, 894, 360, 0, 0, -1 }, + { 0x0, 0x0, 41, 895, 364, 0, 0, -1 }, + { 0x1, 0x1, 41, 896, 128, 34, 1, 20 }, + { 0x10000001, 0x10000001, 41, 897, 128, 6, 1, 20 }, + { 0x0, 0x0, 41, 898, 368, 0, 0, -1 }, + { 0x1, 0x1, 41, 899, 129, 34, 1, 21 }, + { 0x0, 0x0, 41, 900, 372, 0, 0, -1 }, + { 0x0, 0x0, 41, 901, 376, 0, 0, -1 }, + { 0x1, 0x1, 41, 902, 130, 34, 1, 22 }, + { 0x10000001, 0x10000001, 41, 903, 130, 6, 1, 22 }, + { 0x0, 0x0, 41, 904, 380, 0, 0, -1 }, + { 0x1, 0x1, 41, 905, 131, 34, 1, 23 }, + { 0x800001, 0x800001, 41, 928, 383, 4, 1, 18 }, + { 0x1, 0x1, 41, 738, 383, 4, 1, 18 }, + { 0x0, 0x0, 41, 930, 170, 0, 0, -1 }, + { 0x0, 0x0, 41, 739, 164, 0, 0, -1 }, + { 0x1, 0x1, 41, 329, 388, 4, 1, 24 }, + { 0x0, 0x0, 41, 330, 193, 0, 0, -1 }, + { 0x0, 0x0, 41, 396, 394, 0, 0, -1 }, + { 0x0, 0x0, 41, 398, 393, 0, 0, -1 }, + { 0x0, 0x0, 42, -1, -1, 0, 1, 82 }, + { 0x0, 0x0, 42, -1, -1, 0, 1, 125 }, + { 0x1, 0x1, 44, 468, 86, 38, 1, 3 }, + { 0x0, 0x0, 44, 543, 100, 0, 0, -1 }, + { 0x0, 0x0, 44, 544, 91, 0, 0, -1 }, + { 0x1, 0x1, 44, 472, 86, 38, 1, 3 }, + { 0x0, 0x0, 44, 459, 761, 0, 0, -1 }, + { 0x0, 0x0, 44, 460, 1016, 0, 1, 56 }, + { 0x0, 0x0, 44, 461, 777, 0, 0, -1 }, + { 0x0, 0x0, 44, 462, -1, 0, 1, 51 }, + { 0x0, 0x0, 44, 423, -1, 0, 1, 0 }, + { 0x1, 0x1, 45, 669, 669, 30, 1, 143 }, + { 0x1, 0x1, 45, 334, 668, 30, 1, 142 }, + { 0x1, 0x1, 45, 671, 671, 30, 1, 145 }, + { 0x1, 0x1, 45, 335, 670, 30, 1, 144 }, + { 0x3, 0x3, 46, 465, 388, 3, 1, 24 }, + { 0x0, 0x0, 46, 466, 199, 0, 0, -1 }, + { 0x1, 0x1, 47, 752, -1, 30, 1, 136 }, + { 0x1, 0x1, 47, 755, -1, 30, 1, 146 }, + { 0x0, 0x0, 49, -1, -1, 0, 1, 42 }, + { 0x1, 0x1, 56, 668, 325, 31, 1, 143 }, + { 0x1, 0x1, 56, 670, 327, 31, 1, 145 }, + { 0x2, 0x3, 56, -1, -1, 27, 1, 96 }, + { 0x0, 0x0, 56, -1, -1, 0, 1, 96 }, + { 0x1, 0x1, 56, -1, -1, 28, 1, 96 }, + { 0x0, 0x0, 65, 486, 121, 0, 1, 8 }, + { 0x3, 0x3, 65, 487, 121, 33, 1, 8 }, + { 0x1, 0x1, 65, 488, 121, 34, 1, 8 }, + { 0x1, 0x1, 65, 489, 121, 33, 1, 8 }, + { 0x18000001, 0x18000001, 65, 490, 123, 6, 1, 9 }, + { 0x10000001, 0x10000001, 65, 491, 123, 6, 1, 9 }, + { 0x8000001, 0x8000001, 65, 492, 123, 6, 1, 9 }, + { 0x1, 0x1, 65, 493, 123, 6, 1, 9 }, + { 0x3, 0x3, 65, 494, 124, 33, 1, 10 }, + { 0x1, 0x1, 65, 495, 124, 34, 1, 10 }, + { 0x1, 0x1, 65, 496, 124, 33, 1, 10 }, + { 0x0, 0x0, 65, 497, 124, 0, 1, 10 }, + { 0x3, 0x3, 65, 498, 125, 33, 1, 17 }, + { 0x1, 0x1, 65, 499, 125, 34, 1, 17 }, + { 0x1, 0x1, 65, 500, 125, 33, 1, 17 }, + { 0x0, 0x0, 65, 501, 125, 0, 1, 17 }, + { 0x0, 0x0, 65, 502, 126, 0, 1, 19 }, + { 0x3, 0x3, 65, 503, 126, 33, 1, 19 }, + { 0x1, 0x1, 65, 504, 126, 34, 1, 19 }, + { 0x1, 0x1, 65, 505, 126, 33, 1, 19 }, + { 0x3, 0x3, 65, 506, 128, 33, 1, 20 }, + { 0x1, 0x1, 65, 507, 128, 34, 1, 20 }, + { 0x1, 0x1, 65, 508, 128, 33, 1, 20 }, + { 0x0, 0x0, 65, 509, 128, 0, 1, 20 }, + { 0x18000001, 0x18000001, 65, 510, 128, 6, 1, 20 }, + { 0x10000001, 0x10000001, 65, 511, 128, 6, 1, 20 }, + { 0x8000001, 0x8000001, 65, 512, 128, 6, 1, 20 }, + { 0x1, 0x1, 65, 513, 128, 6, 1, 20 }, + { 0x3, 0x3, 65, 514, 129, 33, 1, 21 }, + { 0x1, 0x1, 65, 515, 129, 34, 1, 21 }, + { 0x1, 0x1, 65, 516, 129, 33, 1, 21 }, + { 0x0, 0x0, 65, 517, 129, 0, 1, 21 }, + { 0x3, 0x3, 65, 518, 130, 33, 1, 22 }, + { 0x1, 0x1, 65, 519, 130, 34, 1, 22 }, + { 0x1, 0x1, 65, 520, 130, 33, 1, 22 }, + { 0x0, 0x0, 65, 521, 130, 0, 1, 22 }, + { 0x18000001, 0x18000001, 65, 522, 130, 6, 1, 22 }, + { 0x10000001, 0x10000001, 65, 523, 130, 6, 1, 22 }, + { 0x8000001, 0x8000001, 65, 524, 130, 6, 1, 22 }, + { 0x1, 0x1, 65, 525, 130, 6, 1, 22 }, + { 0x3, 0x3, 65, 526, 131, 33, 1, 23 }, + { 0x1, 0x1, 65, 527, 131, 34, 1, 23 }, + { 0x1, 0x1, 65, 528, 131, 33, 1, 23 }, + { 0x0, 0x0, 65, 529, 131, 0, 1, 23 }, + { 0x0, 0x0, 65, 442, 154, 0, 0, -1 }, + { 0x0, 0x0, 65, 576, 161, 0, 0, -1 }, + { 0x0, 0x0, 65, 580, 167, 0, 0, -1 }, + { 0x0, 0x0, 65, 584, 173, 0, 0, -1 }, + { 0x0, 0x0, 65, 568, 179, 0, 0, -1 }, + { 0x0, 0x0, 65, 444, 183, 0, 0, -1 }, + { 0x0, 0x0, 65, 596, 190, 0, 0, -1 }, + { 0x0, 0x0, 65, 600, 196, 0, 0, -1 }, + { 0x0, 0x0, 65, 604, 202, 0, 0, -1 }, + { 0x0, 0x0, 65, 588, 208, 0, 0, -1 }, + { 0x0, 0x0, 65, 532, 213, 0, 0, -1 }, + { 0x0, 0x0, 65, 533, 229, 0, 0, -1 }, + { 0x0, 0x0, 65, 534, 245, 0, 0, -1 }, + { 0x0, 0x0, 65, 535, 237, 0, 0, -1 }, + { 0x0, 0x0, 65, 536, 253, 0, 0, -1 }, + { 0x0, 0x0, 65, 537, 221, 0, 0, -1 }, + { 0x3, 0x3, 66, 660, 661, 33, 1, 130 }, + { 0x0, 0x0, 66, -1, 662, 0, 1, 137 }, + { 0x0, 0x0, 107, 403, 771, 0, 0, -1 }, + { 0x0, 0x0, 107, 404, 1007, 0, 1, 31 }, + { 0x0, 0x0, 109, -1, 773, 0, 0, -1 }, + { 0x1, 0x1, 109, -1, 1007, 27, 1, 31 }, + { 0x0, 0x0, 110, 406, -1, 0, 1, 117 }, + { 0x1, 0x1, 111, -1, -1, 27, 1, 117 }, + { 0x0, 0x0, 112, 414, 1010, 0, 1, 3 }, + { 0x0, 0x0, 112, 417, 88, 0, 0, -1 }, + { 0x0, 0x0, 112, 418, 102, 0, 0, -1 }, + { 0x0, 0x0, 112, 420, 93, 0, 0, -1 }, + { 0x0, 0x0, 112, 542, 1010, 0, 1, 3 }, + { 0x0, 0x0, 112, 421, 769, 0, 0, -1 }, + { 0x1, 0x9, 112, 422, 1016, 33, 1, 56 }, + { 0x1, 0x1, 114, 542, 1010, 37, 1, 3 }, + { 0x0, 0x0, 114, -1, 1010, 0, 1, 3 }, + { 0x0, 0x0, 115, 424, 1010, 0, 1, 3 }, + { 0x0, 0x0, 115, 455, 89, 0, 0, -1 }, + { 0x0, 0x0, 115, 456, 100, 0, 0, -1 }, + { 0x0, 0x0, 115, -1, 1010, 0, 1, 3 }, + { 0x0, 0x0, 115, 458, 91, 0, 0, -1 }, + { 0x0, 0x0, 115, -1, 761, 0, 0, -1 }, + { 0x0, 0x0, 115, -1, 1016, 0, 1, 56 }, + { 0x1, 0x1, 115, -1, -1, 27, 1, 0 }, + { 0x1, 0x1, 116, -1, 1010, 37, 1, 3 }, + { 0x0, 0x0, 116, -1, 1010, 0, 1, 3 }, + { 0x0, 0x0, 117, 451, -1, 0, 1, 0 }, + { 0x3, 0x3, 117, 429, -1, 34, 1, 35 }, + { 0x3, 0x3, 117, 430, -1, 34, 1, 42 }, + { 0x1, 0x1, 118, 452, -1, 35, 1, 35 }, + { 0x1, 0x1, 118, 453, -1, 35, 1, 42 }, + { 0x0, 0x0, 119, -1, -1, 0, 1, 42 }, + { 0x0, 0x0, 119, -1, -1, 0, 1, 68 }, + { 0x1, 0x1, 119, -1, -1, 27, 1, 98 }, + { 0x0, 0x0, 119, -1, -1, 0, 1, 107 }, + { 0x0, 0x0, 119, -1, -1, 0, 1, 75 }, + { 0x0, 0x0, 119, -1, -1, 0, 1, 76 }, + { 0x1, 0x1, 119, -1, -1, 27, 1, 119 }, + { 0x1, 0x1, 119, -1, -1, 27, 1, 42 }, + { 0x0, 0x0, 120, 884, 259, 0, 0, -1 }, + { 0x0, 0x0, 120, 886, 262, 0, 0, -1 }, + { 0x1, 0x1, 121, -1, -1, 35, 1, 18 }, + { 0x1, 0x1, 121, 530, -1, 35, 1, 18 }, + { 0x1, 0x1, 121, -1, -1, 35, 1, 24 }, + { 0x1, 0x1, 121, 531, -1, 35, 1, 24 }, + { 0x1, 0x1, 121, -1, -1, 23, 1, 69 }, + { 0x0, 0x0, 125, 725, -1, 0, 1, 0 }, + { 0x1, 0x1, 125, 467, -1, 28, 1, 35 }, + { 0x1, 0x1, 125, 727, -1, 27, 1, 35 }, + { 0x1, 0x1, 125, 728, -1, 29, 1, 0 }, + { 0x0, 0x0, 125, -1, -1, 0, 1, 116 }, + { 0x1, 0x1, 125, -1, -1, 29, 1, 0 }, + { 0x0, 0x0, 125, -1, -1, 0, 1, 35 }, + { 0x0, 0x0, 125, 480, -1, 0, 1, 42 }, + { 0x0, 0x0, 138, 463, 1010, 0, 1, 3 }, + { 0x0, 0x0, 138, 469, 90, 0, 0, -1 }, + { 0x0, 0x0, 138, 470, 101, 0, 0, -1 }, + { 0x0, 0x0, 138, -1, 1010, 0, 1, 3 }, + { 0x0, 0x0, 138, 471, 92, 0, 0, -1 }, + { 0x0, 0x0, 138, 473, 763, 0, 0, -1 }, + { 0x1, 0x1, 138, 474, 1016, 33, 1, 56 }, + { 0x0, 0x0, 138, 475, 778, 0, 0, -1 }, + { 0x1, 0x1, 138, 476, -1, 28, 1, 51 }, + { 0x1, 0x1, 139, -1, 1010, 37, 1, 3 }, + { 0x0, 0x0, 139, -1, 1010, 0, 1, 3 }, + { 0x1, 0x1, 142, 932, 388, 3, 1, 24 }, + { 0x0, 0x0, 142, 933, 205, 0, 0, -1 }, + { 0x0, 0x0, 143, 726, -1, 0, 1, 35 }, + { 0x0, 0x0, 144, 477, 1010, 0, 1, 3 }, + { 0x0, 0x0, 144, -1, 87, 0, 0, -1 }, + { 0x0, 0x0, 144, -1, 103, 0, 0, -1 }, + { 0x0, 0x0, 144, -1, 94, 0, 0, -1 }, + { 0x0, 0x0, 144, 541, 1010, 0, 1, 3 }, + { 0x0, 0x0, 144, 1019, 765, 0, 0, -1 }, + { 0x1, 0x1, 144, 1020, 1016, 36, 1, 56 }, + { 0x0, 0x0, 144, 547, 779, 0, 0, -1 }, + { 0x1, 0x1, 144, 548, -1, 27, 1, 51 }, + { 0x1, 0x1, 145, 541, 1010, 37, 1, 3 }, + { 0x0, 0x0, 145, -1, 1010, 0, 1, 3 }, + { 0x0, 0x0, 146, -1, -1, 0, 1, 35 }, + { 0x0, 0x0, 146, -1, -1, 0, 1, 42 }, + { 0x0, 0x0, 147, -1, -1, 0, 1, 42 }, + { 0x0, 0x0, 147, -1, -1, 0, 1, 68 }, + { 0x0, 0x0, 147, -1, 1011, 0, 1, 65 }, + { 0x0, 0x0, 147, -1, -1, 0, 1, 83 }, + { 0x0, 0x0, 147, -1, -1, 0, 1, 87 }, + { 0x1, 0x1, 148, -1, 121, 12, 1, 8 }, + { 0x600001, 0x600001, 148, -1, 121, 12, 1, 8 }, + { 0x400001, 0x400001, 148, -1, 121, 12, 1, 8 }, + { 0x200001, 0x200001, 148, -1, 121, 12, 1, 8 }, + { 0x18000041, 0x18000041, 148, -1, 123, 6, 1, 9 }, + { 0x10000041, 0x10000041, 148, -1, 123, 6, 1, 9 }, + { 0x8000041, 0x8000041, 148, -1, 123, 6, 1, 9 }, + { 0x41, 0x41, 148, -1, 123, 6, 1, 9 }, + { 0x600001, 0x600001, 148, -1, 124, 12, 1, 10 }, + { 0x400001, 0x400001, 148, -1, 124, 12, 1, 10 }, + { 0x200001, 0x200001, 148, -1, 124, 12, 1, 10 }, + { 0x1, 0x1, 148, -1, 124, 12, 1, 10 }, + { 0x600001, 0x600001, 148, -1, 125, 12, 1, 17 }, + { 0x400001, 0x400001, 148, -1, 125, 12, 1, 17 }, + { 0x200001, 0x200001, 148, -1, 125, 12, 1, 17 }, + { 0x1, 0x1, 148, -1, 125, 12, 1, 17 }, + { 0x1, 0x1, 148, -1, 126, 12, 1, 19 }, + { 0x600001, 0x600001, 148, -1, 126, 12, 1, 19 }, + { 0x400001, 0x400001, 148, -1, 126, 12, 1, 19 }, + { 0x200001, 0x200001, 148, -1, 126, 12, 1, 19 }, + { 0x600001, 0x600001, 148, -1, 128, 12, 1, 20 }, + { 0x400001, 0x400001, 148, -1, 128, 12, 1, 20 }, + { 0x200001, 0x200001, 148, -1, 128, 12, 1, 20 }, + { 0x1, 0x1, 148, -1, 128, 12, 1, 20 }, + { 0x18000041, 0x18000041, 148, -1, 128, 6, 1, 20 }, + { 0x10000041, 0x10000041, 148, -1, 128, 6, 1, 20 }, + { 0x8000041, 0x8000041, 148, -1, 128, 6, 1, 20 }, + { 0x41, 0x41, 148, -1, 128, 6, 1, 20 }, + { 0x600001, 0x600001, 148, -1, 129, 12, 1, 21 }, + { 0x400001, 0x400001, 148, -1, 129, 12, 1, 21 }, + { 0x200001, 0x200001, 148, -1, 129, 12, 1, 21 }, + { 0x1, 0x1, 148, -1, 129, 12, 1, 21 }, + { 0x600001, 0x600001, 148, -1, 130, 12, 1, 22 }, + { 0x400001, 0x400001, 148, -1, 130, 12, 1, 22 }, + { 0x200001, 0x200001, 148, -1, 130, 12, 1, 22 }, + { 0x1, 0x1, 148, -1, 130, 12, 1, 22 }, + { 0x18000041, 0x18000041, 148, -1, 130, 6, 1, 22 }, + { 0x10000041, 0x10000041, 148, -1, 130, 6, 1, 22 }, + { 0x8000041, 0x8000041, 148, -1, 130, 6, 1, 22 }, + { 0x41, 0x41, 148, -1, 130, 6, 1, 22 }, + { 0x600001, 0x600001, 148, -1, 131, 12, 1, 23 }, + { 0x400001, 0x400001, 148, -1, 131, 12, 1, 23 }, + { 0x200001, 0x200001, 148, -1, 131, 12, 1, 23 }, + { 0x1, 0x1, 148, -1, 131, 12, 1, 23 }, + { 0x0, 0x0, 148, -1, 158, 0, 0, -1 }, + { 0x0, 0x0, 148, -1, 187, 0, 0, -1 }, + { 0x0, 0x0, 148, -1, 217, 0, 0, -1 }, + { 0x0, 0x0, 148, -1, 233, 0, 0, -1 }, + { 0x0, 0x0, 148, -1, 249, 0, 0, -1 }, + { 0x0, 0x0, 148, 934, 241, 0, 0, -1 }, + { 0x0, 0x0, 148, -1, 257, 0, 0, -1 }, + { 0x0, 0x0, 148, 740, 225, 0, 0, -1 }, + { 0x0, 0x0, 157, -1, -1, 0, 1, 77 }, + { 0x9, 0x9, 157, -1, 657, 32, 1, 131 }, + { 0x9, 0x9, 157, -1, 664, 32, 1, 141 }, + { 0x0, 0x0, 158, -1, 87, 0, 0, -1 }, + { 0x1, 0x1, 158, -1, 1010, 38, 1, 3 }, + { 0x0, 0x0, 158, -1, 101, 0, 0, -1 }, + { 0x0, 0x0, 158, -1, 92, 0, 0, -1 }, + { 0x0, 0x0, 159, 554, 761, 0, 0, -1 }, + { 0x0, 0x0, 159, 555, 1016, 0, 1, 56 }, + { 0x0, 0x0, 159, 556, 780, 0, 0, -1 }, + { 0x1, 0x1, 159, 557, -1, 29, 1, 51 }, + { 0x0, 0x0, 160, 551, 769, 0, 0, -1 }, + { 0x1, 0x9, 160, 552, 1016, 33, 1, 56 }, + { 0x0, 0x0, 161, -1, 761, 0, 0, -1 }, + { 0x0, 0x0, 161, -1, 1016, 0, 1, 56 }, + { 0x1, 0x1, 162, 563, -1, 27, 1, 35 }, + { 0x0, 0x0, 163, 558, 763, 0, 0, -1 }, + { 0x1, 0x1, 163, 559, 1016, 33, 1, 56 }, + { 0x0, 0x0, 163, 560, 781, 0, 0, -1 }, + { 0x3, 0x3, 163, 561, -1, 28, 1, 51 }, + { 0x0, 0x0, 164, 720, 765, 0, 0, -1 }, + { 0x1, 0x1, 164, 721, 1016, 36, 1, 56 }, + { 0x0, 0x0, 164, 722, 782, 0, 0, -1 }, + { 0x5, 0x5, 164, 723, -1, 27, 1, 51 }, + { 0x0, 0x0, 165, -1, 1011, 0, 1, 65 }, + { 0x1, 0x1, 167, -1, -1, 28, 1, 35 }, + { 0x1, 0x1, 168, 749, -1, 27, 1, 35 }, + { 0x1, 0x1, 169, -1, 441, 0, 1, 18 }, + { 0x7, 0x7, 169, 939, 441, 0, 1, 18 }, + { 0x1, 0x1, 169, 940, 441, 2, 1, 18 }, + { 0x0, 0x0, 169, 941, 152, 0, 0, -1 }, + { 0x21, 0x21, 169, -1, 441, 0, 1, 18 }, + { 0x27, 0x27, 169, 942, 441, 0, 1, 18 }, + { 0x9, 0x9, 169, 943, 441, 2, 1, 18 }, + { 0x0, 0x0, 169, 944, 156, 0, 0, -1 }, + { 0x11, 0x11, 169, -1, 441, 0, 1, 18 }, + { 0x17, 0x17, 169, 945, 441, 0, 1, 18 }, + { 0x5, 0x5, 169, 946, 441, 2, 1, 18 }, + { 0x0, 0x0, 169, 947, 162, 0, 0, -1 }, + { 0x8000011, 0x8000011, 169, -1, 441, 0, 1, 18 }, + { 0x8000017, 0x8000017, 169, 948, 441, 0, 1, 18 }, + { 0x2000005, 0x2000005, 169, 949, 441, 2, 1, 18 }, + { 0x0, 0x0, 169, 950, 168, 0, 0, -1 }, + { 0x8000001, 0x8000001, 169, -1, 441, 0, 1, 18 }, + { 0x8000007, 0x8000007, 169, 951, 441, 0, 1, 18 }, + { 0x2000001, 0x2000001, 169, 952, 441, 2, 1, 18 }, + { 0x0, 0x0, 169, 953, 174, 0, 0, -1 }, + { 0x1, 0x1, 169, -1, 443, 0, 1, 24 }, + { 0x7, 0x7, 169, 954, 443, 0, 1, 24 }, + { 0x1, 0x1, 169, 955, 443, 2, 1, 24 }, + { 0x0, 0x0, 169, 956, 181, 0, 0, -1 }, + { 0x21, 0x21, 169, -1, 443, 0, 1, 24 }, + { 0x27, 0x27, 169, 957, 443, 0, 1, 24 }, + { 0x9, 0x9, 169, 958, 443, 2, 1, 24 }, + { 0x0, 0x0, 169, 959, 185, 0, 0, -1 }, + { 0x11, 0x11, 169, -1, 443, 0, 1, 24 }, + { 0x17, 0x17, 169, 960, 443, 0, 1, 24 }, + { 0x5, 0x5, 169, 961, 443, 2, 1, 24 }, + { 0x0, 0x0, 169, 962, 191, 0, 0, -1 }, + { 0x19, 0x19, 169, -1, 443, 0, 1, 24 }, + { 0x1f, 0x1f, 169, 963, 443, 0, 1, 24 }, + { 0x7, 0x7, 169, 964, 443, 2, 1, 24 }, + { 0x0, 0x0, 169, 965, 197, 0, 0, -1 }, + { 0x9, 0x9, 169, -1, 443, 0, 1, 24 }, + { 0xf, 0xf, 169, 966, 443, 0, 1, 24 }, + { 0x3, 0x3, 169, 967, 443, 2, 1, 24 }, + { 0x0, 0x0, 169, 968, 203, 0, 0, -1 }, + { 0x1001, 0x1001, 169, -1, 445, 9, 1, 69 }, + { 0x1007, 0x1007, 169, 969, 445, 9, 1, 69 }, + { 0x401, 0x401, 169, 970, 445, 11, 1, 69 }, + { 0x0, 0x0, 169, 971, 211, 0, 0, -1 }, + { 0x1009, 0x1009, 169, -1, 445, 9, 1, 69 }, + { 0x100f, 0x100f, 169, 972, 445, 9, 1, 69 }, + { 0x403, 0x403, 169, 973, 445, 11, 1, 69 }, + { 0x0, 0x0, 169, 974, 215, 0, 0, -1 }, + { 0x801, 0x801, 169, -1, 445, 9, 1, 69 }, + { 0x807, 0x807, 169, 975, 445, 9, 1, 69 }, + { 0x201, 0x201, 169, 976, 445, 11, 1, 69 }, + { 0x0, 0x0, 169, 977, 219, 0, 0, -1 }, + { 0x809, 0x809, 169, -1, 445, 9, 1, 69 }, + { 0x80f, 0x80f, 169, 978, 445, 9, 1, 69 }, + { 0x203, 0x203, 169, 979, 445, 11, 1, 69 }, + { 0x0, 0x0, 169, 980, 223, 0, 0, -1 }, + { 0x3001, 0x3001, 169, -1, 445, 9, 1, 69 }, + { 0x3007, 0x3007, 169, 981, 445, 9, 1, 69 }, + { 0xc01, 0xc01, 169, 982, 445, 11, 1, 69 }, + { 0x0, 0x0, 169, 983, 227, 0, 0, -1 }, + { 0x3009, 0x3009, 169, -1, 445, 9, 1, 69 }, + { 0x300f, 0x300f, 169, 984, 445, 9, 1, 69 }, + { 0xc03, 0xc03, 169, 985, 445, 11, 1, 69 }, + { 0x0, 0x0, 169, 986, 231, 0, 0, -1 }, + { 0x2801, 0x2801, 169, -1, 445, 9, 1, 69 }, + { 0x2807, 0x2807, 169, 987, 445, 9, 1, 69 }, + { 0xa01, 0xa01, 169, 988, 445, 11, 1, 69 }, + { 0x0, 0x0, 169, 989, 235, 0, 0, -1 }, + { 0x2809, 0x2809, 169, -1, 445, 9, 1, 69 }, + { 0x280f, 0x280f, 169, 990, 445, 9, 1, 69 }, + { 0xa03, 0xa03, 169, 991, 445, 11, 1, 69 }, + { 0x0, 0x0, 169, 992, 239, 0, 0, -1 }, + { 0x2001, 0x2001, 169, -1, 445, 9, 1, 69 }, + { 0x2007, 0x2007, 169, 993, 445, 9, 1, 69 }, + { 0x801, 0x801, 169, 994, 445, 11, 1, 69 }, + { 0x0, 0x0, 169, 995, 243, 0, 0, -1 }, + { 0x2009, 0x2009, 169, -1, 445, 9, 1, 69 }, + { 0x200f, 0x200f, 169, 996, 445, 9, 1, 69 }, + { 0x803, 0x803, 169, 997, 445, 11, 1, 69 }, + { 0x0, 0x0, 169, 998, 247, 0, 0, -1 }, + { 0x1, 0x1, 169, -1, 445, 9, 1, 69 }, + { 0x7, 0x7, 169, 999, 445, 9, 1, 69 }, + { 0x1, 0x1, 169, 1000, 445, 11, 1, 69 }, + { 0x0, 0x0, 169, 1001, 251, 0, 0, -1 }, + { 0x9, 0x9, 169, -1, 445, 9, 1, 69 }, + { 0xf, 0xf, 169, 1002, 445, 9, 1, 69 }, + { 0x3, 0x3, 169, 1003, 445, 11, 1, 69 }, + { 0x0, 0x0, 169, 1004, 255, 0, 0, -1 }, + { 0x1, 0x1, 170, 676, -1, 28, 1, 134 }, + { 0x1, 0x1, 170, 677, -1, 28, 1, 135 }, + { 0x1, 0x1, 170, 678, -1, 28, 1, 128 }, + { 0x1, 0x1, 170, 679, -1, 28, 1, 126 }, + { 0x1, 0x1, 170, 680, -1, 28, 1, 131 }, + { 0x1, 0x1, 170, 681, -1, 28, 1, 127 }, + { 0x1, 0x1, 170, 682, -1, 28, 1, 129 }, + { 0x1, 0x1, 170, 683, -1, 28, 1, 126 }, + { 0x1, 0x1, 170, 684, -1, 28, 1, 130 }, + { 0x1, 0x1, 170, 685, -1, 28, 1, 137 }, + { 0x1, 0x1, 170, 686, -1, 28, 1, 139 }, + { 0x1, 0x1, 170, 687, -1, 28, 1, 141 }, + { 0x1, 0x1, 170, 688, -1, 28, 1, 138 }, + { 0x1, 0x1, 170, 689, -1, 28, 1, 140 }, + { 0x1, 0x1, 170, 690, -1, 28, 1, 137 }, + { 0x1, 0x1, 170, 672, -1, 28, 1, 142 }, + { 0x1, 0x1, 170, 673, -1, 28, 1, 143 }, + { 0x1, 0x1, 170, 674, -1, 28, 1, 144 }, + { 0x1, 0x1, 170, 675, -1, 28, 1, 145 }, + { 0x1, 0x1, 171, 691, -1, 29, 1, 142 }, + { 0x1, 0x1, 171, 692, -1, 29, 1, 143 }, + { 0x1, 0x1, 171, 693, -1, 29, 1, 144 }, + { 0x1, 0x1, 171, 694, -1, 29, 1, 145 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 134 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 135 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 128 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 126 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 131 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 127 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 129 }, + { 0x3, 0x3, 172, 753, -1, 28, 1, 126 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 130 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 137 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 139 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 141 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 138 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 140 }, + { 0x3, 0x3, 172, 754, -1, 28, 1, 137 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 142 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 143 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 144 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 145 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 132 }, + { 0x3, 0x3, 172, 734, -1, 28, 1, 132 }, + { 0x3, 0x3, 172, -1, -1, 28, 1, 133 }, + { 0x3, 0x3, 172, 735, -1, 28, 1, 132 }, + { 0x0, 0x0, 173, 1036, 95, 0, 0, -1 }, + { 0x0, 0x0, 173, 1037, 97, 0, 1, 3 }, + { 0x11, 0x31, 174, 1010, 99, 33, 1, 6 }, + { 0x2200001, 0x2200001, 174, -1, 99, 12, 1, 6 }, + { 0x11, 0x11, 174, -1, 99, 33, 1, 6 }, + { 0x1, 0x1, 174, -1, 99, 37, 1, 6 }, + { 0x2000001, 0x2000001, 174, -1, 99, 12, 1, 6 }, + { 0x200001, 0x200001, 174, -1, 104, 12, 1, 6 }, + { 0x1, 0x1, 174, 1010, 104, 33, 1, 6 }, + { 0x2000001, 0x2000001, 175, -1, -1, 12, 1, 6 }, + { 0x1, 0x1, 175, -1, -1, 37, 1, 6 }, + { 0x2200001, 0x2200001, 175, -1, -1, 12, 1, 6 }, + { 0x11, 0x11, 175, -1, -1, 33, 1, 6 }, + { 0x1, 0x1, 175, -1, -1, 12, 1, 7 }, + { 0x0, 0x0, 175, -1, -1, 0, 1, 7 }, + { 0x200001, 0x200001, 175, -1, -1, 12, 1, 7 }, + { 0x1, 0x1, 175, -1, -1, 33, 1, 7 }, + { 0x9, 0x9, 175, -1, -1, 33, 1, 7 }, + { 0x1, 0x1, 175, 1010, -1, 33, 1, 6 }, + { 0x1200001, 0x1200001, 175, -1, -1, 12, 1, 7 }, + { 0x200001, 0x200001, 175, -1, -1, 12, 1, 6 }, + { 0x0, 0x0, 176, -1, 767, 0, 0, -1 }, + { 0x9, 0x9, 176, -1, 1017, 33, 1, 51 }, + { 0x0, 0x0, 176, 1021, 783, 0, 0, -1 }, + { 0x7, 0x7, 176, 1022, -1, 27, 1, 51 }, + { 0x1, 0x1, 196, -1, -1, 27, 1, 12 }, + { 0x1, 0x1, 210, -1, -1, 29, 1, 0 }, + { 0x2, 0x3, 210, -1, -1, 27, 1, 35 }, + { 0x0, 0x0, 210, -1, -1, 0, 1, 35 }, + { 0x0, 0x0, 210, -1, -1, 0, 1, 0 }, + { 0x0, 0x0, 210, 1026, -1, 0, 1, 95 }, + { 0x0, 0x0, 210, 741, 336, 0, 0, -1 }, + { 0x1, 0x1, 211, -1, -1, 27, 1, 0 }, + { 0x1, 0x1, 212, -1, 653, 32, 1, 134 }, + { 0x1, 0x1, 212, -1, 654, 32, 1, 135 }, + { 0x1, 0x1, 212, -1, 695, 32, 1, 132 }, + { 0x1, 0x1, 212, 882, 695, 32, 1, 132 }, + { 0x0, 0x0, 213, -1, 264, 0, 0, -1 }, + { 0x0, 0x0, 213, -1, 265, 0, 0, -1 }, + { 0x0, 0x0, 213, 929, 306, 0, 0, -1 }, + { 0x0, 0x0, 213, 931, 308, 0, 0, -1 }, + { 0x0, 0x0, 213, 935, 312, 0, 0, -1 }, + { 0x0, 0x0, 217, 1027, 337, 0, 0, -1 }, + { 0x0, 0x0, 218, -1, 432, 0, 0, -1 }, + { 0x0, 0x0, 218, -1, 482, 0, 0, -1 }, + { 0x0, 0x0, 218, -1, -1, 0, 1, 123 }, + { 0x0, 0x0, 218, -1, -1, 0, 1, 68 }, + { 0x1, 0x1, 218, 756, 757, 36, 1, 67 }, + { 0x1, 0x1, 218, 756, 788, 36, 1, 67 }, + { 0x0, 0x0, 218, -1, 775, 0, 0, -1 }, + { 0x0, 0x0, 218, 879, -1, 0, 1, 35 }, + { 0x0, 0x0, 218, 756, 776, 0, 0, -1 }, + { 0x1, 0x1, 218, -1, -1, 36, 1, 67 }, + { 0x1, 0x1, 218, 880, -1, 31, 1, 136 }, + { 0x1, 0x1, 218, 877, 658, 32, 1, 127 }, + { 0x1, 0x1, 218, 878, 665, 32, 1, 138 }, + { 0x1, 0x1, 218, 881, -1, 31, 1, 146 }, + { 0x0, 0x0, 219, 787, -1, 0, 1, 30 }, + { 0x0, 0x0, 219, 788, -1, 0, 1, 67 }, + { 0x0, 0x0, 219, 789, -1, 0, 1, 46 }, + { 0x0, 0x0, 219, 790, -1, 0, 1, 41 }, + { 0x1, 0x1, 219, 791, -1, 12, 1, 60 }, + { 0x0, 0x0, 219, 792, -1, 0, 1, 55 }, + { 0x200001, 0x200001, 219, 793, -1, 12, 1, 60 }, + { 0x1, 0x1, 219, 794, -1, 33, 1, 55 }, + { 0x1000001, 0x1000001, 219, 795, -1, 12, 1, 60 }, + { 0x1, 0x1, 219, 796, -1, 36, 1, 55 }, + { 0x1200001, 0x1200001, 219, 797, -1, 12, 1, 50 }, + { 0x9, 0x9, 219, 798, -1, 33, 1, 50 }, + { 0x200001, 0x1200001, 219, 799, -1, 12, 1, 60 }, + { 0x1, 0x9, 219, 800, -1, 33, 1, 55 }, + { 0x1, 0x1, 219, 801, -1, 28, 1, 30 }, + { 0x0, 0x0, 219, 802, -1, 0, 1, 30 }, + { 0x3, 0x3, 219, 803, -1, 27, 1, 30 }, + { 0x1, 0x1, 219, 804, -1, 27, 1, 30 }, + { 0x1, 0x1, 219, 805, -1, 37, 1, 30 }, + { 0x1, 0x1, 219, -1, -1, 36, 1, 67 }, + { 0x1, 0x1, 219, 806, -1, 36, 1, 67 }, + { 0x0, 0x0, 219, 807, -1, 0, 1, 50 }, + { 0x1, 0x1, 219, 808, -1, 28, 1, 50 }, + { 0x1, 0x1, 219, 809, -1, 27, 1, 50 }, + { 0x1, 0x1, 219, 810, -1, 29, 1, 50 }, + { 0x3, 0x3, 219, 811, -1, 28, 1, 50 }, + { 0x5, 0x5, 219, 812, -1, 27, 1, 50 }, + { 0x7, 0x7, 219, 813, -1, 27, 1, 50 }, + { 0x3, 0x3, 219, 814, -1, 27, 1, 50 }, + { 0x0, 0x0, 219, 815, -1, 0, 1, 25 }, + { 0x0, 0x0, 219, 816, -1, 0, 1, 36 }, + { 0x1, 0x1, 220, 817, -1, 34, 1, 32 }, + { 0x1, 0x1, 220, 818, -1, 34, 1, 67 }, + { 0x1, 0x1, 220, 819, -1, 34, 1, 47 }, + { 0x1, 0x1, 220, 820, -1, 34, 1, 43 }, + { 0x400001, 0x400001, 220, 821, -1, 12, 1, 62 }, + { 0x1, 0x1, 220, 822, -1, 34, 1, 57 }, + { 0x600001, 0x600001, 220, 823, -1, 12, 1, 62 }, + { 0x3, 0x3, 220, 824, -1, 33, 1, 57 }, + { 0x1400001, 0x1400001, 220, 825, -1, 12, 1, 62 }, + { 0x5, 0x5, 220, 826, -1, 34, 1, 57 }, + { 0x1600001, 0x1600001, 220, 827, -1, 12, 1, 52 }, + { 0xb, 0xb, 220, 828, -1, 33, 1, 52 }, + { 0x600001, 0x1600001, 220, 829, -1, 12, 1, 62 }, + { 0x3, 0xb, 220, 830, -1, 33, 1, 57 }, + { 0x41, 0x41, 220, 831, -1, 28, 1, 32 }, + { 0x1, 0x1, 220, 832, -1, 34, 1, 32 }, + { 0x83, 0x83, 220, 833, -1, 27, 1, 32 }, + { 0x81, 0x81, 220, 834, -1, 27, 1, 32 }, + { 0x9, 0x9, 220, 835, -1, 34, 1, 32 }, + { 0x5, 0x5, 220, 836, -1, 34, 1, 67 }, + { 0x1, 0x1, 220, 837, -1, 34, 1, 52 }, + { 0x41, 0x41, 220, 838, -1, 28, 1, 52 }, + { 0x81, 0x81, 220, 839, -1, 27, 1, 52 }, + { 0x21, 0x21, 220, 840, -1, 29, 1, 52 }, + { 0x43, 0x43, 220, 841, -1, 28, 1, 52 }, + { 0x85, 0x85, 220, 842, -1, 27, 1, 52 }, + { 0x87, 0x87, 220, 843, -1, 27, 1, 52 }, + { 0x83, 0x83, 220, 844, -1, 27, 1, 52 }, + { 0x1, 0x1, 220, 845, -1, 34, 1, 27 }, + { 0x1, 0x1, 220, 846, -1, 34, 1, 38 }, + { 0x1, 0x1, 221, 847, -1, 35, 1, 33 }, + { 0x1, 0x1, 221, 848, -1, 35, 1, 67 }, + { 0x1, 0x1, 221, 849, -1, 35, 1, 48 }, + { 0x1, 0x1, 221, 850, -1, 35, 1, 44 }, + { 0x800001, 0x800001, 221, 851, -1, 12, 1, 63 }, + { 0x1, 0x1, 221, 852, -1, 35, 1, 58 }, + { 0xa00001, 0xa00001, 221, 853, -1, 12, 1, 63 }, + { 0x5, 0x5, 221, 854, -1, 33, 1, 58 }, + { 0x1800001, 0x1800001, 221, 855, -1, 12, 1, 63 }, + { 0x3, 0x3, 221, 856, -1, 35, 1, 58 }, + { 0x1a00001, 0x1a00001, 221, 857, -1, 12, 1, 53 }, + { 0xd, 0xd, 221, 858, -1, 33, 1, 53 }, + { 0xa00001, 0x1a00001, 221, 859, -1, 12, 1, 63 }, + { 0x5, 0xd, 221, 860, -1, 33, 1, 58 }, + { 0x81, 0x81, 221, 861, -1, 28, 1, 33 }, + { 0x1, 0x1, 221, 862, -1, 35, 1, 33 }, + { 0x103, 0x103, 221, 863, -1, 27, 1, 33 }, + { 0x101, 0x101, 221, 864, -1, 27, 1, 33 }, + { 0x5, 0x5, 221, 865, -1, 35, 1, 33 }, + { 0x3, 0x3, 221, 866, -1, 35, 1, 67 }, + { 0x1, 0x1, 221, 867, -1, 35, 1, 53 }, + { 0x81, 0x81, 221, 868, -1, 28, 1, 53 }, + { 0x101, 0x101, 221, 869, -1, 27, 1, 53 }, + { 0x41, 0x41, 221, 870, -1, 29, 1, 53 }, + { 0x83, 0x83, 221, 871, -1, 28, 1, 53 }, + { 0x105, 0x105, 221, 872, -1, 27, 1, 53 }, + { 0x107, 0x107, 221, 873, -1, 27, 1, 53 }, + { 0x103, 0x103, 221, 874, -1, 27, 1, 53 }, + { 0x1, 0x1, 221, 875, -1, 35, 1, 28 }, + { 0x1, 0x1, 221, 876, -1, 35, 1, 39 }, + { 0x3, 0x3, 222, -1, -1, 34, 1, 34 }, + { 0x3, 0x3, 222, -1, -1, 34, 1, 67 }, + { 0x3, 0x3, 222, -1, -1, 34, 1, 49 }, + { 0x3, 0x3, 222, -1, -1, 34, 1, 45 }, + { 0xc00001, 0xc00001, 222, -1, -1, 12, 1, 64 }, + { 0x3, 0x3, 222, 1012, -1, 34, 1, 59 }, + { 0xe00001, 0xe00001, 222, -1, -1, 12, 1, 64 }, + { 0x7, 0x7, 222, 1013, -1, 33, 1, 59 }, + { 0x1c00001, 0x1c00001, 222, -1, -1, 12, 1, 64 }, + { 0x7, 0x7, 222, 1014, -1, 34, 1, 59 }, + { 0x1e00001, 0x1e00001, 222, -1, -1, 12, 1, 54 }, + { 0xf, 0xf, 222, 1015, -1, 33, 1, 54 }, + { 0xe00001, 0x1e00001, 222, -1, -1, 12, 1, 64 }, + { 0x7, 0xf, 222, 1018, -1, 33, 1, 59 }, + { 0xc1, 0xc1, 222, -1, -1, 28, 1, 34 }, + { 0x3, 0x3, 222, 1005, -1, 34, 1, 34 }, + { 0x183, 0x183, 222, -1, -1, 27, 1, 34 }, + { 0x181, 0x181, 222, 1006, -1, 27, 1, 34 }, + { 0xb, 0xb, 222, -1, -1, 34, 1, 34 }, + { 0x7, 0x7, 222, -1, -1, 34, 1, 67 }, + { 0x3, 0x3, 222, -1, -1, 34, 1, 54 }, + { 0xc1, 0xc1, 222, -1, -1, 28, 1, 54 }, + { 0x181, 0x181, 222, -1, -1, 27, 1, 54 }, + { 0x61, 0x61, 222, -1, -1, 29, 1, 54 }, + { 0xc3, 0xc3, 222, -1, -1, 28, 1, 54 }, + { 0x185, 0x185, 222, -1, -1, 27, 1, 54 }, + { 0x187, 0x187, 222, -1, -1, 27, 1, 54 }, + { 0x183, 0x183, 222, -1, -1, 27, 1, 54 }, + { 0x3, 0x3, 222, -1, -1, 34, 1, 29 }, + { 0x3, 0x3, 222, -1, -1, 34, 1, 40 }, + { 0x3, 0x3, 223, -1, 659, 32, 1, 129 }, + { 0x3, 0x3, 223, -1, 666, 32, 1, 140 }, + { 0x1, 0x1, 224, -1, -1, 28, 1, 35 }, + { 0x0, 0x0, 231, -1, -1, 0, 1, 136 }, + { 0x0, 0x0, 231, -1, -1, 0, 1, 146 }, + { 0x1, 0x1, 232, -1, 697, 33, 1, 133 }, + { 0x0, 0x0, 232, -1, 695, 0, 1, 132 }, + { 0x0, 0x0, 233, 906, 342, 0, 0, -1 }, + { 0x0, 0x0, 233, 907, 345, 0, 0, -1 }, + { 0x1, 0x1, 233, 908, 121, 33, 1, 8 }, + { 0x8000001, 0x8000001, 233, 909, 123, 6, 1, 9 }, + { 0x0, 0x0, 233, 910, 349, 0, 0, -1 }, + { 0x1, 0x1, 233, 911, 124, 33, 1, 10 }, + { 0x0, 0x0, 233, 912, 353, 0, 0, -1 }, + { 0x1, 0x1, 233, 913, 125, 33, 1, 17 }, + { 0x0, 0x0, 233, 914, 358, 0, 0, -1 }, + { 0x1, 0x1, 233, 915, 126, 33, 1, 19 }, + { 0x0, 0x0, 233, 916, 361, 0, 0, -1 }, + { 0x0, 0x0, 233, 917, 365, 0, 0, -1 }, + { 0x1, 0x1, 233, 918, 128, 33, 1, 20 }, + { 0x8000001, 0x8000001, 233, 919, 128, 6, 1, 20 }, + { 0x0, 0x0, 233, 920, 369, 0, 0, -1 }, + { 0x1, 0x1, 233, 921, 129, 33, 1, 21 }, + { 0x0, 0x0, 233, 922, 373, 0, 0, -1 }, + { 0x0, 0x0, 233, 923, 377, 0, 0, -1 }, + { 0x1, 0x1, 233, 924, 130, 33, 1, 22 }, + { 0x8000001, 0x8000001, 233, 925, 130, 6, 1, 22 }, + { 0x0, 0x0, 233, 926, 381, 0, 0, -1 }, + { 0x1, 0x1, 233, 927, 131, 33, 1, 23 }, + { 0x0, 0x0, 234, -1, 339, 0, 0, -1 }, + { 0x0, 0x0, 234, -1, 346, 0, 0, -1 }, + { 0x0, 0x0, 234, -1, 121, 0, 1, 8 }, + { 0x1, 0x1, 234, -1, 123, 6, 1, 9 }, + { 0x0, 0x0, 234, -1, 350, 0, 0, -1 }, + { 0x0, 0x0, 234, -1, 124, 0, 1, 10 }, + { 0x0, 0x0, 234, -1, 354, 0, 0, -1 }, + { 0x0, 0x0, 234, -1, 125, 0, 1, 17 }, + { 0x0, 0x0, 234, -1, 355, 0, 0, -1 }, + { 0x0, 0x0, 234, -1, 126, 0, 1, 19 }, + { 0x0, 0x0, 234, -1, 362, 0, 0, -1 }, + { 0x0, 0x0, 234, -1, 366, 0, 0, -1 }, + { 0x0, 0x0, 234, -1, 128, 0, 1, 20 }, + { 0x1, 0x1, 234, -1, 128, 6, 1, 20 }, + { 0x0, 0x0, 234, -1, 370, 0, 0, -1 }, + { 0x0, 0x0, 234, -1, 129, 0, 1, 21 }, + { 0x0, 0x0, 234, -1, 374, 0, 0, -1 }, + { 0x0, 0x0, 234, -1, 378, 0, 0, -1 }, + { 0x0, 0x0, 234, -1, 130, 0, 1, 22 }, + { 0x1, 0x1, 234, -1, 130, 6, 1, 22 }, + { 0x0, 0x0, 234, -1, 382, 0, 0, -1 }, + { 0x0, 0x0, 234, -1, 131, 0, 1, 23 }, + { 0x1, 0x1, 234, -1, 383, 27, 1, 18 }, + { 0x0, 0x0, 234, -1, 383, 0, 1, 18 }, + { 0x0, 0x0, 234, -1, 176, 0, 0, -1 }, + { 0x0, 0x0, 234, -1, 180, 0, 0, -1 }, + { 0x0, 0x0, 234, -1, 388, 0, 1, 24 }, + { 0x0, 0x0, 234, -1, 209, 0, 0, -1 }, + { 0x0, 0x0, 234, -1, 395, 0, 0, -1 }, + { 0x0, 0x0, 234, -1, 397, 0, 0, -1 }, + { 0x1, 0x1, 237, 1023, -1, 29, 1, 0 }, + { 0x0, 0x0, 237, -1, -1, 0, 1, 0 }, + { 0x1, 0x1, 237, 1024, -1, 27, 1, 0 }, + { 0x3, 0x3, 256, -1, 441, 1, 1, 18 }, + { 0x3, 0x3, 256, -1, 441, 0, 1, 18 }, + { 0x0, 0x0, 256, -1, 153, 0, 0, -1 }, + { 0x13, 0x13, 256, -1, 441, 1, 1, 18 }, + { 0x23, 0x23, 256, -1, 441, 0, 1, 18 }, + { 0x0, 0x0, 256, -1, 157, 0, 0, -1 }, + { 0xb, 0xb, 256, -1, 441, 1, 1, 18 }, + { 0x13, 0x13, 256, -1, 441, 0, 1, 18 }, + { 0x0, 0x0, 256, -1, 163, 0, 0, -1 }, + { 0x400000b, 0x400000b, 256, -1, 441, 1, 1, 18 }, + { 0x8000013, 0x8000013, 256, -1, 441, 0, 1, 18 }, + { 0x0, 0x0, 256, -1, 169, 0, 0, -1 }, + { 0x4000003, 0x4000003, 256, -1, 441, 1, 1, 18 }, + { 0x8000003, 0x8000003, 256, -1, 441, 0, 1, 18 }, + { 0x0, 0x0, 256, -1, 175, 0, 0, -1 }, + { 0x3, 0x3, 256, -1, 443, 1, 1, 24 }, + { 0x3, 0x3, 256, -1, 443, 0, 1, 24 }, + { 0x0, 0x0, 256, -1, 182, 0, 0, -1 }, + { 0x13, 0x13, 256, -1, 443, 1, 1, 24 }, + { 0x23, 0x23, 256, -1, 443, 0, 1, 24 }, + { 0x0, 0x0, 256, -1, 186, 0, 0, -1 }, + { 0xb, 0xb, 256, -1, 443, 1, 1, 24 }, + { 0x13, 0x13, 256, -1, 443, 0, 1, 24 }, + { 0x0, 0x0, 256, -1, 192, 0, 0, -1 }, + { 0xf, 0xf, 256, -1, 443, 1, 1, 24 }, + { 0x1b, 0x1b, 256, -1, 443, 0, 1, 24 }, + { 0x0, 0x0, 256, -1, 198, 0, 0, -1 }, + { 0x7, 0x7, 256, -1, 443, 1, 1, 24 }, + { 0xb, 0xb, 256, -1, 443, 0, 1, 24 }, + { 0x0, 0x0, 256, -1, 204, 0, 0, -1 }, + { 0x803, 0x803, 256, -1, 445, 10, 1, 69 }, + { 0x1003, 0x1003, 256, -1, 445, 9, 1, 69 }, + { 0x0, 0x0, 256, -1, 212, 0, 0, -1 }, + { 0x807, 0x807, 256, -1, 445, 10, 1, 69 }, + { 0x100b, 0x100b, 256, -1, 445, 9, 1, 69 }, + { 0x0, 0x0, 256, -1, 216, 0, 0, -1 }, + { 0x403, 0x403, 256, -1, 445, 10, 1, 69 }, + { 0x803, 0x803, 256, -1, 445, 9, 1, 69 }, + { 0x0, 0x0, 256, -1, 220, 0, 0, -1 }, + { 0x407, 0x407, 256, -1, 445, 10, 1, 69 }, + { 0x80b, 0x80b, 256, -1, 445, 9, 1, 69 }, + { 0x0, 0x0, 256, -1, 224, 0, 0, -1 }, + { 0x1803, 0x1803, 256, -1, 445, 10, 1, 69 }, + { 0x3003, 0x3003, 256, -1, 445, 9, 1, 69 }, + { 0x0, 0x0, 256, -1, 228, 0, 0, -1 }, + { 0x1807, 0x1807, 256, -1, 445, 10, 1, 69 }, + { 0x300b, 0x300b, 256, -1, 445, 9, 1, 69 }, + { 0x0, 0x0, 256, -1, 232, 0, 0, -1 }, + { 0x1403, 0x1403, 256, -1, 445, 10, 1, 69 }, + { 0x2803, 0x2803, 256, -1, 445, 9, 1, 69 }, + { 0x0, 0x0, 256, -1, 236, 0, 0, -1 }, + { 0x1407, 0x1407, 256, -1, 445, 10, 1, 69 }, + { 0x280b, 0x280b, 256, -1, 445, 9, 1, 69 }, + { 0x0, 0x0, 256, -1, 240, 0, 0, -1 }, + { 0x1003, 0x1003, 256, -1, 445, 10, 1, 69 }, + { 0x2003, 0x2003, 256, -1, 445, 9, 1, 69 }, + { 0x0, 0x0, 256, -1, 244, 0, 0, -1 }, + { 0x1007, 0x1007, 256, -1, 445, 10, 1, 69 }, + { 0x200b, 0x200b, 256, -1, 445, 9, 1, 69 }, + { 0x0, 0x0, 256, -1, 248, 0, 0, -1 }, + { 0x3, 0x3, 256, -1, 445, 10, 1, 69 }, + { 0x3, 0x3, 256, -1, 445, 9, 1, 69 }, + { 0x0, 0x0, 256, -1, 252, 0, 0, -1 }, + { 0x7, 0x7, 256, -1, 445, 10, 1, 69 }, + { 0xb, 0xb, 256, -1, 445, 9, 1, 69 }, + { 0x0, 0x0, 256, -1, 256, 0, 0, -1 }, + { 0x0, 0x0, 259, -1, 770, 0, 0, -1 }, + { 0x0, 0x0, 259, -1, 772, 0, 0, -1 }, + { 0x1, 0x1, 259, -1, -1, 28, 1, 31 }, + { 0x0, 0x0, 261, -1, -1, 0, 1, 0 }, + { 0x0, 0x1, 261, -1, -1, 29, 1, 0 }, + { 0x1, 0x1, 262, -1, -1, 12, 1, 4 }, + { 0x1, 0x1, 262, -1, -1, 12, 1, 66 }, + { 0x0, 0x0, 262, -1, 760, 0, 0, -1 }, + { 0x0, 0x0, 262, -1, 762, 0, 0, -1 }, + { 0x0, 0x0, 262, -1, 764, 0, 0, -1 }, + { 0x0, 0x0, 262, -1, 766, 0, 0, -1 }, + { 0x1, 0x1, 262, -1, -1, 12, 1, 61 }, + { 0x1, 0x1, 262, -1, -1, 12, 1, 51 }, + { 0x0, 0x0, 262, -1, 768, 0, 0, -1 }, + { 0x0, 0x0, 263, -1, 767, 0, 0, -1 }, + { 0x9, 0x9, 263, -1, 1017, 33, 1, 51 }, + { 0x0, 0x0, 263, -1, 784, 0, 0, -1 }, + { 0x3, 0x3, 263, -1, -1, 27, 1, 51 }, + { 0x0, 0x0, 267, -1, -1, 0, 1, 0 }, + { 0x3, 0x3, 268, 1025, -1, 27, 1, 0 }, + { 0x1, 0x1, 269, -1, -1, 28, 1, 0 }, + { 0x1, 0x1, 270, -1, -1, 27, 1, 95 }, + { 0x0, 0x0, 270, -1, 338, 0, 0, -1 }, + { 0x0, 0x0, 271, 1030, 270, 0, 0, -1 }, + { 0x0, 0x0, 271, 1031, 272, 0, 0, -1 }, + { 0x0, 0x0, 272, -1, 271, 0, 0, -1 }, + { 0x0, 0x0, 272, -1, 273, 0, 0, -1 }, + { 0x0, 0x0, 273, -1, -1, 0, 1, 42 }, + { 0x0, 0x0, 278, -1, -1, 0, 1, 35 }, + { 0x0, 0x0, 282, -1, 141, 0, 1, 31 }, + { 0x0, 0x0, 283, -1, -1, 0, 1, 73 }, + { 0x0, 0x0, 283, -1, 96, 0, 1, 3 }, + { 0x0, 0x0, 283, -1, 98, 0, 0, -1 }, +}; + +static const struct ia64_main_table +main_table[] = { + { 5, 1, 1, 0x10000000000ull, 0x1eff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 0, }, + { 5, 1, 1, 0x10008000000ull, 0x1eff8000000ull, { 23, 24, 25, 3, 0 }, 0x0, 0, }, + { 5, 7, 1, 0x0ull, 0x0ull, { 23, 65, 25, 0, 0 }, 0x0, 0, }, + { 6, 1, 1, 0x12000000000ull, 0x1e000000000ull, { 23, 65, 26, 0, 0 }, 0x0, 1, }, + { 7, 1, 1, 0x10040000000ull, 0x1eff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 0, }, + { 7, 1, 1, 0x10c00000000ull, 0x1ee00000000ull, { 23, 62, 25, 0, 0 }, 0x0, 0, }, + { 8, 1, 1, 0x10800000000ull, 0x1ee00000000ull, { 23, 62, 25, 0, 0 }, 0x0, 1, }, + { 9, 3, 1, 0x2c00000000ull, 0x1ee00000000ull, { 23, 2, 51, 52, 53 }, 0x221, 2, }, + { 10, 1, 1, 0x10060000000ull, 0x1eff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 0, }, + { 10, 1, 1, 0x10160000000ull, 0x1eff8000000ull, { 23, 54, 25, 0, 0 }, 0x0, 0, }, + { 11, 1, 1, 0x10068000000ull, 0x1eff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 0, }, + { 11, 1, 1, 0x10168000000ull, 0x1eff8000000ull, { 23, 54, 25, 0, 0 }, 0x0, 0, }, + { 14, 4, 0, 0x100000000ull, 0x1eff80011ffull, { 15, 0, 0, 0, 0 }, 0x40, 3, }, + { 14, 4, 0, 0x100000000ull, 0x1eff80011c0ull, { 15, 0, 0, 0, 0 }, 0x0, 135, }, + { 14, 4, 0, 0x100000000ull, 0x1eff80011c0ull, { 15, 0, 0, 0, 0 }, 0x40, 136, }, + { 14, 4, 0, 0x108000100ull, 0x1eff80011c0ull, { 15, 0, 0, 0, 0 }, 0x200, 736, }, + { 14, 4, 0, 0x108000100ull, 0x1eff80011c0ull, { 15, 0, 0, 0, 0 }, 0x240, 737, }, + { 14, 4, 1, 0x2000000000ull, 0x1ee00001000ull, { 14, 15, 0, 0, 0 }, 0x0, 113, }, + { 14, 4, 1, 0x2000000000ull, 0x1ee00001000ull, { 14, 15, 0, 0, 0 }, 0x40, 114, }, + { 14, 4, 0, 0x8000000000ull, 0x1ee000011ffull, { 80, 0, 0, 0, 0 }, 0x40, 4, }, + { 14, 4, 0, 0x8000000000ull, 0x1ee000011c0ull, { 80, 0, 0, 0, 0 }, 0x0, 137, }, + { 14, 4, 0, 0x8000000000ull, 0x1ee000011c0ull, { 80, 0, 0, 0, 0 }, 0x40, 138, }, + { 14, 4, 0, 0x8000000080ull, 0x1ee000011c0ull, { 80, 0, 0, 0, 0 }, 0x210, 1028, }, + { 14, 4, 0, 0x8000000080ull, 0x1ee000011c0ull, { 80, 0, 0, 0, 0 }, 0x250, 1029, }, + { 14, 4, 0, 0x8000000140ull, 0x1ee000011c0ull, { 80, 0, 0, 0, 0 }, 0x30, 119, }, + { 14, 4, 0, 0x8000000140ull, 0x1ee000011c0ull, { 80, 0, 0, 0, 0 }, 0x70, 120, }, + { 14, 4, 0, 0x8000000180ull, 0x1ee000011c0ull, { 80, 0, 0, 0, 0 }, 0x230, 117, }, + { 14, 4, 0, 0x8000000180ull, 0x1ee000011c0ull, { 80, 0, 0, 0, 0 }, 0x270, 118, }, + { 14, 4, 1, 0xa000000000ull, 0x1ee00001000ull, { 14, 80, 0, 0, 0 }, 0x0, 115, }, + { 14, 4, 1, 0xa000000000ull, 0x1ee00001000ull, { 14, 80, 0, 0, 0 }, 0x40, 116, }, + { 15, 4, 0, 0x0ull, 0x1e1f8000000ull, { 64, 0, 0, 0, 0 }, 0x0, 107, }, + { 15, 5, 0, 0x0ull, 0x1e3f8000000ull, { 64, 0, 0, 0, 0 }, 0x0, 333, }, + { 15, 2, 0, 0x0ull, 0x1eff8000000ull, { 64, 0, 0, 0, 0 }, 0x2, 431, }, + { 15, 3, 0, 0x0ull, 0x1eff8000000ull, { 64, 0, 0, 0, 0 }, 0x0, 481, }, + { 15, 6, 0, 0x0ull, 0x1eff8000000ull, { 68, 0, 0, 0, 0 }, 0x0, 1032, }, + { 15, 7, 0, 0x0ull, 0x0ull, { 64, 0, 0, 0, 0 }, 0x0, 5, }, + { 16, 6, 0, 0x18000000000ull, 0x1ee000011ffull, { 81, 0, 0, 0, 0 }, 0x40, 4, }, + { 16, 6, 0, 0x18000000000ull, 0x1ee000011c0ull, { 81, 0, 0, 0, 0 }, 0x0, 137, }, + { 16, 6, 0, 0x18000000000ull, 0x1ee000011c0ull, { 81, 0, 0, 0, 0 }, 0x40, 138, }, + { 16, 6, 1, 0x1a000000000ull, 0x1ee00001000ull, { 14, 81, 0, 0, 0 }, 0x0, 115, }, + { 16, 6, 1, 0x1a000000000ull, 0x1ee00001000ull, { 14, 81, 0, 0, 0 }, 0x40, 116, }, + { 17, 4, 0, 0x4080000000ull, 0x1e9f800003full, { 15, 76, 0, 0, 0 }, 0x20, 307, }, + { 17, 4, 0, 0x4080000000ull, 0x1e9f800003full, { 15, 76, 0, 0, 0 }, 0x60, 309, }, + { 17, 4, 0, 0xe000000000ull, 0x1e80000003full, { 80, 76, 0, 0, 0 }, 0x20, 310, }, + { 17, 4, 0, 0xe000000000ull, 0x1e80000003full, { 80, 76, 0, 0, 0 }, 0x60, 311, }, + { 18, 4, 0, 0x60000000ull, 0x1e1f8000000ull, { 0, 0, 0, 0, 0 }, 0x2c, 74, }, + { 22, 2, 0, 0x200000000ull, 0x1ee00000000ull, { 24, 79, 0, 0, 0 }, 0x0, 742, }, + { 22, 3, 0, 0x800000000ull, 0x1ee00000000ull, { 23, 80, 0, 0, 0 }, 0x0, 76, }, + { 22, 3, 0, 0xc00000000ull, 0x1ee00000000ull, { 17, 80, 0, 0, 0 }, 0x0, 76, }, + { 22, 3, 0, 0x2200000000ull, 0x1ee00000000ull, { 24, 79, 0, 0, 0 }, 0x0, 743, }, + { 22, 3, 0, 0x2600000000ull, 0x1ee00000000ull, { 18, 79, 0, 0, 0 }, 0x0, 744, }, + { 22, 7, 0, 0x0ull, 0x0ull, { 24, 79, 0, 0, 0 }, 0x0, 745, }, + { 25, 4, 0, 0x20000000ull, 0x1e1f8000000ull, { 0, 0, 0, 0, 0 }, 0x224, 6, }, + { 26, 1, 2, 0x18000000000ull, 0x1fe00001000ull, { 21, 22, 24, 25, 0 }, 0x0, 316, }, + { 26, 1, 2, 0x18000000000ull, 0x1fe00001000ull, { 22, 21, 25, 24, 0 }, 0x0, 454, }, + { 26, 1, 2, 0x18000000000ull, 0x1fe00001000ull, { 21, 22, 25, 24, 0 }, 0x0, 416, }, + { 26, 1, 2, 0x18000000000ull, 0x1fe00001000ull, { 22, 21, 24, 25, 0 }, 0x0, 407, }, + { 26, 1, 2, 0x18200000000ull, 0x1fe00001000ull, { 21, 22, 24, 25, 0 }, 0x40, 317, }, + { 26, 1, 2, 0x19000000000ull, 0x1fe00001000ull, { 21, 22, 6, 25, 0 }, 0x0, 408, }, + { 26, 1, 2, 0x19000000000ull, 0x1fe00001000ull, { 21, 22, 6, 25, 0 }, 0x40, 409, }, + { 26, 1, 2, 0x18800000000ull, 0x1ee00001000ull, { 21, 22, 54, 25, 0 }, 0x0, 316, }, + { 26, 1, 2, 0x18800000000ull, 0x1ee00001000ull, { 21, 22, 56, 25, 0 }, 0x0, 457, }, + { 26, 1, 2, 0x18800000000ull, 0x1ee00001000ull, { 22, 21, 56, 25, 0 }, 0x0, 419, }, + { 26, 1, 2, 0x18800000000ull, 0x1ee00001000ull, { 22, 21, 54, 25, 0 }, 0x0, 407, }, + { 26, 1, 2, 0x18a00000000ull, 0x1ee00001000ull, { 21, 22, 54, 25, 0 }, 0x40, 317, }, + { 26, 1, 2, 0x1a800000000ull, 0x1ee00001000ull, { 21, 22, 58, 25, 0 }, 0x0, 464, }, + { 26, 1, 2, 0x1a800000000ull, 0x1ee00001000ull, { 22, 21, 58, 25, 0 }, 0x0, 425, }, + { 26, 1, 2, 0x1c200000000ull, 0x1fe00001000ull, { 22, 21, 24, 25, 0 }, 0x40, 318, }, + { 26, 1, 2, 0x1d000000000ull, 0x1fe00001000ull, { 22, 21, 6, 25, 0 }, 0x40, 410, }, + { 26, 1, 2, 0x1ca00000000ull, 0x1ee00001000ull, { 22, 21, 54, 25, 0 }, 0x40, 318, }, + { 27, 1, 2, 0x18400000000ull, 0x1fe00001000ull, { 21, 22, 24, 25, 0 }, 0x0, 316, }, + { 27, 1, 2, 0x18400000000ull, 0x1fe00001000ull, { 22, 21, 25, 24, 0 }, 0x0, 454, }, + { 27, 1, 2, 0x18400000000ull, 0x1fe00001000ull, { 21, 22, 25, 24, 0 }, 0x0, 416, }, + { 27, 1, 2, 0x18400000000ull, 0x1fe00001000ull, { 22, 21, 24, 25, 0 }, 0x0, 407, }, + { 27, 1, 2, 0x18600000000ull, 0x1fe00001000ull, { 21, 22, 24, 25, 0 }, 0x40, 317, }, + { 27, 1, 2, 0x19400000000ull, 0x1fe00001000ull, { 21, 22, 6, 25, 0 }, 0x0, 408, }, + { 27, 1, 2, 0x19400000000ull, 0x1fe00001000ull, { 21, 22, 6, 25, 0 }, 0x40, 409, }, + { 27, 1, 2, 0x18c00000000ull, 0x1ee00001000ull, { 21, 22, 54, 25, 0 }, 0x0, 319, }, + { 27, 1, 2, 0x18c00000000ull, 0x1ee00001000ull, { 21, 22, 56, 25, 0 }, 0x0, 457, }, + { 27, 1, 2, 0x18c00000000ull, 0x1ee00001000ull, { 22, 21, 56, 25, 0 }, 0x0, 419, }, + { 27, 1, 2, 0x18c00000000ull, 0x1ee00001000ull, { 22, 21, 54, 25, 0 }, 0x0, 411, }, + { 27, 1, 2, 0x18e00000000ull, 0x1ee00001000ull, { 21, 22, 54, 25, 0 }, 0x40, 317, }, + { 27, 1, 2, 0x1ac00000000ull, 0x1ee00001000ull, { 21, 22, 55, 25, 0 }, 0x0, 478, }, + { 27, 1, 2, 0x1ac00000000ull, 0x1ee00001000ull, { 21, 22, 57, 25, 0 }, 0x0, 464, }, + { 27, 1, 2, 0x1ac00000000ull, 0x1ee00001000ull, { 22, 21, 57, 25, 0 }, 0x0, 425, }, + { 27, 1, 2, 0x1ac00000000ull, 0x1ee00001000ull, { 22, 21, 55, 25, 0 }, 0x0, 415, }, + { 27, 1, 2, 0x1c600000000ull, 0x1fe00001000ull, { 22, 21, 24, 25, 0 }, 0x40, 318, }, + { 27, 1, 2, 0x1d400000000ull, 0x1fe00001000ull, { 22, 21, 6, 25, 0 }, 0x40, 410, }, + { 27, 1, 2, 0x1ce00000000ull, 0x1ee00001000ull, { 22, 21, 54, 25, 0 }, 0x40, 318, }, + { 28, 3, 1, 0x8008000000ull, 0x1fff8000000ull, { 23, 32, 24, 1, 0 }, 0x0, 81, }, + { 29, 3, 1, 0x8048000000ull, 0x1fff8000000ull, { 23, 32, 24, 1, 0 }, 0x0, 81, }, + { 30, 3, 1, 0x8088000000ull, 0x1fff8000000ull, { 23, 32, 24, 1, 0 }, 0x0, 81, }, + { 31, 3, 1, 0x80c8000000ull, 0x1fff8000000ull, { 23, 32, 24, 1, 0 }, 0x0, 81, }, + { 33, 4, 0, 0x10000000ull, 0x1e1f8000000ull, { 0, 0, 0, 0, 0 }, 0x224, 7, }, + { 35, 2, 1, 0xc0000000ull, 0x1eff8000000ull, { 23, 25, 0, 0, 0 }, 0x0, 446, }, + { 36, 2, 1, 0xc8000000ull, 0x1eff8000000ull, { 23, 25, 0, 0, 0 }, 0x0, 446, }, + { 39, 2, 1, 0x8000000000ull, 0x1e000000000ull, { 23, 24, 25, 46, 71 }, 0x0, 8, }, + { 39, 2, 1, 0xa600000000ull, 0x1ee04000000ull, { 23, 24, 44, 72, 0 }, 0x0, 1035, }, + { 39, 2, 1, 0xa604000000ull, 0x1ee04000000ull, { 23, 54, 44, 72, 0 }, 0x0, 1035, }, + { 39, 2, 1, 0xae00000000ull, 0x1ee00000000ull, { 23, 47, 25, 45, 72 }, 0x0, 8, }, + { 43, 4, 0, 0x80000000ull, 0x1e1f8000000ull, { 0, 0, 0, 0, 0 }, 0x20, 9, }, + { 48, 2, 1, 0xa400000000ull, 0x1ee00002000ull, { 23, 25, 75, 72, 0 }, 0x0, 10, }, + { 50, 5, 1, 0x80000000ull, 0x1e3f80fe000ull, { 17, 19, 0, 0, 0 }, 0x40, 11, }, + { 51, 5, 1, 0x10008000000ull, 0x1fff8000000ull, { 17, 19, 18, 0, 0 }, 0x40, 12, }, + { 52, 5, 1, 0xb8000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 756, }, + { 52, 5, 1, 0xb8000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x40, 13, }, + { 53, 5, 1, 0xb0000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 756, }, + { 53, 5, 1, 0xb0000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x40, 13, }, + { 54, 5, 1, 0x160000000ull, 0x1e3f8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 11, }, + { 55, 5, 1, 0x168000000ull, 0x1e3f8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 11, }, + { 57, 3, 0, 0x2180000000ull, 0x1eff8000000ull, { 25, 0, 0, 0, 0 }, 0x0, 14, }, + { 58, 5, 0, 0x40000000ull, 0x1eff8000000ull, { 78, 0, 0, 0, 0 }, 0x0, 758, }, + { 58, 5, 0, 0x40000000ull, 0x1eff8000000ull, { 78, 0, 0, 0, 0 }, 0x40, 15, }, + { 59, 5, 2, 0xa000000000ull, 0x1e000001000ull, { 21, 22, 18, 59, 0 }, 0x0, 483, }, + { 59, 5, 2, 0xa000000000ull, 0x1e000001000ull, { 22, 21, 18, 59, 0 }, 0x40, 562, }, + { 60, 5, 0, 0x28000000ull, 0x1eff8000000ull, { 0, 0, 0, 0, 0 }, 0x0, 759, }, + { 60, 5, 0, 0x28000000ull, 0x1eff8000000ull, { 0, 0, 0, 0, 0 }, 0x40, 16, }, + { 61, 5, 2, 0x8000000000ull, 0x1fe00001000ull, { 21, 22, 18, 19, 0 }, 0x0, 320, }, + { 61, 5, 2, 0x8000000000ull, 0x1fe00001000ull, { 21, 22, 18, 19, 0 }, 0x40, 321, }, + { 61, 5, 2, 0x9000000000ull, 0x1fe00001000ull, { 21, 22, 19, 18, 0 }, 0x0, 412, }, + { 61, 5, 2, 0x9000000000ull, 0x1fe00001000ull, { 21, 22, 19, 18, 0 }, 0x40, 413, }, + { 61, 5, 2, 0x8000000000ull, 0x1fe00001000ull, { 22, 21, 18, 19, 0 }, 0x0, 545, }, + { 61, 5, 2, 0x8000000000ull, 0x1fe00001000ull, { 22, 21, 18, 19, 0 }, 0x40, 546, }, + { 61, 5, 2, 0x9000000000ull, 0x1fe00001000ull, { 22, 21, 19, 18, 0 }, 0x0, 549, }, + { 61, 5, 2, 0x9000000000ull, 0x1fe00001000ull, { 22, 21, 19, 18, 0 }, 0x40, 550, }, + { 62, 5, 1, 0xc0000000ull, 0x1eff8000000ull, { 17, 18, 0, 0, 0 }, 0x0, 401, }, + { 62, 5, 1, 0xc0000000ull, 0x1eff8000000ull, { 17, 18, 0, 0, 0 }, 0x40, 402, }, + { 62, 5, 1, 0xe0000000ull, 0x1e3f8000000ull, { 17, 18, 0, 0, 0 }, 0x0, 1033, }, + { 62, 5, 1, 0x10008000000ull, 0x1fff80fe000ull, { 17, 19, 0, 0, 0 }, 0x40, 1034, }, + { 63, 3, 1, 0x8488000000ull, 0x1fff8000000ull, { 23, 32, 70, 0, 0 }, 0x0, 82, }, + { 64, 3, 1, 0x84c8000000ull, 0x1fff8000000ull, { 23, 32, 70, 0, 0 }, 0x0, 82, }, + { 67, 3, 0, 0x60000000ull, 0x1eff8000000ull, { 0, 0, 0, 0, 0 }, 0x21, 17, }, + { 68, 5, 1, 0x10000000000ull, 0x1fc00000000ull, { 17, 19, 20, 18, 0 }, 0x0, 142, }, + { 68, 5, 1, 0x10000000000ull, 0x1fc00000000ull, { 17, 19, 20, 18, 0 }, 0x40, 18, }, + { 69, 5, 1, 0xa8000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 756, }, + { 69, 5, 1, 0xa8000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x40, 13, }, + { 70, 5, 1, 0x80000000ull, 0x1e3f8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 564, }, + { 71, 5, 1, 0xa0000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 756, }, + { 71, 5, 1, 0xa0000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x40, 13, }, + { 72, 5, 1, 0x1c8000000ull, 0x1e3f8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 447, }, + { 73, 5, 1, 0x10000000000ull, 0x1fc000fe000ull, { 17, 19, 20, 0, 0 }, 0x40, 12, }, + { 74, 5, 1, 0x14000000000ull, 0x1fc00000000ull, { 17, 19, 20, 18, 0 }, 0x0, 144, }, + { 74, 5, 1, 0x14000000000ull, 0x1fc00000000ull, { 17, 19, 20, 18, 0 }, 0x40, 19, }, + { 75, 5, 1, 0x88000000ull, 0x1e3f8000000ull, { 17, 19, 0, 0, 0 }, 0xc0, 11, }, + { 76, 5, 1, 0x88000000ull, 0x1e3f80fe000ull, { 17, 19, 0, 0, 0 }, 0x40, 11, }, + { 77, 5, 1, 0x18000000000ull, 0x1fc00000000ull, { 17, 19, 20, 18, 0 }, 0x0, 144, }, + { 77, 5, 1, 0x18000000000ull, 0x1fc00000000ull, { 17, 19, 20, 18, 0 }, 0x40, 19, }, + { 78, 5, 1, 0x18000000000ull, 0x1fc000fe000ull, { 17, 19, 20, 0, 0 }, 0x40, 12, }, + { 79, 5, 1, 0x10008000000ull, 0x1fff80fe000ull, { 17, 19, 0, 0, 0 }, 0x40, 12, }, + { 80, 5, 1, 0x170000000ull, 0x1e3f8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 11, }, + { 81, 5, 1, 0x2080000000ull, 0x1e3f80fe000ull, { 17, 19, 0, 0, 0 }, 0x40, 11, }, + { 82, 5, 1, 0x140000000ull, 0x1e3f8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 11, }, + { 83, 5, 1, 0x20b8000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 756, }, + { 83, 5, 1, 0x20b8000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x40, 13, }, + { 84, 5, 1, 0x20b0000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 756, }, + { 84, 5, 1, 0x20b0000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x40, 13, }, + { 85, 5, 1, 0x2180000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 322, }, + { 85, 5, 1, 0x2180000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x40, 323, }, + { 86, 5, 1, 0x20c0000000ull, 0x1eff8000000ull, { 17, 18, 0, 0, 0 }, 0x0, 401, }, + { 86, 5, 1, 0x20c0000000ull, 0x1eff8000000ull, { 17, 18, 0, 0, 0 }, 0x40, 402, }, + { 87, 5, 1, 0x13000000000ull, 0x1fc00000000ull, { 17, 19, 20, 18, 0 }, 0x0, 756, }, + { 87, 5, 1, 0x13000000000ull, 0x1fc00000000ull, { 17, 19, 20, 18, 0 }, 0x40, 13, }, + { 88, 5, 1, 0x20a8000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 756, }, + { 88, 5, 1, 0x20a8000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x40, 13, }, + { 89, 5, 1, 0x2080000000ull, 0x1e3f8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 564, }, + { 90, 5, 1, 0x20a0000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 756, }, + { 90, 5, 1, 0x20a0000000ull, 0x1eff8000000ull, { 17, 18, 19, 0, 0 }, 0x40, 13, }, + { 91, 5, 1, 0x13000000000ull, 0x1fc000fe000ull, { 17, 19, 20, 0, 0 }, 0x40, 20, }, + { 92, 5, 1, 0x17000000000ull, 0x1fc00000000ull, { 17, 19, 20, 18, 0 }, 0x0, 756, }, + { 92, 5, 1, 0x17000000000ull, 0x1fc00000000ull, { 17, 19, 20, 18, 0 }, 0x40, 13, }, + { 93, 5, 1, 0x2088000000ull, 0x1e3f8000000ull, { 17, 19, 0, 0, 0 }, 0xc0, 11, }, + { 94, 5, 1, 0x2088000000ull, 0x1e3f80fe000ull, { 17, 19, 0, 0, 0 }, 0x40, 11, }, + { 95, 5, 1, 0x1b000000000ull, 0x1fc00000000ull, { 17, 19, 20, 18, 0 }, 0x0, 756, }, + { 95, 5, 1, 0x1b000000000ull, 0x1fc00000000ull, { 17, 19, 20, 18, 0 }, 0x40, 13, }, + { 96, 5, 1, 0x1b000000000ull, 0x1fc000fe000ull, { 17, 19, 20, 0, 0 }, 0x40, 20, }, + { 97, 5, 2, 0x2200000000ull, 0x1fe00000000ull, { 17, 22, 18, 19, 0 }, 0x0, 785, }, + { 97, 5, 2, 0x2200000000ull, 0x1fe00000000ull, { 17, 22, 18, 19, 0 }, 0x40, 21, }, + { 98, 5, 2, 0x3200000000ull, 0x1fe00000000ull, { 17, 22, 19, 0, 0 }, 0x0, 785, }, + { 98, 5, 2, 0x3200000000ull, 0x1fe00000000ull, { 17, 22, 19, 0, 0 }, 0x40, 21, }, + { 99, 5, 2, 0x200000000ull, 0x1fe00000000ull, { 17, 22, 18, 19, 0 }, 0x0, 785, }, + { 99, 5, 2, 0x200000000ull, 0x1fe00000000ull, { 17, 22, 18, 19, 0 }, 0x40, 21, }, + { 100, 5, 2, 0x1200000000ull, 0x1fe00000000ull, { 17, 22, 19, 0, 0 }, 0x0, 785, }, + { 100, 5, 2, 0x1200000000ull, 0x1fe00000000ull, { 17, 22, 19, 0, 0 }, 0x40, 21, }, + { 101, 5, 1, 0x1c000000000ull, 0x1f000000000ull, { 17, 19, 20, 18, 0 }, 0x0, 11, }, + { 102, 5, 0, 0x20000000ull, 0x1eff8000000ull, { 49, 50, 0, 0, 0 }, 0x0, 786, }, + { 102, 5, 0, 0x20000000ull, 0x1eff8000000ull, { 49, 50, 0, 0, 0 }, 0x40, 22, }, + { 103, 5, 1, 0x14008000000ull, 0x1fff8000000ull, { 17, 19, 18, 0, 0 }, 0x40, 12, }, + { 104, 5, 1, 0x1a0000000ull, 0x1e3f8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 23, }, + { 105, 5, 1, 0x1e0000000ull, 0x1e3f8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 448, }, + { 106, 3, 0, 0x100000000ull, 0x1eff8000000ull, { 0, 0, 0, 0, 0 }, 0x0, 16, }, + { 108, 5, 1, 0x178000000ull, 0x1e3f8000000ull, { 17, 18, 19, 0, 0 }, 0x0, 11, }, + { 113, 3, 1, 0x8708000000ull, 0x1ffc8000000ull, { 23, 18, 0, 0, 0 }, 0x0, 146, }, + { 122, 3, 0, 0x80000000ull, 0x1eff8000000ull, { 0, 0, 0, 0, 0 }, 0x0, 24, }, + { 122, 3, 0, 0x90000000ull, 0x1eff8000000ull, { 23, 0, 0, 0, 0 }, 0x0, 314, }, + { 122, 3, 0, 0x98000000ull, 0x1eff8000000ull, { 17, 0, 0, 0, 0 }, 0x0, 314, }, + { 123, 3, 0, 0x2170000000ull, 0x1eff8000000ull, { 24, 0, 0, 0, 0 }, 0xc, 147, }, + { 124, 3, 1, 0x2070000000ull, 0x1eff8000000ull, { 29, 24, 0, 0, 0 }, 0x8, 148, }, + { 124, 3, 1, 0x2078000000ull, 0x1eff8000000ull, { 30, 24, 0, 0, 0 }, 0x8, 434, }, + { 126, 3, 1, 0x8000000000ull, 0x1fff8000000ull, { 23, 32, 0, 0, 0 }, 0x0, 25, }, + { 126, 3, 1, 0x9000000000ull, 0x1fff8000000ull, { 23, 32, 24, 0, 0 }, 0x0, 25, }, + { 126, 3, 1, 0xa000000000ull, 0x1eff0000000ull, { 23, 32, 61, 0, 0 }, 0x0, 25, }, + { 127, 3, 1, 0x8040000000ull, 0x1fff8000000ull, { 23, 32, 0, 0, 0 }, 0x0, 25, }, + { 127, 3, 1, 0x9040000000ull, 0x1fff8000000ull, { 23, 32, 24, 0, 0 }, 0x0, 25, }, + { 127, 3, 1, 0xa040000000ull, 0x1eff0000000ull, { 23, 32, 61, 0, 0 }, 0x0, 25, }, + { 128, 3, 1, 0x8080000000ull, 0x1fff8000000ull, { 23, 32, 0, 0, 0 }, 0x0, 25, }, + { 128, 3, 1, 0x9080000000ull, 0x1fff8000000ull, { 23, 32, 24, 0, 0 }, 0x0, 25, }, + { 128, 3, 1, 0xa080000000ull, 0x1eff0000000ull, { 23, 32, 61, 0, 0 }, 0x0, 25, }, + { 129, 3, 1, 0x80c0000000ull, 0x1fff8000000ull, { 23, 32, 0, 0, 0 }, 0x0, 26, }, + { 129, 3, 1, 0x90c0000000ull, 0x1fff8000000ull, { 23, 32, 24, 0, 0 }, 0x0, 26, }, + { 129, 3, 1, 0xa0c0000000ull, 0x1eff0000000ull, { 23, 32, 61, 0, 0 }, 0x0, 26, }, + { 130, 3, 1, 0xc6c0000000ull, 0x1fff8000000ull, { 17, 32, 0, 0, 0 }, 0x0, 400, }, + { 130, 3, 1, 0xd6c0000000ull, 0x1fff8000000ull, { 17, 32, 24, 0, 0 }, 0x0, 400, }, + { 130, 3, 1, 0xe6c0000000ull, 0x1eff0000000ull, { 17, 32, 61, 0, 0 }, 0x0, 400, }, + { 131, 3, 1, 0xc040000000ull, 0x1fff8000000ull, { 17, 32, 0, 0, 0 }, 0x0, 27, }, + { 131, 3, 1, 0xd040000000ull, 0x1fff8000000ull, { 17, 32, 24, 0, 0 }, 0x0, 27, }, + { 131, 3, 1, 0xe040000000ull, 0x1eff0000000ull, { 17, 32, 61, 0, 0 }, 0x0, 27, }, + { 132, 3, 1, 0xc0c0000000ull, 0x1fff8000000ull, { 17, 32, 0, 0, 0 }, 0x0, 27, }, + { 132, 3, 1, 0xd0c0000000ull, 0x1fff8000000ull, { 17, 32, 24, 0, 0 }, 0x0, 27, }, + { 132, 3, 1, 0xe0c0000000ull, 0x1eff0000000ull, { 17, 32, 61, 0, 0 }, 0x0, 27, }, + { 133, 3, 1, 0xc000000000ull, 0x1fff8000000ull, { 17, 32, 0, 0, 0 }, 0x0, 27, }, + { 133, 3, 1, 0xd000000000ull, 0x1fff8000000ull, { 17, 32, 24, 0, 0 }, 0x0, 27, }, + { 133, 3, 1, 0xe000000000ull, 0x1eff0000000ull, { 17, 32, 61, 0, 0 }, 0x0, 27, }, + { 134, 3, 2, 0xc048000000ull, 0x1fff8000000ull, { 17, 18, 32, 0, 0 }, 0x0, 27, }, + { 134, 3, 2, 0xd048000000ull, 0x1fff8000000ull, { 17, 18, 32, 5, 0 }, 0x0, 27, }, + { 135, 3, 2, 0xc0c8000000ull, 0x1fff8000000ull, { 17, 18, 32, 0, 0 }, 0x0, 27, }, + { 135, 3, 2, 0xd0c8000000ull, 0x1fff8000000ull, { 17, 18, 32, 5, 0 }, 0x0, 27, }, + { 136, 3, 2, 0xc088000000ull, 0x1fff8000000ull, { 17, 18, 32, 0, 0 }, 0x0, 27, }, + { 136, 3, 2, 0xd088000000ull, 0x1fff8000000ull, { 17, 18, 32, 4, 0 }, 0x0, 27, }, + { 137, 3, 1, 0xc080000000ull, 0x1fff8000000ull, { 17, 32, 0, 0, 0 }, 0x0, 27, }, + { 137, 3, 1, 0xd080000000ull, 0x1fff8000000ull, { 17, 32, 24, 0, 0 }, 0x0, 27, }, + { 137, 3, 1, 0xe080000000ull, 0x1eff0000000ull, { 17, 32, 61, 0, 0 }, 0x0, 27, }, + { 140, 3, 0, 0xcb00000000ull, 0x1fff8000000ull, { 32, 0, 0, 0, 0 }, 0x0, 28, }, + { 140, 3, 0, 0xdb00000000ull, 0x1fff8000000ull, { 32, 24, 0, 0, 0 }, 0x0, 29, }, + { 140, 3, 0, 0xeb00000000ull, 0x1eff0000000ull, { 32, 61, 0, 0, 0 }, 0x0, 29, }, + { 141, 3, 0, 0x50000000ull, 0x1eff8000000ull, { 0, 0, 0, 0, 0 }, 0x21, 30, }, + { 149, 3, 0, 0x110000000ull, 0x1eff8000000ull, { 0, 0, 0, 0, 0 }, 0x0, 31, }, + { 150, 2, 1, 0xe880000000ull, 0x1fff0000000ull, { 23, 24, 25, 0, 0 }, 0x0, 449, }, + { 151, 2, 1, 0xea80000000ull, 0x1fff0000000ull, { 23, 24, 25, 0, 0 }, 0x0, 449, }, + { 152, 2, 1, 0xf880000000ull, 0x1fff0000000ull, { 23, 24, 25, 0, 0 }, 0x0, 449, }, + { 153, 1, 1, 0x10800000000ull, 0x1fff80fe000ull, { 23, 25, 0, 0, 0 }, 0x0, 1, }, + { 153, 1, 1, 0x10800000000ull, 0x1ee07f00000ull, { 23, 62, 0, 0, 0 }, 0x40, 1, }, + { 153, 1, 1, 0x12000000000ull, 0x1e000300000ull, { 23, 65, 0, 0, 0 }, 0x40, 32, }, + { 153, 5, 1, 0x80000000ull, 0x1e3f8000000ull, { 17, 19, 0, 0, 0 }, 0xc0, 11, }, + { 153, 2, 1, 0xe00100000ull, 0x1ee00f01e00ull, { 14, 24, 0, 0, 0 }, 0x40, 33, }, + { 153, 2, 1, 0xe00000000ull, 0x1ee00f01e00ull, { 14, 24, 77, 0, 0 }, 0x0, 313, }, + { 153, 2, 1, 0x188000000ull, 0x1eff8000000ull, { 23, 15, 0, 0, 0 }, 0x0, 34, }, + { 153, 2, 1, 0x600000000ull, 0x1ee00000000ull, { 8, 24, 63, 0, 0 }, 0x0, 35, }, + { 153, 2, 1, 0x400000000ull, 0x1ee00000000ull, { 9, 67, 0, 0, 0 }, 0x0, 36, }, + { 153, 2, 1, 0x180000000ull, 0x1eff8000000ull, { 23, 7, 0, 0, 0 }, 0x0, 8, }, + { 153, 2, 1, 0x198000000ull, 0x1eff8000000ull, { 23, 8, 0, 0, 0 }, 0x0, 37, }, + { 153, 2, 1, 0x150000000ull, 0x1eff8000000ull, { 13, 24, 0, 0, 0 }, 0x0, 435, }, + { 153, 2, 1, 0x50000000ull, 0x1eff8000000ull, { 13, 54, 0, 0, 0 }, 0x0, 435, }, + { 153, 2, 1, 0x190000000ull, 0x1eff8000000ull, { 23, 13, 0, 0, 0 }, 0x0, 436, }, + { 153, 3, 1, 0x140000000ull, 0x1eff8000000ull, { 13, 54, 0, 0, 0 }, 0x0, 484, }, + { 153, 3, 1, 0x2150000000ull, 0x1eff8000000ull, { 13, 24, 0, 0, 0 }, 0x0, 484, }, + { 153, 3, 1, 0x2110000000ull, 0x1eff8000000ull, { 23, 13, 0, 0, 0 }, 0x0, 485, }, + { 153, 3, 1, 0x2160000000ull, 0x1eff8000000ull, { 16, 24, 0, 0, 0 }, 0x8, 38, }, + { 153, 3, 1, 0x2120000000ull, 0x1eff8000000ull, { 23, 16, 0, 0, 0 }, 0x8, 39, }, + { 153, 3, 1, 0x2168000000ull, 0x1eff8000000ull, { 11, 24, 0, 0, 0 }, 0x8, 40, }, + { 153, 3, 1, 0x2148000000ull, 0x1eff8000000ull, { 12, 24, 0, 0, 0 }, 0x0, 41, }, + { 153, 3, 1, 0x2128000000ull, 0x1eff8000000ull, { 23, 10, 0, 0, 0 }, 0x8, 42, }, + { 153, 3, 1, 0x2108000000ull, 0x1eff8000000ull, { 23, 12, 0, 0, 0 }, 0x0, 43, }, + { 153, 3, 1, 0x2000000000ull, 0x1eff8000000ull, { 37, 24, 0, 0, 0 }, 0x8, 44, }, + { 153, 3, 1, 0x2008000000ull, 0x1eff8000000ull, { 28, 24, 0, 0, 0 }, 0x8, 45, }, + { 153, 3, 1, 0x2010000000ull, 0x1eff8000000ull, { 31, 24, 0, 0, 0 }, 0x8, 46, }, + { 153, 3, 1, 0x2018000000ull, 0x1eff8000000ull, { 34, 24, 0, 0, 0 }, 0x8, 47, }, + { 153, 3, 1, 0x2020000000ull, 0x1eff8000000ull, { 35, 24, 0, 0, 0 }, 0x8, 48, }, + { 153, 3, 1, 0x2028000000ull, 0x1eff8000000ull, { 36, 24, 0, 0, 0 }, 0x8, 49, }, + { 153, 3, 1, 0x2030000000ull, 0x1eff8000000ull, { 33, 24, 0, 0, 0 }, 0x8, 50, }, + { 153, 3, 1, 0x2080000000ull, 0x1eff8000000ull, { 23, 37, 0, 0, 0 }, 0x8, 51, }, + { 153, 3, 1, 0x2088000000ull, 0x1eff8000000ull, { 23, 28, 0, 0, 0 }, 0x8, 52, }, + { 153, 3, 1, 0x2090000000ull, 0x1eff8000000ull, { 23, 31, 0, 0, 0 }, 0x8, 53, }, + { 153, 3, 1, 0x2098000000ull, 0x1eff8000000ull, { 23, 34, 0, 0, 0 }, 0x8, 54, }, + { 153, 3, 1, 0x20a0000000ull, 0x1eff8000000ull, { 23, 35, 0, 0, 0 }, 0x8, 55, }, + { 153, 3, 1, 0x20a8000000ull, 0x1eff8000000ull, { 23, 36, 0, 0, 0 }, 0x0, 56, }, + { 153, 3, 1, 0x20b0000000ull, 0x1eff8000000ull, { 23, 33, 0, 0, 0 }, 0x8, 57, }, + { 153, 3, 1, 0x20b8000000ull, 0x1eff8000000ull, { 23, 27, 0, 0, 0 }, 0x0, 58, }, + { 153, 7, 1, 0x0ull, 0x0ull, { 23, 13, 0, 0, 0 }, 0x0, 59, }, + { 153, 7, 1, 0x0ull, 0x0ull, { 13, 54, 0, 0, 0 }, 0x0, 59, }, + { 153, 7, 1, 0x0ull, 0x0ull, { 13, 24, 0, 0, 0 }, 0x0, 59, }, + { 154, 6, 1, 0xc000000000ull, 0x1e000100000ull, { 23, 69, 0, 0, 0 }, 0x0, 8, }, + { 155, 2, 1, 0xeca0000000ull, 0x1fff0000000ull, { 23, 24, 73, 0, 0 }, 0x0, 0, }, + { 156, 2, 1, 0xeea0000000ull, 0x1fff0000000ull, { 23, 24, 74, 0, 0 }, 0x0, 0, }, + { 166, 4, 0, 0x4000000000ull, 0x1e1f8000000ull, { 64, 0, 0, 0, 0 }, 0x0, 107, }, + { 166, 5, 0, 0x8000000ull, 0x1e3f8000000ull, { 64, 0, 0, 0, 0 }, 0x0, 333, }, + { 166, 2, 0, 0x8000000ull, 0x1eff8000000ull, { 64, 0, 0, 0, 0 }, 0x2, 431, }, + { 166, 3, 0, 0x8000000ull, 0x1eff8000000ull, { 64, 0, 0, 0, 0 }, 0x0, 481, }, + { 166, 6, 0, 0x8000000ull, 0x1eff8000000ull, { 68, 0, 0, 0, 0 }, 0x0, 1032, }, + { 166, 7, 0, 0x0ull, 0x0ull, { 64, 0, 0, 0, 0 }, 0x0, 5, }, + { 174, 1, 1, 0x10070000000ull, 0x1eff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 0, }, + { 174, 1, 1, 0x10170000000ull, 0x1eff8000000ull, { 23, 54, 25, 0, 0 }, 0x0, 0, }, + { 177, 2, 1, 0xea00000000ull, 0x1fff0000000ull, { 23, 24, 25, 0, 0 }, 0x0, 936, }, + { 178, 2, 1, 0xf820000000ull, 0x1fff0000000ull, { 23, 24, 25, 0, 0 }, 0x0, 937, }, + { 179, 1, 1, 0x10400000000ull, 0x1fff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 60, }, + { 180, 1, 1, 0x10600000000ull, 0x1fff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 60, }, + { 181, 1, 1, 0x11400000000ull, 0x1fff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 0, }, + { 182, 1, 1, 0x10450000000ull, 0x1fff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 61, }, + { 183, 1, 1, 0x10650000000ull, 0x1fff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 61, }, + { 184, 1, 1, 0x10470000000ull, 0x1fff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 0, }, + { 185, 1, 1, 0x10670000000ull, 0x1fff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 0, }, + { 186, 1, 1, 0x10520000000ull, 0x1fff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 324, }, + { 187, 1, 1, 0x10720000000ull, 0x1fff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 324, }, + { 188, 1, 1, 0x11520000000ull, 0x1fff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 324, }, + { 189, 2, 1, 0xe850000000ull, 0x1fff0000000ull, { 23, 24, 25, 0, 0 }, 0x0, 1008, }, + { 190, 2, 1, 0xea70000000ull, 0x1fff0000000ull, { 23, 24, 25, 0, 0 }, 0x0, 0, }, + { 191, 2, 1, 0xe810000000ull, 0x1fff0000000ull, { 23, 24, 25, 0, 0 }, 0x0, 1008, }, + { 192, 2, 1, 0xea30000000ull, 0x1fff0000000ull, { 23, 24, 25, 0, 0 }, 0x0, 0, }, + { 193, 2, 1, 0xead0000000ull, 0x1fff0000000ull, { 23, 24, 25, 0, 0 }, 0x0, 449, }, + { 194, 2, 1, 0xe230000000ull, 0x1ff30000000ull, { 23, 24, 25, 41, 0 }, 0x0, 62, }, + { 195, 2, 1, 0xe690000000ull, 0x1fff0000000ull, { 23, 25, 0, 0, 0 }, 0x0, 0, }, + { 197, 3, 1, 0x21c0000000ull, 0x1eff8000000ull, { 23, 25, 24, 0, 0 }, 0x0, 729, }, + { 197, 3, 1, 0x20c0000000ull, 0x1eff8000000ull, { 23, 25, 48, 0, 0 }, 0x0, 729, }, + { 197, 3, 0, 0x2188000000ull, 0x1eff8000000ull, { 25, 48, 0, 0, 0 }, 0x0, 730, }, + { 198, 2, 1, 0xe8b0000000ull, 0x1fff0000000ull, { 23, 24, 25, 0, 0 }, 0x0, 0, }, + { 199, 2, 1, 0xe240000000ull, 0x1fff0000000ull, { 23, 24, 25, 0, 0 }, 0x0, 0, }, + { 199, 2, 1, 0xee50000000ull, 0x1fff0000000ull, { 23, 24, 38, 0, 0 }, 0x0, 0, }, + { 200, 2, 1, 0xf040000000ull, 0x1fff0000000ull, { 23, 24, 25, 0, 0 }, 0x0, 0, }, + { 200, 2, 1, 0xfc50000000ull, 0x1fff0000000ull, { 23, 24, 38, 0, 0 }, 0x0, 0, }, + { 201, 1, 1, 0x10680000000ull, 0x1ffe0000000ull, { 23, 24, 40, 25, 0 }, 0x0, 0, }, + { 202, 2, 1, 0xe220000000ull, 0x1fff0000000ull, { 23, 25, 24, 0, 0 }, 0x0, 62, }, + { 202, 2, 1, 0xe630000000ull, 0x1fff0000000ull, { 23, 25, 42, 0, 0 }, 0x0, 62, }, + { 203, 2, 1, 0xf020000000ull, 0x1fff0000000ull, { 23, 25, 24, 0, 0 }, 0x0, 62, }, + { 203, 2, 1, 0xf430000000ull, 0x1fff0000000ull, { 23, 25, 42, 0, 0 }, 0x0, 62, }, + { 204, 1, 1, 0x106c0000000ull, 0x1ffe0000000ull, { 23, 24, 40, 25, 0 }, 0x0, 0, }, + { 205, 1, 1, 0x10420000000ull, 0x1fff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 60, }, + { 206, 1, 1, 0x10620000000ull, 0x1fff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 60, }, + { 207, 1, 1, 0x11420000000ull, 0x1fff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 0, }, + { 208, 3, 0, 0x2048000000ull, 0x1eff8000000ull, { 25, 24, 0, 0, 0 }, 0x8, 450, }, + { 208, 3, 0, 0x2050000000ull, 0x1eff8000000ull, { 25, 24, 0, 0, 0 }, 0xc, 405, }, + { 208, 3, 0, 0x21a0000000ull, 0x1eff8000000ull, { 25, 0, 0, 0, 0 }, 0x8, 315, }, + { 209, 3, 0, 0x2060000000ull, 0x1eff8000000ull, { 25, 24, 0, 0, 0 }, 0x8, 149, }, + { 214, 4, 0, 0x40000000ull, 0x1e1f8000000ull, { 0, 0, 0, 0, 0 }, 0x22c, 63, }, + { 215, 3, 0, 0x38000000ull, 0x1ee78000000ull, { 66, 0, 0, 0, 0 }, 0x8, 64, }, + { 216, 3, 0, 0x28000000ull, 0x1ee78000000ull, { 66, 0, 0, 0, 0 }, 0x0, 65, }, + { 225, 3, 1, 0xc708000000ull, 0x1ffc8000000ull, { 17, 24, 0, 0, 0 }, 0x0, 150, }, + { 226, 2, 1, 0xa600000000ull, 0x1ee04000000ull, { 23, 24, 44, 0, 0 }, 0x140, 0, }, + { 226, 2, 1, 0xf240000000ull, 0x1fff0000000ull, { 23, 24, 25, 0, 0 }, 0x0, 0, }, + { 227, 1, 1, 0x10080000000ull, 0x1efe0000000ull, { 23, 24, 39, 25, 0 }, 0x0, 0, }, + { 228, 1, 1, 0x100c0000000ull, 0x1efe0000000ull, { 23, 24, 39, 25, 0 }, 0x0, 0, }, + { 229, 2, 1, 0xa400000000ull, 0x1ee00002000ull, { 23, 25, 75, 0, 0 }, 0x140, 10, }, + { 229, 2, 1, 0xf220000000ull, 0x1fff0000000ull, { 23, 25, 24, 0, 0 }, 0x0, 62, }, + { 230, 2, 1, 0xac00000000ull, 0x1ee00000000ull, { 23, 24, 25, 43, 0 }, 0x0, 0, }, + { 235, 3, 0, 0x180000000ull, 0x1eff8000000ull, { 0, 0, 0, 0, 0 }, 0x0, 151, }, + { 236, 3, 0, 0x30000000ull, 0x1ee78000000ull, { 66, 0, 0, 0, 0 }, 0x8, 64, }, + { 238, 3, 1, 0x8c00000000ull, 0x1fff8000000ull, { 32, 24, 0, 0, 0 }, 0x0, 66, }, + { 238, 3, 1, 0xac00000000ull, 0x1eff0000000ull, { 32, 24, 60, 0, 0 }, 0x0, 66, }, + { 239, 3, 1, 0x8c40000000ull, 0x1fff8000000ull, { 32, 24, 0, 0, 0 }, 0x0, 66, }, + { 239, 3, 1, 0xac40000000ull, 0x1eff0000000ull, { 32, 24, 60, 0, 0 }, 0x0, 66, }, + { 240, 3, 1, 0x8c80000000ull, 0x1fff8000000ull, { 32, 24, 0, 0, 0 }, 0x0, 66, }, + { 240, 3, 1, 0xac80000000ull, 0x1eff0000000ull, { 32, 24, 60, 0, 0 }, 0x0, 66, }, + { 241, 3, 1, 0x8cc0000000ull, 0x1fff8000000ull, { 32, 24, 0, 0, 0 }, 0x0, 67, }, + { 241, 3, 1, 0xacc0000000ull, 0x1eff0000000ull, { 32, 24, 60, 0, 0 }, 0x0, 67, }, + { 242, 3, 1, 0xcec0000000ull, 0x1fff8000000ull, { 32, 18, 0, 0, 0 }, 0x0, 883, }, + { 242, 3, 1, 0xeec0000000ull, 0x1eff0000000ull, { 32, 18, 60, 0, 0 }, 0x0, 883, }, + { 243, 3, 1, 0xcc40000000ull, 0x1fff8000000ull, { 32, 18, 0, 0, 0 }, 0x0, 68, }, + { 243, 3, 1, 0xec40000000ull, 0x1eff0000000ull, { 32, 18, 60, 0, 0 }, 0x0, 68, }, + { 244, 3, 1, 0xccc0000000ull, 0x1fff8000000ull, { 32, 18, 0, 0, 0 }, 0x0, 68, }, + { 244, 3, 1, 0xecc0000000ull, 0x1eff0000000ull, { 32, 18, 60, 0, 0 }, 0x0, 68, }, + { 245, 3, 1, 0xcc00000000ull, 0x1fff8000000ull, { 32, 18, 0, 0, 0 }, 0x0, 68, }, + { 245, 3, 1, 0xec00000000ull, 0x1eff0000000ull, { 32, 18, 60, 0, 0 }, 0x0, 68, }, + { 246, 3, 1, 0xcc80000000ull, 0x1fff8000000ull, { 32, 18, 0, 0, 0 }, 0x0, 68, }, + { 246, 3, 1, 0xec80000000ull, 0x1eff0000000ull, { 32, 18, 60, 0, 0 }, 0x0, 68, }, + { 247, 1, 1, 0x10028000000ull, 0x1eff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 0, }, + { 247, 1, 1, 0x10020000000ull, 0x1eff8000000ull, { 23, 24, 25, 3, 0 }, 0x0, 0, }, + { 247, 1, 1, 0x10128000000ull, 0x1eff8000000ull, { 23, 54, 25, 0, 0 }, 0x0, 0, }, + { 248, 3, 0, 0x20000000ull, 0x1ee78000000ull, { 66, 0, 0, 0, 0 }, 0x0, 69, }, + { 249, 2, 1, 0xa0000000ull, 0x1eff8000000ull, { 23, 25, 0, 0, 0 }, 0x0, 0, }, + { 250, 2, 1, 0xa8000000ull, 0x1eff8000000ull, { 23, 25, 0, 0, 0 }, 0x0, 0, }, + { 251, 2, 1, 0xb0000000ull, 0x1eff8000000ull, { 23, 25, 0, 0, 0 }, 0x0, 0, }, + { 252, 3, 0, 0x198000000ull, 0x1eff8000000ull, { 0, 0, 0, 0, 0 }, 0x0, 431, }, + { 253, 3, 1, 0x20f8000000ull, 0x1eff8000000ull, { 23, 25, 0, 0, 0 }, 0x8, 70, }, + { 254, 2, 2, 0xa000000000ull, 0x1fe00003000ull, { 21, 22, 25, 75, 0 }, 0x0, 699, }, + { 254, 2, 2, 0xa000000000ull, 0x1fe00003000ull, { 22, 21, 25, 75, 0 }, 0x40, 700, }, + { 255, 3, 1, 0x20d0000000ull, 0x1eff8000000ull, { 23, 25, 0, 0, 0 }, 0x0, 71, }, + { 257, 2, 2, 0xa000002000ull, 0x1fe00003000ull, { 21, 22, 25, 0, 0 }, 0x0, 699, }, + { 257, 2, 2, 0xa000002000ull, 0x1fe00003000ull, { 22, 21, 25, 0, 0 }, 0x40, 700, }, + { 258, 3, 1, 0x20f0000000ull, 0x1eff8000000ull, { 23, 25, 0, 0, 0 }, 0x8, 70, }, + { 260, 3, 1, 0x20d8000000ull, 0x1eff8000000ull, { 23, 25, 0, 0, 0 }, 0x0, 72, }, + { 264, 2, 1, 0xe840000000ull, 0x1fff0000000ull, { 23, 24, 25, 0, 0 }, 0x0, 426, }, + { 265, 2, 1, 0xea40000000ull, 0x1fff0000000ull, { 23, 24, 25, 0, 0 }, 0x0, 426, }, + { 266, 2, 1, 0xf840000000ull, 0x1fff0000000ull, { 23, 24, 25, 0, 0 }, 0x0, 426, }, + { 274, 3, 1, 0x8208000000ull, 0x1fff8000000ull, { 23, 32, 24, 0, 0 }, 0x0, 73, }, + { 275, 3, 1, 0x8248000000ull, 0x1fff8000000ull, { 23, 32, 24, 0, 0 }, 0x0, 73, }, + { 276, 3, 1, 0x8288000000ull, 0x1fff8000000ull, { 23, 32, 24, 0, 0 }, 0x0, 73, }, + { 277, 3, 1, 0x82c8000000ull, 0x1fff8000000ull, { 23, 32, 24, 0, 0 }, 0x0, 73, }, + { 279, 5, 1, 0x1d000000000ull, 0x1fc00000000ull, { 17, 19, 20, 18, 0 }, 0x0, 427, }, + { 279, 5, 1, 0x1d000000000ull, 0x1fc00000000ull, { 17, 19, 20, 18, 0 }, 0x40, 479, }, + { 280, 5, 1, 0x1d000000000ull, 0x1fc000fe000ull, { 17, 19, 20, 0, 0 }, 0x40, 428, }, + { 281, 1, 1, 0x10078000000ull, 0x1eff8000000ull, { 23, 24, 25, 0, 0 }, 0x0, 0, }, + { 281, 1, 1, 0x10178000000ull, 0x1eff8000000ull, { 23, 54, 25, 0, 0 }, 0x0, 0, }, + { 284, 2, 1, 0x80000000ull, 0x1eff8000000ull, { 23, 25, 0, 0, 0 }, 0x0, 0, }, + { 285, 2, 1, 0x88000000ull, 0x1eff8000000ull, { 23, 25, 0, 0, 0 }, 0x0, 0, }, + { 286, 2, 1, 0x90000000ull, 0x1eff8000000ull, { 23, 25, 0, 0, 0 }, 0x0, 0, }, +}; + +static const char dis_table[] = { +0xa0, 0xf0, 0xd0, 0xa0, 0x4d, 0xc8, 0xa0, 0x3e, 0x88, 0xa0, 0x2e, 0x78, +0x98, 0xb0, 0x01, 0x40, 0x90, 0x50, 0x90, 0x28, 0x24, 0x25, 0xc8, 0x24, +0x25, 0xc0, 0x90, 0x28, 0x24, 0x25, 0xb8, 0x24, 0x25, 0xb0, 0x90, 0x50, +0x90, 0x28, 0x24, 0x25, 0xa0, 0x24, 0x25, 0x98, 0x90, 0x28, 0x24, 0x25, +0x90, 0x24, 0x25, 0x88, 0xa8, 0x0b, 0x28, 0x29, 0x08, 0x97, 0x00, 0x95, +0xa8, 0x9a, 0x98, 0x05, 0x18, 0x90, 0xf8, 0x90, 0x80, 0x90, 0x40, 0x80, +0xa4, 0x06, 0x50, 0x39, 0x47, 0x80, 0xa4, 0x32, 0xb8, 0x34, 0xae, 0x90, +0x50, 0x90, 0x28, 0x80, 0x36, 0x60, 0x80, 0x31, 0xbc, 0x81, 0x35, 0xa0, +0x90, 0xe0, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x00, 0x00, 0x34, 0x8f, 0xa4, +0x24, 0x60, 0x34, 0x8d, 0x90, 0x38, 0xa4, 0x2c, 0x70, 0x35, 0x83, 0xa4, +0x33, 0x80, 0x36, 0x6a, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x34, 0x70, 0x36, +0x92, 0xa4, 0x2e, 0x78, 0x35, 0xd7, 0x80, 0xa4, 0x34, 0x68, 0x36, 0x91, +0x92, 0x18, 0x91, 0xc0, 0x80, 0x91, 0x80, 0x90, 0xf8, 0xdb, 0x84, 0x61, +0x25, 0x80, 0xc0, 0xc0, 0x80, 0xa4, 0x52, 0x20, 0x8c, 0x52, 0xf0, 0x84, +0x3a, 0x8e, 0xc0, 0xc0, 0x80, 0xa4, 0x52, 0x10, 0x8c, 0x52, 0xd0, 0x84, +0x3a, 0x8a, 0xd3, 0x82, 0x40, 0x50, 0xc0, 0xc0, 0x81, 0x3a, 0x2c, 0x50, +0xc0, 0xc0, 0x81, 0x3a, 0x2a, 0xa4, 0x0d, 0xd0, 0x31, 0xbb, 0x80, 0x90, +0x28, 0x80, 0x30, 0xe5, 0x80, 0x30, 0xe7, 0x81, 0x90, 0x38, 0xa4, 0x07, +0x70, 0x30, 0xea, 0xa4, 0x07, 0x40, 0x30, 0xe6, 0xc0, 0x40, 0x10, 0x10, +0x90, 0x38, 0xa4, 0x04, 0x30, 0x30, 0x3f, 0xa4, 0x04, 0x38, 0x30, 0x7b, +0x18, 0x24, 0x3a, 0x70, 0x83, 0x90, 0xa8, 0xd3, 0x82, 0xc0, 0xc0, 0xc0, +0x80, 0xa4, 0x52, 0x50, 0x3a, 0x6a, 0xc0, 0xc0, 0x80, 0xa4, 0x52, 0x40, +0x3a, 0x66, 0xd3, 0x82, 0x40, 0x50, 0xc0, 0xc0, 0x81, 0x3a, 0x32, 0x50, +0xc0, 0xc0, 0x81, 0x3a, 0x30, 0x92, 0xb8, 0x99, 0x84, 0x07, 0x60, 0x90, +0x78, 0x90, 0x50, 0x10, 0x10, 0x80, 0xa4, 0x32, 0xb0, 0x34, 0xad, 0x82, +0x36, 0x5f, 0x90, 0x80, 0x10, 0x10, 0x90, 0x38, 0xa4, 0x2c, 0x68, 0x35, +0x82, 0xa4, 0x33, 0x78, 0x36, 0x69, 0x80, 0x90, 0x38, 0xa4, 0x2e, 0x98, +0x35, 0xdb, 0xa4, 0x2e, 0x70, 0x35, 0xd6, 0x83, 0x90, 0xa8, 0xd3, 0x82, +0xc0, 0xc0, 0xc0, 0x80, 0xa4, 0x52, 0x80, 0x3a, 0x76, 0xc0, 0xc0, 0x80, +0xa4, 0x52, 0x70, 0x3a, 0x72, 0xd3, 0x82, 0x40, 0x50, 0xc0, 0xc0, 0x81, +0x3a, 0x38, 0x50, 0xc0, 0xc0, 0x81, 0x3a, 0x36, 0x18, 0x24, 0x07, 0x68, +0x83, 0x90, 0xa8, 0xd3, 0x82, 0xc0, 0xc0, 0xc0, 0x80, 0xa4, 0x52, 0xb0, +0x3a, 0x82, 0xc0, 0xc0, 0x80, 0xa4, 0x52, 0xa0, 0x3a, 0x7e, 0xd3, 0x82, +0x40, 0x50, 0xc0, 0xc0, 0x81, 0x3a, 0x3e, 0x50, 0xc0, 0xc0, 0x81, 0x3a, +0x3c, 0x94, 0x50, 0x92, 0xf8, 0x99, 0x84, 0x3a, 0x60, 0x90, 0x78, 0x90, +0x50, 0x10, 0x10, 0x80, 0xa4, 0x32, 0xa8, 0x34, 0xac, 0x82, 0x36, 0x5e, +0x90, 0x80, 0x10, 0x10, 0x90, 0x38, 0xa4, 0x2c, 0x60, 0x35, 0x81, 0xa4, +0x33, 0x70, 0x36, 0x68, 0x80, 0x90, 0x38, 0xa4, 0x2e, 0x90, 0x35, 0xda, +0xa4, 0x2e, 0x68, 0x35, 0xd5, 0x83, 0x90, 0xe8, 0xd3, 0x83, 0xc0, 0xc0, +0xc0, 0x80, 0xa4, 0x52, 0x30, 0x8c, 0x53, 0x10, 0x84, 0x3a, 0x8c, 0xc0, +0xc0, 0x80, 0xa4, 0x52, 0x18, 0x8c, 0x52, 0xe0, 0x84, 0x3a, 0x8b, 0xd3, +0x82, 0x40, 0x50, 0xc0, 0xc0, 0x81, 0x3a, 0x2e, 0x50, 0xc0, 0xc0, 0x81, +0x3a, 0x2b, 0x18, 0x24, 0x3a, 0x68, 0x83, 0x90, 0xa8, 0xd3, 0x82, 0xc0, +0xc0, 0xc0, 0x80, 0xa4, 0x52, 0x60, 0x3a, 0x6e, 0xc0, 0xc0, 0x80, 0xa4, +0x52, 0x48, 0x3a, 0x68, 0xd3, 0x82, 0x40, 0x50, 0xc0, 0xc0, 0x81, 0x3a, +0x34, 0x50, 0xc0, 0xc0, 0x81, 0x3a, 0x31, 0x92, 0xb8, 0x99, 0x84, 0x3a, +0x50, 0x90, 0x78, 0x90, 0x50, 0x10, 0x10, 0x80, 0xa4, 0x32, 0xa0, 0x34, +0xab, 0x82, 0x36, 0x5d, 0x90, 0x80, 0x10, 0x10, 0x90, 0x38, 0xa4, 0x2c, +0x58, 0x35, 0x80, 0xa4, 0x33, 0x68, 0x36, 0x67, 0x80, 0x90, 0x38, 0xa4, +0x2e, 0x88, 0x35, 0xd9, 0xa4, 0x2e, 0x60, 0x35, 0xd4, 0x83, 0x90, 0xa8, +0xd3, 0x82, 0xc0, 0xc0, 0xc0, 0x80, 0xa4, 0x52, 0x90, 0x3a, 0x7a, 0xc0, +0xc0, 0x80, 0xa4, 0x52, 0x78, 0x3a, 0x74, 0xd3, 0x82, 0x40, 0x50, 0xc0, +0xc0, 0x81, 0x3a, 0x3a, 0x50, 0xc0, 0xc0, 0x81, 0x3a, 0x37, 0x18, 0x20, +0x01, 0x48, 0x83, 0x90, 0xa8, 0xd3, 0x82, 0xc0, 0xc0, 0xc0, 0x80, 0xa4, +0x52, 0xc0, 0x3a, 0x86, 0xc0, 0xc0, 0x80, 0xa4, 0x52, 0xa8, 0x3a, 0x80, +0xd3, 0x82, 0x40, 0x50, 0xc0, 0xc0, 0x81, 0x3a, 0x40, 0x50, 0xc0, 0xc0, +0x81, 0x3a, 0x3d, 0xea, 0x00, 0x57, 0x21, 0xd2, 0xc0, 0x95, 0x60, 0x93, +0x90, 0x91, 0xc8, 0xd1, 0xc7, 0x40, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x08, +0x60, 0x31, 0x0e, 0xa4, 0x08, 0x00, 0x31, 0x04, 0x90, 0x38, 0xa4, 0x08, +0x50, 0x31, 0x02, 0xa4, 0x08, 0x40, 0x31, 0x06, 0x90, 0x70, 0x90, 0x38, +0xa4, 0x07, 0xe0, 0x30, 0xfe, 0xa4, 0x07, 0x80, 0x30, 0xf4, 0x90, 0x38, +0xa4, 0x07, 0xd0, 0x30, 0xf2, 0xa4, 0x07, 0xc0, 0x30, 0xf6, 0xd1, 0xc7, +0x40, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x0c, 0x60, 0x31, 0xaf, 0xa4, 0x0c, +0x00, 0x31, 0x84, 0x90, 0x38, 0xa4, 0x0c, 0x50, 0x31, 0x82, 0xa4, 0x0c, +0x40, 0x31, 0x86, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x0b, 0xe0, 0x31, 0x7e, +0xa4, 0x0b, 0x80, 0x31, 0x74, 0x90, 0x38, 0xa4, 0x0b, 0xd0, 0x31, 0x72, +0xa4, 0x0b, 0xc0, 0x31, 0x76, 0x80, 0xd1, 0xc7, 0x40, 0x90, 0x70, 0x90, +0x38, 0xa4, 0x0d, 0x58, 0x31, 0xad, 0xa4, 0x0c, 0xf8, 0x31, 0xa3, 0x90, +0x38, 0xa4, 0x0d, 0x48, 0x31, 0xa1, 0xa4, 0x0d, 0x38, 0x31, 0xa5, 0x90, +0x70, 0x90, 0x38, 0xa4, 0x0c, 0xd8, 0x31, 0x9d, 0xa4, 0x0c, 0x78, 0x31, +0x93, 0x90, 0x38, 0xa4, 0x0c, 0xc8, 0x31, 0x91, 0xa4, 0x0c, 0xb8, 0x31, +0x95, 0x93, 0x90, 0x91, 0xc8, 0xd1, 0xc7, 0x40, 0x90, 0x70, 0x90, 0x38, +0xa4, 0x09, 0x60, 0x31, 0x2e, 0xa4, 0x09, 0x00, 0x31, 0x24, 0x90, 0x38, +0xa4, 0x09, 0x50, 0x31, 0x22, 0xa4, 0x09, 0x40, 0x31, 0x26, 0x90, 0x70, +0x90, 0x38, 0xa4, 0x08, 0xe0, 0x31, 0x1e, 0xa4, 0x08, 0x80, 0x31, 0x14, +0x90, 0x38, 0xa4, 0x08, 0xd0, 0x31, 0x12, 0xa4, 0x08, 0xc0, 0x31, 0x16, +0xd1, 0xc7, 0x40, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x0a, 0x60, 0x31, 0x4e, +0xa4, 0x0a, 0x00, 0x31, 0x44, 0x90, 0x38, 0xa4, 0x0a, 0x50, 0x31, 0x42, +0xa4, 0x0a, 0x40, 0x31, 0x46, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x09, 0xe0, +0x31, 0x3e, 0xa4, 0x09, 0x80, 0x31, 0x34, 0x90, 0x38, 0xa4, 0x09, 0xd0, +0x31, 0x32, 0xa4, 0x09, 0xc0, 0x31, 0x36, 0x80, 0xd1, 0xc7, 0x40, 0x90, +0x70, 0x90, 0x38, 0xa4, 0x0b, 0x60, 0x31, 0x6e, 0xa4, 0x0b, 0x00, 0x31, +0x64, 0x90, 0x38, 0xa4, 0x0b, 0x50, 0x31, 0x62, 0xa4, 0x0b, 0x40, 0x31, +0x66, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x0a, 0xe0, 0x31, 0x5e, 0xa4, 0x0a, +0x80, 0x31, 0x54, 0x90, 0x38, 0xa4, 0x0a, 0xd0, 0x31, 0x52, 0xa4, 0x0a, +0xc0, 0x31, 0x56, 0x95, 0x60, 0x93, 0x90, 0x91, 0xc8, 0xd1, 0xc7, 0x40, +0x90, 0x70, 0x90, 0x38, 0xa4, 0x08, 0x68, 0x31, 0x0f, 0xa4, 0x08, 0x08, +0x31, 0x05, 0x90, 0x38, 0xa4, 0x08, 0x58, 0x31, 0x03, 0xa4, 0x08, 0x48, +0x31, 0x07, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x07, 0xe8, 0x30, 0xff, 0xa4, +0x07, 0x88, 0x30, 0xf5, 0x90, 0x38, 0xa4, 0x07, 0xd8, 0x30, 0xf3, 0xa4, +0x07, 0xc8, 0x30, 0xf7, 0xd1, 0xc7, 0x40, 0x90, 0x70, 0x90, 0x38, 0xa4, +0x0c, 0x68, 0x31, 0x8e, 0xa4, 0x0c, 0x08, 0x31, 0x85, 0x90, 0x38, 0xa4, +0x0c, 0x58, 0x31, 0x83, 0xa4, 0x0c, 0x48, 0x31, 0x87, 0x90, 0x70, 0x90, +0x38, 0xa4, 0x0b, 0xe8, 0x31, 0x7f, 0xa4, 0x0b, 0x88, 0x31, 0x75, 0x90, +0x38, 0xa4, 0x0b, 0xd8, 0x31, 0x73, 0xa4, 0x0b, 0xc8, 0x31, 0x77, 0x80, +0xd1, 0xc7, 0x40, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x0d, 0x60, 0x31, 0xae, +0xa4, 0x0d, 0x00, 0x31, 0xa4, 0x90, 0x38, 0xa4, 0x0d, 0x50, 0x31, 0xa2, +0xa4, 0x0d, 0x40, 0x31, 0xa6, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x0c, 0xe0, +0x31, 0x9e, 0xa4, 0x0c, 0x80, 0x31, 0x94, 0x90, 0x38, 0xa4, 0x0c, 0xd0, +0x31, 0x92, 0xa4, 0x0c, 0xc0, 0x31, 0x96, 0x93, 0x90, 0x91, 0xc8, 0xd1, +0xc7, 0x40, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x09, 0x68, 0x31, 0x2f, 0xa4, +0x09, 0x08, 0x31, 0x25, 0x90, 0x38, 0xa4, 0x09, 0x58, 0x31, 0x23, 0xa4, +0x09, 0x48, 0x31, 0x27, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x08, 0xe8, 0x31, +0x1f, 0xa4, 0x08, 0x88, 0x31, 0x15, 0x90, 0x38, 0xa4, 0x08, 0xd8, 0x31, +0x13, 0xa4, 0x08, 0xc8, 0x31, 0x17, 0xd1, 0xc7, 0x40, 0x90, 0x70, 0x90, +0x38, 0xa4, 0x0a, 0x68, 0x31, 0x4f, 0xa4, 0x0a, 0x08, 0x31, 0x45, 0x90, +0x38, 0xa4, 0x0a, 0x58, 0x31, 0x43, 0xa4, 0x0a, 0x48, 0x31, 0x47, 0x90, +0x70, 0x90, 0x38, 0xa4, 0x09, 0xe8, 0x31, 0x3f, 0xa4, 0x09, 0x88, 0x31, +0x35, 0x90, 0x38, 0xa4, 0x09, 0xd8, 0x31, 0x33, 0xa4, 0x09, 0xc8, 0x31, +0x37, 0x80, 0xd1, 0xc7, 0x40, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x0b, 0x68, +0x31, 0x6f, 0xa4, 0x0b, 0x08, 0x31, 0x65, 0x90, 0x38, 0xa4, 0x0b, 0x58, +0x31, 0x63, 0xa4, 0x0b, 0x48, 0x31, 0x67, 0x90, 0x70, 0x90, 0x38, 0xa4, +0x0a, 0xe8, 0x31, 0x5f, 0xa4, 0x0a, 0x88, 0x31, 0x55, 0x90, 0x38, 0xa4, +0x0a, 0xd8, 0x31, 0x53, 0xa4, 0x0a, 0xc8, 0x31, 0x57, 0xc8, 0x40, 0x18, +0x00, 0x91, 0x38, 0x90, 0x40, 0x82, 0xa4, 0x06, 0x68, 0x39, 0x4a, 0x90, +0xc0, 0x80, 0x90, 0x90, 0x90, 0x48, 0xc9, 0xe1, 0x61, 0xc0, 0x85, 0x36, +0x82, 0xc9, 0xe1, 0x62, 0x40, 0x85, 0x35, 0x5e, 0x80, 0x35, 0x86, 0x10, +0x10, 0x81, 0x35, 0xcb, 0x90, 0xa8, 0x10, 0x10, 0x90, 0x28, 0x81, 0x35, +0x3d, 0x90, 0x38, 0xa4, 0x33, 0x28, 0x36, 0x66, 0xa4, 0x24, 0xa8, 0x35, +0x3f, 0x90, 0x70, 0x10, 0x10, 0x90, 0x38, 0xa4, 0x24, 0xd0, 0x34, 0x9b, +0x80, 0x34, 0x99, 0x90, 0x60, 0x90, 0x28, 0x24, 0x2b, 0xf0, 0xa4, 0x2b, +0xf8, 0x35, 0x7d, 0x80, 0xa4, 0x24, 0xc0, 0x34, 0x97, 0x80, 0x90, 0xf8, +0x90, 0x90, 0x90, 0x50, 0x90, 0x28, 0x80, 0x39, 0x4b, 0x80, 0x36, 0x95, +0x80, 0xa4, 0x3a, 0x30, 0x37, 0x47, 0x90, 0x28, 0x81, 0x30, 0x88, 0x80, +0xa4, 0x3a, 0x78, 0x37, 0x50, 0x83, 0x36, 0x87, 0x98, 0xb0, 0x01, 0x40, +0x90, 0x50, 0x90, 0x28, 0x24, 0x26, 0x18, 0x24, 0x26, 0x10, 0x90, 0x28, +0x24, 0x26, 0x08, 0x24, 0x26, 0x00, 0x90, 0x50, 0x90, 0x28, 0x24, 0x25, +0xf0, 0x24, 0x25, 0xe8, 0x90, 0x28, 0x24, 0x25, 0xe0, 0x24, 0x25, 0xd8, +0xa8, 0x08, 0xe0, 0x0d, 0xe0, 0x96, 0x38, 0x95, 0xe8, 0x9b, 0x48, 0x05, +0xa8, 0x91, 0xa0, 0x90, 0xd0, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x06, 0xd8, +0x30, 0xdc, 0xa4, 0x06, 0xc8, 0x30, 0xda, 0x90, 0x38, 0xa4, 0x06, 0xb8, +0x30, 0xd8, 0x80, 0x30, 0xd6, 0x90, 0x60, 0x90, 0x28, 0x24, 0x04, 0x68, +0xa4, 0x04, 0x58, 0x30, 0x8c, 0x90, 0x38, 0xa4, 0x04, 0x48, 0x30, 0x8a, +0xa4, 0x24, 0x40, 0x34, 0x89, 0x90, 0xe0, 0x90, 0x70, 0x90, 0x38, 0xa4, +0x06, 0xa0, 0x30, 0xd5, 0xa4, 0x06, 0x90, 0x30, 0xd3, 0x90, 0x38, 0xa4, +0x27, 0x38, 0x34, 0xdd, 0xa4, 0x29, 0xd0, 0x35, 0x34, 0x90, 0x70, 0x90, +0x38, 0xa4, 0x27, 0xc0, 0x35, 0x04, 0xa4, 0x27, 0x90, 0x34, 0xfe, 0x10, +0x10, 0xa4, 0x01, 0xf0, 0x30, 0x1d, 0x91, 0x50, 0x90, 0x90, 0x90, 0x50, +0x90, 0x28, 0x24, 0x06, 0xe8, 0x80, 0x30, 0xe3, 0x80, 0xa4, 0x06, 0xf0, +0x30, 0xe1, 0x90, 0x50, 0x90, 0x28, 0x24, 0x06, 0xf8, 0x80, 0x30, 0xe4, +0x90, 0x38, 0xa4, 0x07, 0x00, 0x30, 0xe2, 0xa4, 0x24, 0x50, 0x34, 0x8b, +0x90, 0xe0, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x29, 0x28, 0x36, 0x62, 0xa4, +0x28, 0x50, 0x35, 0x2b, 0x90, 0x38, 0xa4, 0x28, 0xa8, 0x35, 0x1f, 0xa4, +0x28, 0x80, 0x35, 0x1a, 0x81, 0xa4, 0x05, 0x30, 0x30, 0xa7, 0xe4, 0xe2, +0x84, 0x80, 0x3a, 0x14, 0xed, 0x22, 0x86, 0x21, 0xd2, 0x40, 0x3a, 0x1a, +0x92, 0x40, 0x99, 0x18, 0x02, 0x00, 0x10, 0x10, 0x90, 0x80, 0x10, 0x10, +0x90, 0x38, 0xa4, 0x27, 0x30, 0x34, 0xdc, 0xa4, 0x29, 0xc8, 0x35, 0x33, +0x80, 0x90, 0x38, 0xa4, 0x27, 0xb8, 0x35, 0x03, 0xa4, 0x27, 0x88, 0x34, +0xfd, 0x10, 0x10, 0x80, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x29, 0x20, 0x35, +0x30, 0xa4, 0x28, 0x48, 0x35, 0x2a, 0x90, 0x38, 0xa4, 0x28, 0xa0, 0x35, +0x1e, 0xa4, 0x28, 0x78, 0x35, 0x19, 0xe4, 0xe2, 0x87, 0x80, 0x3a, 0x20, +0xed, 0x22, 0x89, 0x21, 0xd2, 0x00, 0x3a, 0x26, 0x92, 0x80, 0x92, 0x40, +0x99, 0x18, 0x02, 0x00, 0x10, 0x10, 0x90, 0x80, 0x10, 0x10, 0x90, 0x38, +0xa4, 0x27, 0x28, 0x34, 0xdb, 0xa4, 0x29, 0xc0, 0x35, 0x32, 0x80, 0x90, +0x38, 0xa4, 0x27, 0xb0, 0x35, 0x02, 0xa4, 0x27, 0x80, 0x34, 0xfc, 0x10, +0x10, 0x80, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x29, 0x18, 0x35, 0x2f, 0xa4, +0x28, 0x40, 0x35, 0x29, 0x90, 0x38, 0xa4, 0x28, 0x98, 0x35, 0x1d, 0xa4, +0x28, 0x70, 0x35, 0x18, 0xe4, 0xe2, 0x84, 0xc0, 0x3a, 0x16, 0xe5, 0x22, +0x86, 0x40, 0x3a, 0x1c, 0x92, 0x50, 0x99, 0x18, 0x02, 0x00, 0x10, 0x10, +0x90, 0x80, 0x10, 0x10, 0x90, 0x38, 0xa4, 0x27, 0x20, 0x34, 0xda, 0xa4, +0x29, 0xb8, 0x35, 0x31, 0x80, 0x90, 0x38, 0xa4, 0x27, 0xa8, 0x35, 0x01, +0xa4, 0x27, 0x78, 0x34, 0xfb, 0x10, 0x10, 0x80, 0x90, 0x70, 0x90, 0x38, +0xa4, 0x29, 0x10, 0x35, 0x2e, 0xa4, 0x28, 0x38, 0x35, 0x28, 0x90, 0x38, +0xa4, 0x28, 0x90, 0x35, 0x1c, 0xa4, 0x28, 0x68, 0x35, 0x17, 0xec, 0xe2, +0x87, 0xe2, 0xa5, 0x00, 0x3a, 0x22, 0xe5, 0x22, 0x89, 0x40, 0x3a, 0x28, +0xc0, 0x40, 0x80, 0x10, 0x10, 0x81, 0x90, 0x90, 0x90, 0x48, 0xc9, 0xe1, +0x38, 0x40, 0x85, 0x35, 0x3e, 0xc9, 0xe1, 0x38, 0x80, 0x85, 0x34, 0xcf, +0x80, 0x34, 0xe0, 0x80, 0xd8, 0x7c, 0x80, 0x77, 0xc0, 0xc0, 0x80, 0x10, +0x10, 0x82, 0x93, 0xa8, 0xd5, 0x4e, 0xc0, 0x90, 0xe8, 0x80, 0x90, 0x70, +0x90, 0x38, 0xa4, 0x42, 0x38, 0x38, 0x19, 0xa4, 0x41, 0x78, 0x38, 0x37, +0x90, 0x38, 0xa4, 0x42, 0x18, 0x38, 0x33, 0xa4, 0x41, 0xf8, 0x38, 0x3b, +0x80, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x46, 0xe8, 0x38, 0xaf, 0xa4, 0x46, +0x28, 0x38, 0xcd, 0x90, 0x38, 0xa4, 0x46, 0xc8, 0x38, 0xc9, 0xa4, 0x46, +0xa8, 0x38, 0xd1, 0x90, 0xe8, 0x80, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x41, +0x40, 0x38, 0x2a, 0xa4, 0x40, 0xe0, 0x38, 0x20, 0x90, 0x38, 0xa4, 0x41, +0x30, 0x38, 0x1e, 0xa4, 0x41, 0x20, 0x38, 0x22, 0x80, 0x90, 0x70, 0x90, +0x38, 0xa4, 0x45, 0xf0, 0x38, 0xc0, 0xa4, 0x45, 0x90, 0x38, 0xb6, 0x90, +0x38, 0xa4, 0x45, 0xe0, 0x38, 0xb4, 0xa4, 0x45, 0xd0, 0x38, 0xb8, 0xd5, +0x4e, 0xc0, 0x90, 0xe8, 0x80, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x43, 0xc8, +0x38, 0x4b, 0xa4, 0x43, 0x08, 0x38, 0x69, 0x90, 0x38, 0xa4, 0x43, 0xa8, +0x38, 0x65, 0xa4, 0x43, 0x88, 0x38, 0x6d, 0x80, 0x90, 0x70, 0x90, 0x38, +0xa4, 0x45, 0x58, 0x38, 0x7d, 0xa4, 0x44, 0x98, 0x38, 0x9b, 0x90, 0x38, +0xa4, 0x45, 0x38, 0x38, 0x97, 0xa4, 0x45, 0x18, 0x38, 0x9f, 0x90, 0xe8, +0x80, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x42, 0xd0, 0x38, 0x5c, 0xa4, 0x42, +0x70, 0x38, 0x52, 0x90, 0x38, 0xa4, 0x42, 0xc0, 0x38, 0x50, 0xa4, 0x42, +0xb0, 0x38, 0x54, 0x80, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x44, 0x60, 0x38, +0x8e, 0xa4, 0x44, 0x00, 0x38, 0x84, 0x90, 0x38, 0xa4, 0x44, 0x50, 0x38, +0x82, 0xa4, 0x44, 0x40, 0x38, 0x86, 0xc0, 0x80, 0x10, 0x10, 0x82, 0x93, +0xa8, 0xd5, 0x4e, 0xc0, 0x90, 0xe8, 0x80, 0x90, 0x70, 0x90, 0x38, 0xa4, +0x42, 0x48, 0x38, 0x2c, 0xa4, 0x41, 0x88, 0x38, 0x39, 0x90, 0x38, 0xa4, +0x42, 0x28, 0x38, 0x35, 0xa4, 0x42, 0x08, 0x38, 0x3d, 0x80, 0x90, 0x70, +0x90, 0x38, 0xa4, 0x46, 0xf8, 0x38, 0xc2, 0xa4, 0x46, 0x38, 0x38, 0xcf, +0x90, 0x38, 0xa4, 0x46, 0xd8, 0x38, 0xcb, 0xa4, 0x46, 0xb8, 0x38, 0xd3, +0x90, 0xe8, 0x80, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x41, 0x48, 0x38, 0x2b, +0xa4, 0x40, 0xe8, 0x38, 0x21, 0x90, 0x38, 0xa4, 0x41, 0x38, 0x38, 0x1f, +0xa4, 0x41, 0x28, 0x38, 0x23, 0x80, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x45, +0xf8, 0x38, 0xc1, 0xa4, 0x45, 0x98, 0x38, 0xb7, 0x90, 0x38, 0xa4, 0x45, +0xe8, 0x38, 0xb5, 0xa4, 0x45, 0xd8, 0x38, 0xb9, 0xd5, 0x4e, 0xc0, 0x90, +0xe8, 0x80, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x43, 0xd8, 0x38, 0x5e, 0xa4, +0x43, 0x18, 0x38, 0x6b, 0x90, 0x38, 0xa4, 0x43, 0xb8, 0x38, 0x67, 0xa4, +0x43, 0x98, 0x38, 0x6f, 0x80, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x45, 0x68, +0x38, 0x90, 0xa4, 0x44, 0xa8, 0x38, 0x9d, 0x90, 0x38, 0xa4, 0x45, 0x48, +0x38, 0x99, 0xa4, 0x45, 0x28, 0x38, 0xa1, 0x90, 0xe8, 0x80, 0x90, 0x70, +0x90, 0x38, 0xa4, 0x42, 0xd8, 0x38, 0x5d, 0xa4, 0x42, 0x78, 0x38, 0x53, +0x90, 0x38, 0xa4, 0x42, 0xc8, 0x38, 0x51, 0xa4, 0x42, 0xb8, 0x38, 0x55, +0x80, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x44, 0x68, 0x38, 0x8f, 0xa4, 0x44, +0x08, 0x38, 0x85, 0x90, 0x38, 0xa4, 0x44, 0x58, 0x38, 0x83, 0xa4, 0x44, +0x48, 0x38, 0x87, 0xc0, 0x80, 0x84, 0x30, 0xce, 0xa0, 0x56, 0x50, 0xa0, +0x40, 0x70, 0xa8, 0x1d, 0x40, 0x33, 0x18, 0xa0, 0x12, 0x38, 0xa0, 0x0b, +0x48, 0x96, 0x00, 0x9a, 0xf0, 0x05, 0xc0, 0x91, 0x70, 0x90, 0xb8, 0x90, +0x70, 0x90, 0x38, 0xa4, 0x35, 0x58, 0x34, 0x87, 0xa4, 0x35, 0x68, 0x34, +0x74, 0x10, 0x10, 0xa4, 0x35, 0x60, 0x34, 0x73, 0x90, 0x70, 0x90, 0x38, +0xa4, 0x35, 0x28, 0x34, 0x36, 0xa4, 0x35, 0x38, 0x34, 0x23, 0x10, 0x10, +0xa4, 0x35, 0x30, 0x34, 0x22, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, +0x34, 0xf8, 0x33, 0xe5, 0xa4, 0x35, 0x08, 0x33, 0xd2, 0x10, 0x10, 0xa4, +0x35, 0x00, 0x33, 0xd1, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x34, 0xc8, 0x33, +0x94, 0xa4, 0x34, 0xd8, 0x33, 0x7e, 0x10, 0x10, 0xa4, 0x34, 0xd0, 0x33, +0x7d, 0x91, 0x70, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x35, 0x40, +0x34, 0x70, 0xa4, 0x35, 0x50, 0x34, 0x72, 0x10, 0x10, 0xa4, 0x35, 0x48, +0x34, 0x71, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x35, 0x10, 0x34, 0x1f, 0xa4, +0x35, 0x20, 0x34, 0x21, 0x10, 0x10, 0xa4, 0x35, 0x18, 0x34, 0x20, 0x90, +0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x34, 0xe0, 0x33, 0xce, 0xa4, 0x34, +0xf0, 0x33, 0xd0, 0x10, 0x10, 0xa4, 0x34, 0xe8, 0x33, 0xcf, 0x90, 0x70, +0x90, 0x38, 0xa4, 0x34, 0xb0, 0x33, 0x7a, 0xa4, 0x34, 0xc0, 0x33, 0x7c, +0x10, 0x10, 0xa4, 0x34, 0xb8, 0x33, 0x7b, 0xe4, 0xe1, 0x91, 0x80, 0x36, +0x50, 0x9a, 0xf0, 0x05, 0x00, 0x91, 0x70, 0x90, 0xb8, 0x90, 0x70, 0x90, +0x38, 0xa4, 0x00, 0xb0, 0x34, 0x84, 0xa4, 0x00, 0xa8, 0x34, 0x86, 0x10, +0x10, 0xa4, 0x00, 0xa0, 0x34, 0x85, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x00, +0x98, 0x34, 0x33, 0xa4, 0x00, 0x90, 0x34, 0x35, 0x10, 0x10, 0xa4, 0x00, +0x88, 0x34, 0x34, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x00, 0x80, +0x33, 0xe2, 0xa4, 0x00, 0x78, 0x33, 0xe4, 0x10, 0x10, 0xa4, 0x00, 0x70, +0x33, 0xe3, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x00, 0x68, 0x33, 0x91, 0xa4, +0x00, 0x60, 0x33, 0x93, 0x10, 0x10, 0xa4, 0x00, 0x58, 0x33, 0x92, 0x91, +0x10, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x34, 0x6d, 0x80, 0x34, +0x6f, 0x10, 0x10, 0x80, 0x34, 0x6e, 0x90, 0x50, 0x90, 0x28, 0x80, 0x34, +0x1c, 0x80, 0x34, 0x1e, 0x10, 0x10, 0x80, 0x34, 0x1d, 0x90, 0x88, 0x90, +0x50, 0x90, 0x28, 0x80, 0x33, 0xcb, 0x80, 0x33, 0xcd, 0x10, 0x10, 0x80, +0x33, 0xcc, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x77, 0x80, 0x33, 0x79, +0x10, 0x10, 0x80, 0x33, 0x78, 0xe4, 0xe1, 0x89, 0x00, 0x36, 0x38, 0x95, +0x40, 0x9a, 0x90, 0x05, 0x00, 0x91, 0x10, 0x90, 0x88, 0x90, 0x50, 0x90, +0x28, 0x80, 0x34, 0x7e, 0x80, 0x34, 0x80, 0x10, 0x10, 0x80, 0x34, 0x7f, +0x90, 0x50, 0x90, 0x28, 0x80, 0x34, 0x2d, 0x80, 0x34, 0x2f, 0x10, 0x10, +0x80, 0x34, 0x2e, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x2d, 0x50, +0x33, 0xdc, 0xa4, 0x2d, 0x60, 0x33, 0xde, 0x10, 0x10, 0xa4, 0x2d, 0x58, +0x33, 0xdd, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x2d, 0x20, 0x33, 0x8b, 0xa4, +0x2d, 0x30, 0x33, 0x8d, 0x10, 0x10, 0xa4, 0x2d, 0x28, 0x33, 0x8c, 0x91, +0x10, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x34, 0x81, 0x80, 0x34, +0x83, 0x10, 0x10, 0x80, 0x34, 0x82, 0x90, 0x50, 0x90, 0x28, 0x80, 0x34, +0x30, 0x80, 0x34, 0x32, 0x10, 0x10, 0x80, 0x34, 0x31, 0x90, 0xb8, 0x90, +0x70, 0x90, 0x38, 0xa4, 0x2d, 0x38, 0x33, 0xdf, 0xa4, 0x2d, 0x48, 0x33, +0xe1, 0x10, 0x10, 0xa4, 0x2d, 0x40, 0x33, 0xe0, 0x90, 0x70, 0x90, 0x38, +0xa4, 0x2d, 0x08, 0x33, 0x8e, 0xa4, 0x2d, 0x18, 0x33, 0x90, 0x10, 0x10, +0xa4, 0x2d, 0x10, 0x33, 0x8f, 0xe4, 0xe1, 0x91, 0x00, 0x36, 0x4e, 0x98, +0xb8, 0x01, 0x68, 0x10, 0x10, 0x10, 0x10, 0x90, 0x50, 0x90, 0x28, 0x80, +0x33, 0x7f, 0x80, 0x33, 0x81, 0x10, 0x10, 0x80, 0x33, 0x80, 0x90, 0x60, +0x90, 0x30, 0x60, 0xa1, 0x24, 0x40, 0x60, 0xa1, 0x24, 0xc0, 0x90, 0x30, +0x60, 0xa1, 0x24, 0x80, 0x60, 0xa1, 0x25, 0x00, 0xe4, 0xe1, 0x88, 0x00, +0x36, 0x34, 0x96, 0xe8, 0x94, 0x80, 0x9a, 0x30, 0x04, 0x40, 0x91, 0x10, +0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x34, 0x78, 0x80, 0x34, 0x7a, +0x10, 0x10, 0x80, 0x34, 0x79, 0x90, 0x50, 0x90, 0x28, 0x80, 0x34, 0x27, +0x80, 0x34, 0x29, 0x10, 0x10, 0x80, 0x34, 0x28, 0x90, 0x88, 0x90, 0x50, +0x90, 0x28, 0x80, 0x33, 0xd6, 0x80, 0x33, 0xd8, 0x10, 0x10, 0x80, 0x33, +0xd7, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x85, 0x80, 0x33, 0x87, 0x10, +0x10, 0x80, 0x33, 0x86, 0x91, 0x10, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, +0x80, 0x34, 0x75, 0x80, 0x34, 0x77, 0x10, 0x10, 0x80, 0x34, 0x76, 0x90, +0x50, 0x90, 0x28, 0x80, 0x34, 0x24, 0x80, 0x34, 0x26, 0x10, 0x10, 0x80, +0x34, 0x25, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0xd3, 0x80, +0x33, 0xd5, 0x10, 0x10, 0x80, 0x33, 0xd4, 0x90, 0x50, 0x90, 0x28, 0x80, +0x33, 0x82, 0x80, 0x33, 0x84, 0x10, 0x10, 0x80, 0x33, 0x83, 0xe4, 0xe1, +0x90, 0x80, 0x36, 0x4c, 0x88, 0x02, 0x28, 0x91, 0x10, 0x90, 0x88, 0x90, +0x50, 0x90, 0x28, 0x80, 0x34, 0x7b, 0x80, 0x34, 0x7d, 0x10, 0x10, 0x80, +0x34, 0x7c, 0x90, 0x50, 0x90, 0x28, 0x80, 0x34, 0x2a, 0x80, 0x34, 0x2c, +0x10, 0x10, 0x80, 0x34, 0x2b, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, +0x33, 0xd9, 0x80, 0x33, 0xdb, 0x10, 0x10, 0x80, 0x33, 0xda, 0x90, 0x50, +0x90, 0x28, 0x80, 0x33, 0x88, 0x80, 0x33, 0x8a, 0x10, 0x10, 0x80, 0x33, +0x89, 0xe4, 0xe1, 0x87, 0x00, 0x36, 0x30, 0x93, 0x40, 0x99, 0x90, 0x03, +0x00, 0x90, 0xc0, 0x90, 0x60, 0x90, 0x28, 0x81, 0x30, 0x7a, 0x10, 0x10, +0x80, 0x30, 0x79, 0x90, 0x28, 0x81, 0x30, 0x72, 0x10, 0x10, 0x80, 0x30, +0x71, 0x90, 0x60, 0x90, 0x28, 0x81, 0x30, 0x6a, 0x10, 0x10, 0x80, 0x30, +0x69, 0x90, 0x28, 0x81, 0x30, 0x62, 0x10, 0x10, 0x80, 0x30, 0x61, 0x90, +0xc0, 0x90, 0x60, 0x90, 0x28, 0x81, 0x30, 0x77, 0x10, 0x10, 0x80, 0x30, +0x78, 0x90, 0x28, 0x81, 0x30, 0x6f, 0x10, 0x10, 0x80, 0x30, 0x70, 0x90, +0x60, 0x90, 0x28, 0x81, 0x30, 0x67, 0x10, 0x10, 0x80, 0x30, 0x68, 0x90, +0x28, 0x81, 0x30, 0x5f, 0x10, 0x10, 0x80, 0x30, 0x60, 0xe4, 0xe1, 0x90, +0x00, 0x36, 0x4a, 0x88, 0x00, 0x88, 0x10, 0x10, 0x10, 0x10, 0x90, 0x28, +0x81, 0x30, 0x5d, 0x10, 0x10, 0x80, 0x30, 0x5e, 0xe4, 0xe1, 0x86, 0x00, +0x36, 0x2c, 0xa0, 0x0e, 0x80, 0xa0, 0x09, 0x08, 0x94, 0x80, 0x9a, 0x30, +0x04, 0x40, 0x91, 0x10, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x34, +0x6c, 0x80, 0x34, 0x59, 0x10, 0x10, 0x80, 0x34, 0x58, 0x90, 0x50, 0x90, +0x28, 0x80, 0x34, 0x1b, 0x80, 0x34, 0x08, 0x10, 0x10, 0x80, 0x34, 0x07, +0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0xca, 0x80, 0x33, 0xb7, +0x10, 0x10, 0x80, 0x33, 0xb6, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x76, +0x80, 0x33, 0x60, 0x10, 0x10, 0x80, 0x33, 0x5f, 0x91, 0x10, 0x90, 0x88, +0x90, 0x50, 0x90, 0x28, 0x80, 0x34, 0x55, 0x80, 0x34, 0x57, 0x10, 0x10, +0x80, 0x34, 0x56, 0x90, 0x50, 0x90, 0x28, 0x80, 0x34, 0x04, 0x80, 0x34, +0x06, 0x10, 0x10, 0x80, 0x34, 0x05, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, +0x80, 0x33, 0xb3, 0x80, 0x33, 0xb5, 0x10, 0x10, 0x80, 0x33, 0xb4, 0x90, +0x50, 0x90, 0x28, 0x80, 0x33, 0x5c, 0x80, 0x33, 0x5e, 0x10, 0x10, 0x80, +0x33, 0x5d, 0xe4, 0xe1, 0x7f, 0x00, 0x36, 0x10, 0x9a, 0x30, 0x04, 0x40, +0x91, 0x10, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x34, 0x69, 0x80, +0x34, 0x6b, 0x10, 0x10, 0x80, 0x34, 0x6a, 0x90, 0x50, 0x90, 0x28, 0x80, +0x34, 0x18, 0x80, 0x34, 0x1a, 0x10, 0x10, 0x80, 0x34, 0x19, 0x90, 0x88, +0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0xc7, 0x80, 0x33, 0xc9, 0x10, 0x10, +0x80, 0x33, 0xc8, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x73, 0x80, 0x33, +0x75, 0x10, 0x10, 0x80, 0x33, 0x74, 0x91, 0x10, 0x90, 0x88, 0x90, 0x50, +0x90, 0x28, 0x80, 0x34, 0x52, 0x80, 0x34, 0x54, 0x10, 0x10, 0x80, 0x34, +0x53, 0x90, 0x50, 0x90, 0x28, 0x80, 0x34, 0x01, 0x80, 0x34, 0x03, 0x10, +0x10, 0x80, 0x34, 0x02, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, +0xb0, 0x80, 0x33, 0xb2, 0x10, 0x10, 0x80, 0x33, 0xb1, 0x90, 0x50, 0x90, +0x28, 0x80, 0x33, 0x59, 0x80, 0x33, 0x5b, 0x10, 0x10, 0x80, 0x33, 0x5a, +0xe4, 0xe1, 0x78, 0x80, 0x35, 0xec, 0x94, 0x80, 0x9a, 0x30, 0x04, 0x40, +0x91, 0x10, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x34, 0x63, 0x80, +0x34, 0x65, 0x10, 0x10, 0x80, 0x34, 0x64, 0x90, 0x50, 0x90, 0x28, 0x80, +0x34, 0x12, 0x80, 0x34, 0x14, 0x10, 0x10, 0x80, 0x34, 0x13, 0x90, 0x88, +0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0xc1, 0x80, 0x33, 0xc3, 0x10, 0x10, +0x80, 0x33, 0xc2, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x6d, 0x80, 0x33, +0x6f, 0x10, 0x10, 0x80, 0x33, 0x6e, 0x91, 0x10, 0x90, 0x88, 0x90, 0x50, +0x90, 0x28, 0x80, 0x34, 0x66, 0x80, 0x34, 0x68, 0x10, 0x10, 0x80, 0x34, +0x67, 0x90, 0x50, 0x90, 0x28, 0x80, 0x34, 0x15, 0x80, 0x34, 0x17, 0x10, +0x10, 0x80, 0x34, 0x16, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, +0xc4, 0x80, 0x33, 0xc6, 0x10, 0x10, 0x80, 0x33, 0xc5, 0x90, 0x50, 0x90, +0x28, 0x80, 0x33, 0x70, 0x80, 0x33, 0x72, 0x10, 0x10, 0x80, 0x33, 0x71, +0xe4, 0xe1, 0x7e, 0x00, 0x36, 0x0c, 0x88, 0x00, 0xb0, 0x10, 0x10, 0x10, +0x10, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x61, 0x80, 0x33, 0x63, 0x10, +0x10, 0x80, 0x33, 0x62, 0xe4, 0xe1, 0x78, 0x00, 0x35, 0xea, 0x96, 0xe8, +0x94, 0x80, 0x9a, 0x30, 0x04, 0x40, 0x91, 0x10, 0x90, 0x88, 0x90, 0x50, +0x90, 0x28, 0x80, 0x34, 0x5d, 0x80, 0x34, 0x5f, 0x10, 0x10, 0x80, 0x34, +0x5e, 0x90, 0x50, 0x90, 0x28, 0x80, 0x34, 0x0c, 0x80, 0x34, 0x0e, 0x10, +0x10, 0x80, 0x34, 0x0d, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, +0xbb, 0x80, 0x33, 0xbd, 0x10, 0x10, 0x80, 0x33, 0xbc, 0x90, 0x50, 0x90, +0x28, 0x80, 0x33, 0x67, 0x80, 0x33, 0x69, 0x10, 0x10, 0x80, 0x33, 0x68, +0x91, 0x10, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x34, 0x5a, 0x80, +0x34, 0x5c, 0x10, 0x10, 0x80, 0x34, 0x5b, 0x90, 0x50, 0x90, 0x28, 0x80, +0x34, 0x09, 0x80, 0x34, 0x0b, 0x10, 0x10, 0x80, 0x34, 0x0a, 0x90, 0x88, +0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0xb8, 0x80, 0x33, 0xba, 0x10, 0x10, +0x80, 0x33, 0xb9, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x64, 0x80, 0x33, +0x66, 0x10, 0x10, 0x80, 0x33, 0x65, 0xe4, 0xe1, 0x7d, 0x00, 0x36, 0x08, +0x88, 0x02, 0x28, 0x91, 0x10, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, +0x34, 0x60, 0x80, 0x34, 0x62, 0x10, 0x10, 0x80, 0x34, 0x61, 0x90, 0x50, +0x90, 0x28, 0x80, 0x34, 0x0f, 0x80, 0x34, 0x11, 0x10, 0x10, 0x80, 0x34, +0x10, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0xbe, 0x80, 0x33, +0xc0, 0x10, 0x10, 0x80, 0x33, 0xbf, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, +0x6a, 0x80, 0x33, 0x6c, 0x10, 0x10, 0x80, 0x33, 0x6b, 0xe4, 0xe1, 0x77, +0x80, 0x35, 0xe8, 0x90, 0x40, 0xe5, 0x21, 0x7c, 0x00, 0x36, 0x04, 0xe5, +0x21, 0x77, 0x00, 0x35, 0xe6, 0x9e, 0xb4, 0x34, 0x60, 0x93, 0x70, 0x91, +0xd8, 0xd5, 0x07, 0x80, 0xd0, 0xc4, 0x40, 0x90, 0x48, 0x80, 0x8c, 0x4f, +0x00, 0x84, 0x3a, 0x10, 0xa4, 0x4d, 0x70, 0x39, 0xc6, 0x90, 0x28, 0x24, +0x4c, 0xb0, 0xa4, 0x4b, 0x30, 0x39, 0x7e, 0xd0, 0xc4, 0x40, 0x90, 0x48, +0x80, 0x8c, 0x4e, 0xe0, 0x84, 0x3a, 0x0c, 0xa4, 0x4d, 0x60, 0x39, 0xc4, +0x90, 0x28, 0x24, 0x4c, 0xa0, 0xa4, 0x4b, 0x20, 0x39, 0x7c, 0xd5, 0x06, +0x80, 0xd0, 0xc3, 0x40, 0x90, 0x28, 0x80, 0x39, 0xec, 0xa4, 0x4d, 0xa0, +0x39, 0xcc, 0x90, 0x28, 0x24, 0x4c, 0xe0, 0xa4, 0x4b, 0x60, 0x39, 0x84, +0xd0, 0xc3, 0x40, 0x90, 0x28, 0x80, 0x39, 0xe8, 0xa4, 0x4d, 0x90, 0x39, +0xca, 0x90, 0x28, 0x24, 0x4c, 0xd0, 0xa4, 0x4b, 0x50, 0x39, 0x82, 0x91, +0x98, 0xd5, 0x06, 0x80, 0xd0, 0xc3, 0x40, 0x90, 0x28, 0x80, 0x39, 0xf8, +0xa4, 0x4d, 0xd0, 0x39, 0xd2, 0x90, 0x28, 0x24, 0x4d, 0x10, 0xa4, 0x4b, +0x90, 0x39, 0x8a, 0xd0, 0xc3, 0x40, 0x90, 0x28, 0x80, 0x39, 0xf4, 0xa4, +0x4d, 0xc0, 0x39, 0xd0, 0x90, 0x28, 0x24, 0x4d, 0x00, 0xa4, 0x4b, 0x80, +0x39, 0x88, 0xd5, 0x06, 0x80, 0xd0, 0xc3, 0x40, 0x90, 0x28, 0x80, 0x3a, +0x04, 0xa4, 0x4e, 0x00, 0x39, 0xd8, 0x90, 0x28, 0x24, 0x4d, 0x40, 0xa4, +0x4b, 0xc0, 0x39, 0x90, 0xd0, 0xc3, 0x40, 0x90, 0x28, 0x80, 0x3a, 0x00, +0xa4, 0x4d, 0xf0, 0x39, 0xd6, 0x90, 0x28, 0x24, 0x4d, 0x30, 0xa4, 0x4b, +0xb0, 0x39, 0x8e, 0x93, 0x70, 0x91, 0xd8, 0xd5, 0x07, 0x80, 0xd0, 0xc4, +0x40, 0x90, 0x48, 0x80, 0x8c, 0x4f, 0x20, 0x84, 0x3a, 0x0e, 0xa4, 0x4d, +0x80, 0x39, 0xc8, 0x90, 0x28, 0x24, 0x4c, 0xc0, 0xa4, 0x4b, 0x40, 0x39, +0x80, 0xd0, 0xc4, 0x40, 0x90, 0x48, 0x80, 0x8c, 0x4e, 0xf0, 0x84, 0x3a, +0x0d, 0xa4, 0x4d, 0x68, 0x39, 0xc5, 0x90, 0x28, 0x24, 0x4c, 0xa8, 0xa4, +0x4b, 0x28, 0x39, 0x7d, 0xd5, 0x06, 0x80, 0xd0, 0xc3, 0x40, 0x90, 0x28, +0x80, 0x39, 0xf0, 0xa4, 0x4d, 0xb0, 0x39, 0xce, 0x90, 0x28, 0x24, 0x4c, +0xf0, 0xa4, 0x4b, 0x70, 0x39, 0x86, 0xd0, 0xc3, 0x40, 0x90, 0x28, 0x80, +0x39, 0xea, 0xa4, 0x4d, 0x98, 0x39, 0xcb, 0x90, 0x28, 0x24, 0x4c, 0xd8, +0xa4, 0x4b, 0x58, 0x39, 0x83, 0x91, 0x98, 0xd5, 0x06, 0x80, 0xd0, 0xc3, +0x40, 0x90, 0x28, 0x80, 0x39, 0xfc, 0xa4, 0x4d, 0xe0, 0x39, 0xd4, 0x90, +0x28, 0x24, 0x4d, 0x20, 0xa4, 0x4b, 0xa0, 0x39, 0x8c, 0xd0, 0xc3, 0x40, +0x90, 0x28, 0x80, 0x39, 0xf6, 0xa4, 0x4d, 0xc8, 0x39, 0xd1, 0x90, 0x28, +0x24, 0x4d, 0x08, 0xa4, 0x4b, 0x88, 0x39, 0x89, 0xd5, 0x06, 0x80, 0xd0, +0xc3, 0x40, 0x90, 0x28, 0x80, 0x3a, 0x08, 0xa4, 0x4e, 0x10, 0x39, 0xda, +0x90, 0x28, 0x24, 0x4d, 0x50, 0xa4, 0x4b, 0xd0, 0x39, 0x92, 0xd0, 0xc3, +0x40, 0x90, 0x28, 0x80, 0x3a, 0x02, 0xa4, 0x4d, 0xf8, 0x39, 0xd7, 0x90, +0x28, 0x24, 0x4d, 0x38, 0xa4, 0x4b, 0xb8, 0x39, 0x8f, 0x99, 0x08, 0x01, +0xf0, 0x81, 0x90, 0x78, 0xd4, 0xc2, 0x00, 0xa4, 0x01, 0x80, 0x30, 0x2e, +0xa4, 0x01, 0x00, 0x30, 0x1e, 0xd4, 0xc2, 0x00, 0xa4, 0x01, 0xc0, 0x30, +0x32, 0xa4, 0x01, 0x40, 0x30, 0x22, 0x81, 0x90, 0x78, 0xd4, 0xc2, 0x00, +0xa4, 0x01, 0xe0, 0x30, 0x36, 0xa4, 0x01, 0x60, 0x30, 0x26, 0xd4, 0xc2, +0x00, 0xa4, 0x01, 0xd0, 0x30, 0x34, 0xa4, 0x01, 0x50, 0x30, 0x24, 0xa8, +0x0b, 0x18, 0x13, 0xa8, 0x96, 0x80, 0x93, 0x40, 0x99, 0x90, 0x03, 0x00, +0x90, 0xc0, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x21, 0xf0, 0x34, 0x51, 0x24, +0x21, 0xe8, 0x90, 0x38, 0xa4, 0x1f, 0x68, 0x34, 0x00, 0x24, 0x1f, 0x60, +0x90, 0x60, 0x90, 0x38, 0xa4, 0x1c, 0xe0, 0x33, 0xaf, 0x24, 0x1c, 0xd8, +0x90, 0x38, 0xa4, 0x1a, 0x10, 0x33, 0x58, 0x24, 0x1a, 0x08, 0x90, 0xc0, +0x90, 0x60, 0x90, 0x38, 0xa4, 0x21, 0xe0, 0x34, 0x3a, 0x24, 0x21, 0xd8, +0x90, 0x38, 0xa4, 0x1f, 0x58, 0x33, 0xe9, 0x24, 0x1f, 0x50, 0x90, 0x60, +0x90, 0x38, 0xa4, 0x1c, 0xd0, 0x33, 0x98, 0x24, 0x1c, 0xc8, 0x90, 0x38, +0xa4, 0x1a, 0x00, 0x33, 0x3e, 0x24, 0x19, 0xf8, 0xe4, 0xe2, 0x53, 0x00, +0x39, 0x4e, 0x99, 0x90, 0x03, 0x00, 0x90, 0xc0, 0x90, 0x60, 0x90, 0x38, +0xa4, 0x22, 0x80, 0x34, 0x4e, 0x24, 0x22, 0x78, 0x90, 0x38, 0xa4, 0x1f, +0xf8, 0x33, 0xfd, 0x24, 0x1f, 0xf0, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x1d, +0x70, 0x33, 0xac, 0x24, 0x1d, 0x68, 0x90, 0x38, 0xa4, 0x1a, 0xb8, 0x33, +0x55, 0x24, 0x1a, 0xb0, 0x90, 0xc0, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x21, +0xc8, 0x34, 0x37, 0x24, 0x21, 0xc0, 0x90, 0x38, 0xa4, 0x1f, 0x40, 0x33, +0xe6, 0x24, 0x1f, 0x38, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x1c, 0xb8, 0x33, +0x95, 0x24, 0x1c, 0xb0, 0x90, 0x38, 0xa4, 0x19, 0xe8, 0x33, 0x3b, 0x24, +0x19, 0xe0, 0xe4, 0xe2, 0x54, 0x80, 0x39, 0x54, 0x93, 0x78, 0x99, 0x90, +0x03, 0x00, 0x90, 0xc0, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x22, 0x50, 0x34, +0x48, 0x24, 0x22, 0x48, 0x90, 0x38, 0xa4, 0x1f, 0xc8, 0x33, 0xf7, 0x24, +0x1f, 0xc0, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x1d, 0x40, 0x33, 0xa6, 0x24, +0x1d, 0x38, 0x90, 0x38, 0xa4, 0x1a, 0x88, 0x33, 0x4f, 0x24, 0x1a, 0x80, +0x90, 0xc0, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x22, 0x68, 0x34, 0x4b, 0x24, +0x22, 0x60, 0x90, 0x38, 0xa4, 0x1f, 0xe0, 0x33, 0xfa, 0x24, 0x1f, 0xd8, +0x90, 0x60, 0x90, 0x38, 0xa4, 0x1d, 0x58, 0x33, 0xa9, 0x24, 0x1d, 0x50, +0x90, 0x38, 0xa4, 0x1a, 0xa0, 0x33, 0x52, 0x24, 0x1a, 0x98, 0xec, 0xa1, +0xa1, 0x40, 0x02, 0x00, 0x36, 0x83, 0xa4, 0x4a, 0xc0, 0x39, 0x5a, 0x88, +0x00, 0x88, 0x10, 0x10, 0x10, 0x10, 0x90, 0x38, 0xa4, 0x1a, 0x28, 0x33, +0x43, 0x24, 0x1a, 0x20, 0xe9, 0x61, 0xa2, 0x40, 0x02, 0x00, 0x36, 0x8a, +0xe3, 0x62, 0x57, 0x80, 0x39, 0x60, 0x95, 0x08, 0x93, 0x40, 0x99, 0x90, +0x03, 0x00, 0x90, 0xc0, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x22, 0x20, 0x34, +0x42, 0x24, 0x22, 0x18, 0x90, 0x38, 0xa4, 0x1f, 0x98, 0x33, 0xf1, 0x24, +0x1f, 0x90, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x1d, 0x10, 0x33, 0xa0, 0x24, +0x1d, 0x08, 0x90, 0x38, 0xa4, 0x1a, 0x58, 0x33, 0x49, 0x24, 0x1a, 0x50, +0x90, 0xc0, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x22, 0x08, 0x34, 0x3f, 0x24, +0x22, 0x00, 0x90, 0x38, 0xa4, 0x1f, 0x80, 0x33, 0xee, 0x24, 0x1f, 0x78, +0x90, 0x60, 0x90, 0x38, 0xa4, 0x1c, 0xf8, 0x33, 0x9d, 0x24, 0x1c, 0xf0, +0x90, 0x38, 0xa4, 0x1a, 0x40, 0x33, 0x46, 0x24, 0x1a, 0x38, 0xe4, 0xe2, +0x53, 0x40, 0x39, 0x50, 0x88, 0x01, 0x88, 0x90, 0xc0, 0x90, 0x60, 0x90, +0x38, 0xa4, 0x22, 0x38, 0x34, 0x45, 0x24, 0x22, 0x30, 0x90, 0x38, 0xa4, +0x1f, 0xb0, 0x33, 0xf4, 0x24, 0x1f, 0xa8, 0x90, 0x60, 0x90, 0x38, 0xa4, +0x1d, 0x28, 0x33, 0xa3, 0x24, 0x1d, 0x20, 0x90, 0x38, 0xa4, 0x1a, 0x70, +0x33, 0x4c, 0x24, 0x1a, 0x68, 0xe4, 0xe2, 0x54, 0xc0, 0x39, 0x56, 0x92, +0xd0, 0x99, 0x50, 0x02, 0x80, 0x90, 0xa0, 0x90, 0x50, 0x90, 0x28, 0x80, +0x30, 0x76, 0x24, 0x03, 0xa8, 0x90, 0x28, 0x80, 0x30, 0x6e, 0x24, 0x03, +0x68, 0x90, 0x50, 0x90, 0x28, 0x80, 0x30, 0x66, 0x24, 0x03, 0x28, 0x90, +0x28, 0x80, 0x30, 0x5c, 0x24, 0x02, 0xd8, 0x90, 0xa0, 0x90, 0x50, 0x90, +0x28, 0x80, 0x30, 0x73, 0x24, 0x03, 0xa0, 0x90, 0x28, 0x80, 0x30, 0x6b, +0x24, 0x03, 0x60, 0x90, 0x50, 0x90, 0x28, 0x80, 0x30, 0x63, 0x24, 0x03, +0x20, 0x90, 0x28, 0x80, 0x30, 0x59, 0x24, 0x02, 0xd0, 0xec, 0xe2, 0x56, +0x60, 0x1f, 0x00, 0x39, 0x5c, 0x88, 0x00, 0x78, 0x10, 0x10, 0x10, 0x10, +0x90, 0x28, 0x80, 0x30, 0x57, 0x24, 0x02, 0xc0, 0xec, 0xe2, 0x57, 0xe1, +0xa2, 0x00, 0x39, 0x62, 0xe5, 0xa1, 0x96, 0xc0, 0x36, 0x59, 0xa0, 0x2a, +0x10, 0xa8, 0x16, 0x60, 0x29, 0xd8, 0xa0, 0x0c, 0x48, 0xa0, 0x0a, 0xc8, +0x95, 0x60, 0x92, 0xb0, 0x91, 0x40, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, +0x80, 0x32, 0xc5, 0x80, 0x32, 0xbb, 0x10, 0x10, 0x80, 0x32, 0xba, 0x90, +0x70, 0x90, 0x38, 0xa4, 0x14, 0x78, 0x33, 0x31, 0xa4, 0x14, 0x28, 0x33, +0x27, 0x10, 0x10, 0xa4, 0x14, 0x20, 0x33, 0x26, 0x90, 0xb8, 0x90, 0x70, +0x90, 0x38, 0xa4, 0x12, 0x38, 0x32, 0x23, 0xa4, 0x11, 0xe8, 0x32, 0x19, +0x10, 0x10, 0xa4, 0x11, 0xe0, 0x32, 0x18, 0x90, 0x70, 0x90, 0x38, 0xa4, +0x13, 0x58, 0x32, 0xfb, 0xa4, 0x13, 0x08, 0x32, 0xf1, 0x10, 0x10, 0xa4, +0x13, 0x00, 0x32, 0xf0, 0x91, 0x40, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, +0x80, 0x32, 0xb7, 0x80, 0x32, 0xb9, 0x10, 0x10, 0x80, 0x32, 0xb8, 0x90, +0x70, 0x90, 0x38, 0xa4, 0x14, 0x08, 0x33, 0x23, 0xa4, 0x14, 0x18, 0x33, +0x25, 0x10, 0x10, 0xa4, 0x14, 0x10, 0x33, 0x24, 0x90, 0xb8, 0x90, 0x70, +0x90, 0x38, 0xa4, 0x11, 0xc8, 0x32, 0x15, 0xa4, 0x11, 0xd8, 0x32, 0x17, +0x10, 0x10, 0xa4, 0x11, 0xd0, 0x32, 0x16, 0x90, 0x70, 0x90, 0x38, 0xa4, +0x12, 0xe8, 0x32, 0xed, 0xa4, 0x12, 0xf8, 0x32, 0xef, 0x10, 0x10, 0xa4, +0x12, 0xf0, 0x32, 0xee, 0x92, 0xb0, 0x91, 0x40, 0x90, 0x88, 0x90, 0x50, +0x90, 0x28, 0x80, 0x32, 0xc2, 0x80, 0x32, 0xc4, 0x10, 0x10, 0x80, 0x32, +0xc3, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x14, 0x60, 0x33, 0x2e, 0xa4, 0x14, +0x70, 0x33, 0x30, 0x10, 0x10, 0xa4, 0x14, 0x68, 0x33, 0x2f, 0x90, 0xb8, +0x90, 0x70, 0x90, 0x38, 0xa4, 0x12, 0x20, 0x32, 0x20, 0xa4, 0x12, 0x30, +0x32, 0x22, 0x10, 0x10, 0xa4, 0x12, 0x28, 0x32, 0x21, 0x90, 0x70, 0x90, +0x38, 0xa4, 0x13, 0x40, 0x32, 0xf8, 0xa4, 0x13, 0x50, 0x32, 0xfa, 0x10, +0x10, 0xa4, 0x13, 0x48, 0x32, 0xf9, 0x91, 0x40, 0x90, 0x88, 0x90, 0x50, +0x90, 0x28, 0x80, 0x32, 0xb4, 0x80, 0x32, 0xb6, 0x10, 0x10, 0x80, 0x32, +0xb5, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x13, 0xf0, 0x33, 0x20, 0xa4, 0x14, +0x00, 0x33, 0x22, 0x10, 0x10, 0xa4, 0x13, 0xf8, 0x33, 0x21, 0x90, 0xb8, +0x90, 0x70, 0x90, 0x38, 0xa4, 0x11, 0xb0, 0x32, 0x12, 0xa4, 0x11, 0xc0, +0x32, 0x14, 0x10, 0x10, 0xa4, 0x11, 0xb8, 0x32, 0x13, 0x90, 0x70, 0x90, +0x38, 0xa4, 0x12, 0xd0, 0x32, 0xea, 0xa4, 0x12, 0xe0, 0x32, 0xec, 0x10, +0x10, 0xa4, 0x12, 0xd8, 0x32, 0xeb, 0x10, 0x10, 0x90, 0xa8, 0x10, 0x10, +0x10, 0x10, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x38, 0x80, 0x33, 0x3a, +0x10, 0x10, 0x80, 0x33, 0x39, 0x90, 0x60, 0x90, 0x30, 0x60, 0xa0, 0x20, +0x80, 0x60, 0xa0, 0x21, 0x00, 0x90, 0x30, 0x60, 0xa0, 0x20, 0xc0, 0x60, +0xa0, 0x21, 0x40, 0x97, 0xf0, 0x95, 0x60, 0x92, 0xb0, 0x91, 0x40, 0x90, +0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x32, 0xbf, 0x80, 0x32, 0xc1, 0x10, +0x10, 0x80, 0x32, 0xc0, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x14, 0x48, 0x33, +0x2b, 0xa4, 0x14, 0x58, 0x33, 0x2d, 0x10, 0x10, 0xa4, 0x14, 0x50, 0x33, +0x2c, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x12, 0x08, 0x32, 0x1d, +0xa4, 0x12, 0x18, 0x32, 0x1f, 0x10, 0x10, 0xa4, 0x12, 0x10, 0x32, 0x1e, +0x90, 0x70, 0x90, 0x38, 0xa4, 0x13, 0x28, 0x32, 0xf5, 0xa4, 0x13, 0x38, +0x32, 0xf7, 0x10, 0x10, 0xa4, 0x13, 0x30, 0x32, 0xf6, 0x91, 0x40, 0x90, +0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x32, 0xbc, 0x80, 0x32, 0xbe, 0x10, +0x10, 0x80, 0x32, 0xbd, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x14, 0x30, 0x33, +0x28, 0xa4, 0x14, 0x40, 0x33, 0x2a, 0x10, 0x10, 0xa4, 0x14, 0x38, 0x33, +0x29, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x11, 0xf0, 0x32, 0x1a, +0xa4, 0x12, 0x00, 0x32, 0x1c, 0x10, 0x10, 0xa4, 0x11, 0xf8, 0x32, 0x1b, +0x90, 0x70, 0x90, 0x38, 0xa4, 0x13, 0x10, 0x32, 0xf2, 0xa4, 0x13, 0x20, +0x32, 0xf4, 0x10, 0x10, 0xa4, 0x13, 0x18, 0x32, 0xf3, 0x10, 0x10, 0x91, +0x40, 0x90, 0xa0, 0x90, 0x50, 0x90, 0x28, 0x80, 0x31, 0xed, 0x80, 0x31, +0xe0, 0x90, 0x28, 0x80, 0x31, 0xdf, 0x80, 0x31, 0xde, 0x90, 0x50, 0x90, +0x28, 0x80, 0x31, 0xe9, 0x80, 0x31, 0xec, 0x90, 0x28, 0x80, 0x31, 0xeb, +0x80, 0x31, 0xea, 0x90, 0xa0, 0x90, 0x50, 0x90, 0x28, 0x80, 0x31, 0xe1, +0x80, 0x31, 0xe4, 0x90, 0x28, 0x80, 0x31, 0xe3, 0x80, 0x31, 0xe2, 0x90, +0x50, 0x90, 0x28, 0x80, 0x31, 0xe5, 0x80, 0x31, 0xe8, 0x90, 0x28, 0x80, +0x31, 0xe7, 0x80, 0x31, 0xe6, 0x91, 0x88, 0x80, 0x90, 0xc0, 0x90, 0x60, +0x90, 0x28, 0x81, 0x30, 0x4a, 0x10, 0x10, 0x80, 0x30, 0x49, 0x90, 0x28, +0x81, 0x30, 0x52, 0x10, 0x10, 0x80, 0x30, 0x51, 0x90, 0x60, 0x90, 0x28, +0x81, 0x30, 0x46, 0x10, 0x10, 0x80, 0x30, 0x45, 0x90, 0x28, 0x81, 0x30, +0x4e, 0x10, 0x10, 0x80, 0x30, 0x4d, 0x80, 0x10, 0x10, 0x10, 0x10, 0x90, +0x28, 0x81, 0x30, 0x55, 0x10, 0x10, 0x80, 0x30, 0x56, 0xa0, 0x0b, 0x90, +0xa0, 0x0a, 0xc8, 0x95, 0x60, 0x92, 0xb0, 0x91, 0x40, 0x90, 0x88, 0x90, +0x50, 0x90, 0x28, 0x80, 0x32, 0xb3, 0x80, 0x32, 0xa9, 0x10, 0x10, 0x80, +0x32, 0xa8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x13, 0xe8, 0x33, 0x1f, 0xa4, +0x13, 0x98, 0x33, 0x15, 0x10, 0x10, 0xa4, 0x13, 0x90, 0x33, 0x14, 0x90, +0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x11, 0xa8, 0x32, 0x11, 0xa4, 0x11, +0x58, 0x32, 0x07, 0x10, 0x10, 0xa4, 0x11, 0x50, 0x32, 0x06, 0x90, 0x70, +0x90, 0x38, 0xa4, 0x12, 0xc8, 0x32, 0xe9, 0xa4, 0x12, 0x78, 0x32, 0xdf, +0x10, 0x10, 0xa4, 0x12, 0x70, 0x32, 0xde, 0x91, 0x40, 0x90, 0x88, 0x90, +0x50, 0x90, 0x28, 0x80, 0x32, 0xa5, 0x80, 0x32, 0xa7, 0x10, 0x10, 0x80, +0x32, 0xa6, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x13, 0x78, 0x33, 0x11, 0xa4, +0x13, 0x88, 0x33, 0x13, 0x10, 0x10, 0xa4, 0x13, 0x80, 0x33, 0x12, 0x90, +0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x11, 0x38, 0x32, 0x03, 0xa4, 0x11, +0x48, 0x32, 0x05, 0x10, 0x10, 0xa4, 0x11, 0x40, 0x32, 0x04, 0x90, 0x70, +0x90, 0x38, 0xa4, 0x12, 0x58, 0x32, 0xdb, 0xa4, 0x12, 0x68, 0x32, 0xdd, +0x10, 0x10, 0xa4, 0x12, 0x60, 0x32, 0xdc, 0x92, 0xb0, 0x91, 0x40, 0x90, +0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x32, 0xb0, 0x80, 0x32, 0xb2, 0x10, +0x10, 0x80, 0x32, 0xb1, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x13, 0xd0, 0x33, +0x1c, 0xa4, 0x13, 0xe0, 0x33, 0x1e, 0x10, 0x10, 0xa4, 0x13, 0xd8, 0x33, +0x1d, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x11, 0x90, 0x32, 0x0e, +0xa4, 0x11, 0xa0, 0x32, 0x10, 0x10, 0x10, 0xa4, 0x11, 0x98, 0x32, 0x0f, +0x90, 0x70, 0x90, 0x38, 0xa4, 0x12, 0xb0, 0x32, 0xe6, 0xa4, 0x12, 0xc0, +0x32, 0xe8, 0x10, 0x10, 0xa4, 0x12, 0xb8, 0x32, 0xe7, 0x91, 0x40, 0x90, +0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x32, 0xa2, 0x80, 0x32, 0xa4, 0x10, +0x10, 0x80, 0x32, 0xa3, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x13, 0x60, 0x33, +0x0e, 0xa4, 0x13, 0x70, 0x33, 0x10, 0x10, 0x10, 0xa4, 0x13, 0x68, 0x33, +0x0f, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x11, 0x20, 0x32, 0x00, +0xa4, 0x11, 0x30, 0x32, 0x02, 0x10, 0x10, 0xa4, 0x11, 0x28, 0x32, 0x01, +0x90, 0x70, 0x90, 0x38, 0xa4, 0x12, 0x40, 0x32, 0xd8, 0xa4, 0x12, 0x50, +0x32, 0xda, 0x10, 0x10, 0xa4, 0x12, 0x48, 0x32, 0xd9, 0x10, 0x10, 0x80, +0x10, 0x10, 0x10, 0x10, 0x90, 0x50, 0x90, 0x28, 0x80, 0x33, 0x35, 0x80, +0x33, 0x37, 0x10, 0x10, 0x80, 0x33, 0x36, 0x80, 0x95, 0x60, 0x92, 0xb0, +0x91, 0x40, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x32, 0xad, 0x80, +0x32, 0xaf, 0x10, 0x10, 0x80, 0x32, 0xae, 0x90, 0x70, 0x90, 0x38, 0xa4, +0x13, 0xb8, 0x33, 0x19, 0xa4, 0x13, 0xc8, 0x33, 0x1b, 0x10, 0x10, 0xa4, +0x13, 0xc0, 0x33, 0x1a, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x11, +0x78, 0x32, 0x0b, 0xa4, 0x11, 0x88, 0x32, 0x0d, 0x10, 0x10, 0xa4, 0x11, +0x80, 0x32, 0x0c, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x12, 0x98, 0x32, 0xe3, +0xa4, 0x12, 0xa8, 0x32, 0xe5, 0x10, 0x10, 0xa4, 0x12, 0xa0, 0x32, 0xe4, +0x91, 0x40, 0x90, 0x88, 0x90, 0x50, 0x90, 0x28, 0x80, 0x32, 0xaa, 0x80, +0x32, 0xac, 0x10, 0x10, 0x80, 0x32, 0xab, 0x90, 0x70, 0x90, 0x38, 0xa4, +0x13, 0xa0, 0x33, 0x16, 0xa4, 0x13, 0xb0, 0x33, 0x18, 0x10, 0x10, 0xa4, +0x13, 0xa8, 0x33, 0x17, 0x90, 0xb8, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x11, +0x60, 0x32, 0x08, 0xa4, 0x11, 0x70, 0x32, 0x0a, 0x10, 0x10, 0xa4, 0x11, +0x68, 0x32, 0x09, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x12, 0x80, 0x32, 0xe0, +0xa4, 0x12, 0x90, 0x32, 0xe2, 0x10, 0x10, 0xa4, 0x12, 0x88, 0x32, 0xe1, +0x10, 0x10, 0x91, 0x40, 0x90, 0xa0, 0x90, 0x50, 0x90, 0x28, 0x80, 0x31, +0xdd, 0x80, 0x31, 0xd0, 0x90, 0x28, 0x80, 0x31, 0xcf, 0x80, 0x31, 0xce, +0x90, 0x50, 0x90, 0x28, 0x80, 0x31, 0xd9, 0x80, 0x31, 0xdc, 0x90, 0x28, +0x80, 0x31, 0xdb, 0x80, 0x31, 0xda, 0x90, 0xa0, 0x90, 0x50, 0x90, 0x28, +0x80, 0x31, 0xd1, 0x80, 0x31, 0xd4, 0x90, 0x28, 0x80, 0x31, 0xd3, 0x80, +0x31, 0xd2, 0x90, 0x50, 0x90, 0x28, 0x80, 0x31, 0xd5, 0x80, 0x31, 0xd8, +0x90, 0x28, 0x80, 0x31, 0xd7, 0x80, 0x31, 0xd6, 0xc3, 0xc0, 0x30, 0xd1, +0x9c, 0xe8, 0x07, 0x60, 0x91, 0x90, 0x90, 0xf0, 0x10, 0x10, 0x80, 0x88, +0x00, 0x80, 0x90, 0x50, 0x90, 0x28, 0x80, 0x30, 0x9e, 0x80, 0x30, 0x9f, +0x81, 0x30, 0xa4, 0xd0, 0x41, 0x80, 0x24, 0x05, 0x48, 0x24, 0x05, 0x50, +0x10, 0x10, 0x80, 0x90, 0x58, 0x80, 0x90, 0x28, 0x24, 0x04, 0xe0, 0x24, +0x04, 0xe8, 0x81, 0x24, 0x05, 0x40, 0x92, 0x68, 0x91, 0x00, 0x80, 0x90, +0x90, 0x90, 0x30, 0x80, 0x24, 0x05, 0x70, 0x90, 0x38, 0xa4, 0x05, 0x80, +0x30, 0x1c, 0x80, 0x30, 0x1b, 0x80, 0x90, 0x28, 0x80, 0x31, 0xb8, 0xa4, +0x05, 0x28, 0x31, 0xb9, 0x80, 0x90, 0xc0, 0x90, 0x60, 0x90, 0x28, 0x80, +0x30, 0xc6, 0xa4, 0x05, 0x68, 0x30, 0xc7, 0x90, 0x28, 0x80, 0x30, 0x1a, +0xa4, 0x05, 0x78, 0x30, 0x19, 0x90, 0x50, 0x90, 0x28, 0x80, 0x31, 0xb6, +0x80, 0x31, 0xb7, 0x90, 0x28, 0x24, 0x05, 0x58, 0x24, 0x05, 0x60, 0x90, +0x58, 0x80, 0x10, 0x10, 0x80, 0x10, 0x10, 0x80, 0x30, 0xd0, 0x80, 0x90, +0x40, 0x10, 0x10, 0x80, 0x24, 0x05, 0x18, 0x80, 0x10, 0x10, 0x80, 0x30, +0xcf, 0x91, 0x58, 0x91, 0x00, 0x90, 0x80, 0x81, 0x90, 0x50, 0x90, 0x28, +0x80, 0x30, 0x9a, 0x80, 0x30, 0x9b, 0x81, 0x30, 0xa2, 0x81, 0x90, 0x50, +0x90, 0x28, 0x80, 0x30, 0x7d, 0x80, 0x30, 0x7e, 0x81, 0x30, 0x81, 0x83, +0x90, 0x28, 0x24, 0x04, 0xc0, 0x24, 0x04, 0xc8, 0x90, 0xe8, 0x81, 0x90, +0x88, 0x90, 0x38, 0x10, 0x10, 0x80, 0x30, 0xc5, 0x90, 0x28, 0x80, 0x30, +0x18, 0x80, 0x30, 0x17, 0x80, 0x90, 0x28, 0x80, 0x31, 0xb4, 0x80, 0x31, +0xb5, 0x82, 0x10, 0x10, 0x80, 0x24, 0x05, 0x08, 0xa0, 0x0d, 0xa8, 0x9e, +0x10, 0x06, 0x98, 0x93, 0x00, 0x91, 0x80, 0x90, 0xc0, 0x90, 0x60, 0x90, +0x38, 0xa4, 0x14, 0xb8, 0x32, 0xa1, 0x24, 0x14, 0xb0, 0x90, 0x38, 0xa4, +0x18, 0x18, 0x33, 0x0d, 0x24, 0x18, 0x10, 0x90, 0x60, 0x90, 0x38, 0xa4, +0x0f, 0xa8, 0x31, 0xff, 0x24, 0x0f, 0xa0, 0x90, 0x38, 0xa4, 0x16, 0x68, +0x32, 0xd7, 0x24, 0x16, 0x60, 0x90, 0xc0, 0x90, 0x60, 0x90, 0x38, 0xa4, +0x14, 0xa8, 0x32, 0x93, 0x24, 0x14, 0xa0, 0x90, 0x38, 0xa4, 0x18, 0x08, +0x32, 0xff, 0x24, 0x18, 0x00, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x0f, 0x98, +0x31, 0xf1, 0x24, 0x0f, 0x90, 0x90, 0x38, 0xa4, 0x16, 0x58, 0x32, 0xc9, +0x24, 0x16, 0x50, 0x91, 0x80, 0x90, 0xc0, 0x90, 0x60, 0x90, 0x38, 0xa4, +0x15, 0x00, 0x32, 0x9e, 0x24, 0x14, 0xf8, 0x90, 0x38, 0xa4, 0x18, 0x60, +0x33, 0x0a, 0x24, 0x18, 0x58, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x0f, 0xf0, +0x31, 0xfc, 0x24, 0x0f, 0xe8, 0x90, 0x38, 0xa4, 0x16, 0xb0, 0x32, 0xd4, +0x24, 0x16, 0xa8, 0x90, 0xc0, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x14, 0x90, +0x32, 0x90, 0x24, 0x14, 0x88, 0x90, 0x38, 0xa4, 0x17, 0xf0, 0x32, 0xfc, +0x24, 0x17, 0xe8, 0x90, 0x60, 0x90, 0x38, 0xa4, 0x0f, 0x80, 0x31, 0xee, +0x24, 0x0f, 0x78, 0x90, 0x38, 0xa4, 0x16, 0x40, 0x32, 0xc6, 0x24, 0x16, +0x38, 0x10, 0x10, 0x80, 0x10, 0x10, 0x10, 0x10, 0x90, 0x38, 0xa4, 0x19, +0xa0, 0x33, 0x32, 0x24, 0x19, 0x98, 0xd7, 0x1c, 0x40, 0x91, 0xc0, 0x90, +0xe0, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x3b, 0xf8, 0x37, 0x51, 0xa4, 0x3b, +0x38, 0x37, 0x6f, 0x90, 0x38, 0xa4, 0x3b, 0xd8, 0x37, 0x6b, 0xa4, 0x3b, +0xb8, 0x37, 0x73, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x3d, 0x88, 0x37, 0x83, +0xa4, 0x3c, 0xc8, 0x37, 0xa1, 0x90, 0x38, 0xa4, 0x3d, 0x68, 0x37, 0x9d, +0xa4, 0x3d, 0x48, 0x37, 0xa5, 0x90, 0xe0, 0x90, 0x70, 0x90, 0x38, 0xa4, +0x40, 0xa8, 0x37, 0xe7, 0xa4, 0x3f, 0xe8, 0x38, 0x05, 0x90, 0x38, 0xa4, +0x40, 0x88, 0x38, 0x01, 0xa4, 0x40, 0x68, 0x38, 0x09, 0x90, 0x70, 0x90, +0x38, 0xa4, 0x3f, 0x18, 0x37, 0xb5, 0xa4, 0x3e, 0x58, 0x37, 0xd3, 0x90, +0x38, 0xa4, 0x3e, 0xf8, 0x37, 0xcf, 0xa4, 0x3e, 0xd8, 0x37, 0xd7, 0x91, +0xc0, 0x90, 0xe0, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x3b, 0x00, 0x37, 0x62, +0xa4, 0x3a, 0xa0, 0x37, 0x58, 0x90, 0x38, 0xa4, 0x3a, 0xf0, 0x37, 0x56, +0xa4, 0x3a, 0xe0, 0x37, 0x5a, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x3c, 0x90, +0x37, 0x94, 0xa4, 0x3c, 0x30, 0x37, 0x8a, 0x90, 0x38, 0xa4, 0x3c, 0x80, +0x37, 0x88, 0xa4, 0x3c, 0x70, 0x37, 0x8c, 0x90, 0xe0, 0x90, 0x70, 0x90, +0x38, 0xa4, 0x3f, 0xb0, 0x37, 0xf8, 0xa4, 0x3f, 0x50, 0x37, 0xee, 0x90, +0x38, 0xa4, 0x3f, 0xa0, 0x37, 0xec, 0xa4, 0x3f, 0x90, 0x37, 0xf0, 0x90, +0x70, 0x90, 0x38, 0xa4, 0x3e, 0x20, 0x37, 0xc6, 0xa4, 0x3d, 0xc0, 0x37, +0xbc, 0x90, 0x38, 0xa4, 0x3e, 0x10, 0x37, 0xba, 0xa4, 0x3e, 0x00, 0x37, +0xbe, 0x9c, 0xe0, 0x06, 0x90, 0x93, 0x00, 0x91, 0x80, 0x90, 0xc0, 0x90, +0x60, 0x90, 0x38, 0xa4, 0x14, 0xe8, 0x32, 0x9b, 0x24, 0x14, 0xe0, 0x90, +0x38, 0xa4, 0x18, 0x48, 0x33, 0x07, 0x24, 0x18, 0x40, 0x90, 0x60, 0x90, +0x38, 0xa4, 0x0f, 0xd8, 0x31, 0xf9, 0x24, 0x0f, 0xd0, 0x90, 0x38, 0xa4, +0x16, 0x98, 0x32, 0xd1, 0x24, 0x16, 0x90, 0x90, 0xc0, 0x90, 0x60, 0x90, +0x38, 0xa4, 0x14, 0xd0, 0x32, 0x98, 0x24, 0x14, 0xc8, 0x90, 0x38, 0xa4, +0x18, 0x30, 0x33, 0x04, 0x24, 0x18, 0x28, 0x90, 0x60, 0x90, 0x38, 0xa4, +0x0f, 0xc0, 0x31, 0xf6, 0x24, 0x0f, 0xb8, 0x90, 0x38, 0xa4, 0x16, 0x80, +0x32, 0xce, 0x24, 0x16, 0x78, 0x10, 0x10, 0x90, 0xe0, 0x90, 0x70, 0x90, +0x38, 0xa4, 0x0e, 0x00, 0x31, 0xcd, 0xa4, 0x0d, 0xf0, 0x31, 0xbf, 0x90, +0x38, 0xa4, 0x0e, 0x60, 0x31, 0xc9, 0xa4, 0x0e, 0x50, 0x31, 0xcb, 0x90, +0x70, 0x90, 0x38, 0xa4, 0x0e, 0x20, 0x31, 0xc1, 0xa4, 0x0e, 0x10, 0x31, +0xc3, 0x90, 0x38, 0xa4, 0x0e, 0x40, 0x31, 0xc5, 0xa4, 0x0e, 0x30, 0x31, +0xc7, 0x91, 0x48, 0x80, 0x90, 0xa0, 0x90, 0x50, 0x90, 0x28, 0x80, 0x30, +0x48, 0x24, 0x02, 0x38, 0x90, 0x28, 0x80, 0x30, 0x50, 0x24, 0x02, 0x78, +0x90, 0x50, 0x90, 0x28, 0x80, 0x30, 0x44, 0x24, 0x02, 0x18, 0x90, 0x28, +0x80, 0x30, 0x4c, 0x24, 0x02, 0x58, 0x80, 0x10, 0x10, 0x10, 0x10, 0x90, +0x28, 0x80, 0x30, 0x53, 0x24, 0x02, 0xa0, 0xd7, 0x1c, 0x40, 0x91, 0xc0, +0x90, 0xe0, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x3c, 0x08, 0x37, 0x64, 0xa4, +0x3b, 0x48, 0x37, 0x71, 0x90, 0x38, 0xa4, 0x3b, 0xe8, 0x37, 0x6d, 0xa4, +0x3b, 0xc8, 0x37, 0x75, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x3d, 0x98, 0x37, +0x96, 0xa4, 0x3c, 0xd8, 0x37, 0xa3, 0x90, 0x38, 0xa4, 0x3d, 0x78, 0x37, +0x9f, 0xa4, 0x3d, 0x58, 0x37, 0xa7, 0x90, 0xe0, 0x90, 0x70, 0x90, 0x38, +0xa4, 0x40, 0xb8, 0x37, 0xfa, 0xa4, 0x3f, 0xf8, 0x38, 0x07, 0x90, 0x38, +0xa4, 0x40, 0x98, 0x38, 0x03, 0xa4, 0x40, 0x78, 0x38, 0x0b, 0x90, 0x70, +0x90, 0x38, 0xa4, 0x3f, 0x28, 0x37, 0xc8, 0xa4, 0x3e, 0x68, 0x37, 0xd5, +0x90, 0x38, 0xa4, 0x3f, 0x08, 0x37, 0xd1, 0xa4, 0x3e, 0xe8, 0x37, 0xd9, +0x91, 0xc0, 0x90, 0xe0, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x3b, 0x08, 0x37, +0x63, 0xa4, 0x3a, 0xa8, 0x37, 0x59, 0x90, 0x38, 0xa4, 0x3a, 0xf8, 0x37, +0x57, 0xa4, 0x3a, 0xe8, 0x37, 0x5b, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x3c, +0x98, 0x37, 0x95, 0xa4, 0x3c, 0x38, 0x37, 0x8b, 0x90, 0x38, 0xa4, 0x3c, +0x88, 0x37, 0x89, 0xa4, 0x3c, 0x78, 0x37, 0x8d, 0x90, 0xe0, 0x90, 0x70, +0x90, 0x38, 0xa4, 0x3f, 0xb8, 0x37, 0xf9, 0xa4, 0x3f, 0x58, 0x37, 0xef, +0x90, 0x38, 0xa4, 0x3f, 0xa8, 0x37, 0xed, 0xa4, 0x3f, 0x98, 0x37, 0xf1, +0x90, 0x70, 0x90, 0x38, 0xa4, 0x3e, 0x28, 0x37, 0xc7, 0xa4, 0x3d, 0xc8, +0x37, 0xbd, 0x90, 0x38, 0xa4, 0x3e, 0x18, 0x37, 0xbb, 0xa4, 0x3e, 0x08, +0x37, 0xbf, 0xa0, 0x14, 0x90, 0xa0, 0x10, 0xb8, 0xa0, 0x0c, 0x88, 0x9e, +0x88, 0x09, 0xd0, 0x94, 0xf0, 0x90, 0xb0, 0x88, 0x00, 0x68, 0x84, 0x10, +0x10, 0xc9, 0xe1, 0xa0, 0x00, 0x85, 0x35, 0xb3, 0xcb, 0x61, 0x65, 0x00, +0x85, 0x35, 0x7b, 0x9a, 0x00, 0x03, 0xf8, 0x91, 0x98, 0x80, 0x91, 0x10, +0x90, 0xa0, 0x90, 0x68, 0x90, 0x20, 0x30, 0xc4, 0xc9, 0xe1, 0x9d, 0x00, +0x85, 0x35, 0xb1, 0xa4, 0x06, 0x18, 0x30, 0xc2, 0x90, 0x38, 0xa4, 0x04, +0xa8, 0x30, 0x96, 0xa4, 0x04, 0xa0, 0x30, 0x93, 0x90, 0x48, 0x10, 0x10, +0xa4, 0x05, 0xd8, 0x30, 0xbc, 0x10, 0x10, 0x80, 0x30, 0xb8, 0x81, 0x10, +0x10, 0x80, 0xa4, 0x05, 0xa8, 0x30, 0xb6, 0x91, 0xb0, 0x91, 0x60, 0x90, +0xe0, 0x90, 0x70, 0x90, 0x38, 0xa4, 0x06, 0x00, 0x30, 0xc1, 0xa4, 0x05, +0xf8, 0x30, 0xbe, 0x90, 0x38, 0xa4, 0x04, 0x88, 0x30, 0x92, 0xa4, 0x04, +0x80, 0x30, 0x8f, 0x90, 0x48, 0x10, 0x10, 0xa4, 0x05, 0xc8, 0x30, 0xba, +0x10, 0x10, 0x80, 0x30, 0xb7, 0x90, 0x28, 0x80, 0x30, 0xa0, 0x80, 0x30, +0x97, 0x81, 0x10, 0x10, 0x80, 0xa4, 0x05, 0x98, 0x30, 0xb4, 0xcb, 0x61, +0x64, 0xc0, 0x85, 0x35, 0x70, 0x90, 0xd8, 0x88, 0x00, 0x90, 0x84, 0x90, +0x38, 0xc1, 0xc0, 0x85, 0x31, 0xb3, 0xc9, 0xe1, 0x9c, 0xc0, 0x85, 0x35, +0xaf, 0xcb, 0x61, 0x64, 0x80, 0x85, 0x35, 0x6f, 0x88, 0x00, 0x68, 0x84, +0x10, 0x10, 0xc9, 0xe1, 0x9c, 0x80, 0x85, 0x35, 0xad, 0xcb, 0x61, 0x64, +0x40, 0x85, 0x35, 0x6e, 0x91, 0xf8, 0x90, 0xb0, 0x88, 0x00, 0x68, 0x84, +0x10, 0x10, 0xc9, 0xe1, 0x9e, 0x40, 0x85, 0x35, 0xbd, 0xcb, 0x61, 0x65, +0x80, 0x85, 0x35, 0x74, 0x88, 0x01, 0x00, 0x90, 0xa0, 0x81, 0x90, 0x70, +0x80, 0x90, 0x20, 0x30, 0xbd, 0xc9, 0xe1, 0x9e, 0x00, 0x85, 0x35, 0xbb, +0x81, 0x30, 0x8e, 0x81, 0x10, 0x10, 0x80, 0xa4, 0x05, 0x88, 0x30, 0xb2, +0xcb, 0x61, 0x66, 0x80, 0x85, 0x35, 0x73, 0x90, 0xb0, 0x88, 0x00, 0x68, +0x84, 0x10, 0x10, 0xc9, 0xe1, 0x9d, 0xc0, 0x85, 0x35, 0xb9, 0xcb, 0x61, +0x66, 0x40, 0x85, 0x35, 0x72, 0x88, 0x00, 0x68, 0x84, 0x10, 0x10, 0xc9, +0xe1, 0x9d, 0x80, 0x85, 0x35, 0xb7, 0xcb, 0x61, 0x66, 0x00, 0x85, 0x35, +0x71, 0x92, 0x38, 0x81, 0x91, 0x68, 0x91, 0x18, 0x90, 0x80, 0x90, 0x40, +0x80, 0xa4, 0x54, 0xc8, 0x3a, 0x9a, 0x80, 0xa4, 0x02, 0x10, 0x30, 0x41, +0x90, 0x28, 0x81, 0x3a, 0x97, 0x90, 0x38, 0xa4, 0x54, 0x88, 0x3a, 0x93, +0xa4, 0x00, 0x10, 0x30, 0xc9, 0x90, 0x28, 0x80, 0x30, 0x80, 0x80, 0x30, +0x7f, 0x80, 0x90, 0x40, 0x10, 0x10, 0x80, 0x24, 0x02, 0x00, 0x10, 0x10, +0x90, 0x38, 0xa4, 0x54, 0x80, 0x3a, 0x92, 0xa4, 0x00, 0x08, 0x30, 0xc8, +0x90, 0x50, 0x80, 0xc9, 0xa2, 0xa5, 0x40, 0x85, 0x31, 0xb2, 0x80, 0x3a, +0x96, 0x9a, 0xd0, 0x03, 0xe0, 0x91, 0x60, 0x90, 0xb0, 0x88, 0x00, 0x68, +0x84, 0x10, 0x10, 0xc9, 0xe1, 0x9f, 0x80, 0x85, 0x35, 0xc7, 0xcb, 0x61, +0x67, 0x80, 0x85, 0x35, 0x79, 0x88, 0x00, 0x68, 0x84, 0x10, 0x10, 0xc9, +0xe1, 0x9f, 0x40, 0x85, 0x35, 0xc5, 0xcb, 0x61, 0x67, 0x40, 0x85, 0x35, +0x78, 0x90, 0xb0, 0x88, 0x00, 0x68, 0x84, 0x10, 0x10, 0xc9, 0xe1, 0x9f, +0x00, 0x85, 0x35, 0xc3, 0xcb, 0x61, 0x67, 0x00, 0x85, 0x35, 0x77, 0x88, +0x00, 0x68, 0x84, 0x10, 0x10, 0xc9, 0xe1, 0x9e, 0xc0, 0x85, 0x35, 0xc1, +0xcb, 0x61, 0x66, 0xc0, 0x85, 0x35, 0x76, 0x90, 0x90, 0x90, 0x48, 0xcb, +0xa1, 0x3b, 0x40, 0x85, 0x34, 0xd8, 0xcb, 0xa1, 0x3b, 0x00, 0x85, 0x34, +0xd7, 0x90, 0x48, 0xcb, 0xa1, 0x3a, 0xc0, 0x85, 0x34, 0xd6, 0xcb, 0xa1, +0x3a, 0x80, 0x85, 0x34, 0xd5, 0xcb, 0xa2, 0xa6, 0x00, 0x80, 0x31, 0xb1, +0x92, 0x40, 0x91, 0x20, 0x90, 0x90, 0x90, 0x48, 0x8c, 0x2b, 0x10, 0x84, +0x24, 0x25, 0x48, 0x8c, 0x2b, 0x08, 0x84, 0x24, 0x24, 0xf0, 0x90, 0x48, +0x8c, 0x2b, 0x00, 0x84, 0x24, 0x24, 0xe8, 0x8c, 0x2a, 0xf8, 0x84, 0x24, +0x24, 0xe0, 0x90, 0x90, 0x90, 0x48, 0x8c, 0x2b, 0x38, 0x84, 0x24, 0x25, +0x10, 0x8c, 0x2b, 0x30, 0x84, 0x24, 0x25, 0x08, 0x90, 0x48, 0x8c, 0x2b, +0x28, 0x84, 0x24, 0x25, 0x00, 0x8c, 0x2b, 0x20, 0x84, 0x24, 0x24, 0xf8, +0x91, 0x20, 0x90, 0x90, 0x90, 0x48, 0x8c, 0x2b, 0x60, 0x84, 0x24, 0x25, +0x38, 0x8c, 0x2b, 0x58, 0x84, 0x24, 0x25, 0x30, 0x90, 0x48, 0x8c, 0x2b, +0x50, 0x84, 0x24, 0x25, 0x28, 0x8c, 0x2b, 0x48, 0x84, 0x24, 0x25, 0x20, +0x90, 0x38, 0xa4, 0x26, 0x90, 0x34, 0xd3, 0xa4, 0x26, 0x80, 0x34, 0xd1, +0xa0, 0x0f, 0x50, 0xa0, 0x09, 0x08, 0x9a, 0x30, 0x04, 0x40, 0x91, 0x90, +0x90, 0xc8, 0x98, 0x50, 0x00, 0x80, 0xe5, 0x21, 0xce, 0x00, 0x37, 0x34, +0xe5, 0x21, 0xca, 0x80, 0x37, 0x44, 0xcb, 0x61, 0x54, 0x80, 0x85, 0x35, +0x4d, 0x98, 0x50, 0x00, 0x80, 0xe5, 0x21, 0xbb, 0x00, 0x36, 0xe8, 0xe5, +0x21, 0xb7, 0x80, 0x36, 0xf8, 0xcb, 0x61, 0x54, 0x40, 0x85, 0x35, 0x42, +0x90, 0x48, 0xcb, 0xa1, 0x54, 0x00, 0x85, 0x35, 0x41, 0xcb, 0xa1, 0x53, +0xc0, 0x85, 0x35, 0x40, 0x91, 0x90, 0x90, 0xc8, 0x98, 0x50, 0x00, 0x80, +0xe5, 0x21, 0xc6, 0x00, 0x37, 0x1e, 0xe5, 0x21, 0xc4, 0x80, 0x37, 0x24, +0xcb, 0x61, 0x55, 0xc0, 0x85, 0x35, 0x46, 0x98, 0x50, 0x00, 0x80, 0xe5, +0x21, 0xb3, 0x00, 0x36, 0xd2, 0xe5, 0x21, 0xb1, 0x80, 0x36, 0xd8, 0xcb, +0x61, 0x55, 0x80, 0x85, 0x35, 0x45, 0x90, 0x48, 0xcb, 0xa1, 0x55, 0x40, +0x85, 0x35, 0x44, 0xcb, 0xa1, 0x55, 0x00, 0x85, 0x35, 0x43, 0x92, 0x20, +0x91, 0x30, 0x90, 0xb8, 0xd5, 0x03, 0x00, 0xc0, 0xc0, 0x81, 0x8c, 0x48, +0xa8, 0x84, 0x39, 0x45, 0xc0, 0xc0, 0x81, 0x8c, 0x48, 0x88, 0x84, 0x39, +0x41, 0xd5, 0x02, 0x00, 0xc0, 0xc0, 0x81, 0x39, 0x21, 0xc0, 0xc0, 0x81, +0x39, 0x1d, 0x90, 0x78, 0xd5, 0x02, 0x00, 0xc0, 0xc0, 0x81, 0x39, 0x2d, +0xc0, 0xc0, 0x81, 0x39, 0x29, 0xd5, 0x02, 0x00, 0xc0, 0xc0, 0x81, 0x39, +0x39, 0xc0, 0xc0, 0x81, 0x39, 0x35, 0x91, 0x70, 0x90, 0xd8, 0xd5, 0x03, +0x80, 0xc8, 0xe1, 0xbf, 0x80, 0x81, 0x8c, 0x48, 0xc8, 0x84, 0x39, 0x43, +0xc8, 0xe1, 0xc0, 0x80, 0x81, 0x8c, 0x48, 0x98, 0x84, 0x39, 0x42, 0xd5, +0x02, 0x80, 0xc8, 0xe1, 0xc3, 0x00, 0x81, 0x39, 0x25, 0xc8, 0xe1, 0xbf, +0x00, 0x81, 0x39, 0x1f, 0x90, 0x98, 0xd5, 0x02, 0x80, 0xc8, 0xe1, 0xac, +0x80, 0x81, 0x39, 0x31, 0xc8, 0xe1, 0xad, 0x80, 0x81, 0x39, 0x2b, 0xd5, +0x02, 0x80, 0xc8, 0xe1, 0xb0, 0x00, 0x81, 0x39, 0x3d, 0xc8, 0xe1, 0xac, +0x00, 0x81, 0x39, 0x37, 0x9a, 0x30, 0x04, 0x40, 0x91, 0x90, 0x90, 0xc8, +0x98, 0x50, 0x00, 0x80, 0xe5, 0x21, 0xcc, 0x00, 0x37, 0x2c, 0xe5, 0x21, +0xc9, 0x80, 0x37, 0x40, 0xcb, 0x61, 0x57, 0x00, 0x85, 0x35, 0x4b, 0x98, +0x50, 0x00, 0x80, 0xe5, 0x21, 0xb9, 0x00, 0x36, 0xe0, 0xe5, 0x21, 0xb6, +0x80, 0x36, 0xf4, 0xcb, 0x61, 0x56, 0xc0, 0x85, 0x35, 0x4a, 0x90, 0x48, +0xcb, 0xa1, 0x56, 0x80, 0x85, 0x35, 0x49, 0xcb, 0xa1, 0x56, 0x40, 0x85, +0x35, 0x48, 0x91, 0x90, 0x90, 0xc8, 0x98, 0x50, 0x00, 0x80, 0xe5, 0x21, +0xc5, 0x00, 0x37, 0x1a, 0xe5, 0x21, 0xc3, 0x80, 0x37, 0x20, 0xcb, 0x61, +0x33, 0x40, 0x85, 0x34, 0xc8, 0x98, 0x50, 0x00, 0x80, 0xe5, 0x21, 0xb2, +0x00, 0x36, 0xce, 0xe5, 0x21, 0xb0, 0x80, 0x36, 0xd4, 0xcb, 0x61, 0x33, +0x00, 0x85, 0x34, 0xc7, 0x90, 0x48, 0xcb, 0xa1, 0x32, 0xc0, 0x85, 0x34, +0xc6, 0xcb, 0xa1, 0x32, 0x80, 0x85, 0x34, 0xc5, 0x91, 0x00, 0x90, 0x80, +0x90, 0x40, 0xe5, 0x22, 0x38, 0x40, 0x38, 0xe7, 0xe5, 0x22, 0x3b, 0xc0, +0x38, 0xf3, 0x90, 0x40, 0xe5, 0x22, 0x3e, 0x40, 0x38, 0xff, 0xe5, 0x22, +0x41, 0xc0, 0x39, 0x0b, 0x90, 0x80, 0x90, 0x40, 0xe5, 0x22, 0x38, 0x80, +0x38, 0xe9, 0xe5, 0x22, 0x3c, 0x00, 0x38, 0xf5, 0x90, 0x40, 0xe5, 0x22, +0x3e, 0x80, 0x39, 0x01, 0xe5, 0x22, 0x42, 0x00, 0x39, 0x0d, 0x80, 0x99, +0x28, 0x02, 0xf0, 0x8c, 0x25, 0x80, 0x90, 0x80, 0x90, 0x40, 0xe5, 0x21, +0xcf, 0x80, 0x37, 0x3c, 0xe5, 0x21, 0xca, 0x00, 0x37, 0x42, 0x90, 0x40, +0xe5, 0x21, 0xbc, 0x80, 0x36, 0xf0, 0xe5, 0x21, 0xb7, 0x00, 0x36, 0xf6, +0x91, 0x48, 0x90, 0xc8, 0x98, 0x50, 0x00, 0x80, 0xe5, 0x21, 0xc5, 0x80, +0x37, 0x1c, 0xe5, 0x21, 0xc4, 0x00, 0x37, 0x22, 0xcb, 0x60, 0x01, 0xc0, +0x85, 0x30, 0x03, 0x90, 0x40, 0xe5, 0x21, 0xb2, 0x80, 0x36, 0xd0, 0xe5, +0x21, 0xb1, 0x00, 0x36, 0xd6, 0x90, 0x48, 0xcb, 0xa0, 0x02, 0x40, 0x85, +0x30, 0x05, 0xcb, 0xa0, 0x02, 0x80, 0x85, 0x30, 0x06, 0x10, 0x10, 0x90, +0x80, 0x90, 0x40, 0xe5, 0x21, 0xc2, 0x00, 0x37, 0x06, 0xe5, 0x21, 0xbe, +0x80, 0x37, 0x0a, 0x90, 0x40, 0xe5, 0x21, 0xaf, 0x00, 0x36, 0xba, 0xe5, +0x21, 0xab, 0x80, 0x36, 0xbe, +}; + +static const struct ia64_dis_names ia64_dis_names[] = { +{ 0x1, 391, 0 }, +{ 0x1, 389, 0 }, +{ 0x1, 388, 0 }, +{ 0x4, 387, 1 }, +{ 0x8, 387, 0 }, +{ 0x2, 387, 0 }, +{ 0x1, 387, 0 }, +{ 0x4, 385, 1 }, +{ 0x1, 386, 0 }, +{ 0x2, 385, 0 }, +{ 0x1, 385, 0 }, +{ 0x4, 384, 0 }, +{ 0x2, 384, 0 }, +{ 0x1, 384, 0 }, +{ 0x4, 383, 0 }, +{ 0x2, 383, 0 }, +{ 0x1, 383, 0 }, +{ 0x4, 382, 0 }, +{ 0x2, 382, 0 }, +{ 0x1, 382, 0 }, +{ 0x4, 381, 0 }, +{ 0x2, 381, 0 }, +{ 0x1, 381, 0 }, +{ 0x2, 380, 0 }, +{ 0x1, 380, 0 }, +{ 0x2, 379, 0 }, +{ 0x1, 379, 0 }, +{ 0x2, 378, 0 }, +{ 0x1, 378, 0 }, +{ 0x1, 376, 0 }, +{ 0x2, 374, 1 }, +{ 0x1, 375, 0 }, +{ 0x12, 374, 1 }, +{ 0x11, 375, 0 }, +{ 0xa, 374, 1 }, +{ 0x9, 375, 0 }, +{ 0x1a, 374, 1 }, +{ 0x7, 375, 0 }, +{ 0x6, 374, 1 }, +{ 0x5, 375, 0 }, +{ 0x5, 374, 1 }, +{ 0x12, 375, 0 }, +{ 0xd, 374, 1 }, +{ 0xe, 375, 0 }, +{ 0x3, 374, 1 }, +{ 0xa, 375, 0 }, +{ 0x2, 371, 1 }, +{ 0x1, 372, 0 }, +{ 0x12, 371, 1 }, +{ 0x11, 372, 0 }, +{ 0xa, 371, 1 }, +{ 0x9, 372, 0 }, +{ 0x1a, 371, 1 }, +{ 0x7, 372, 0 }, +{ 0x6, 371, 1 }, +{ 0x5, 372, 0 }, +{ 0x5, 371, 1 }, +{ 0x12, 372, 0 }, +{ 0xd, 371, 1 }, +{ 0xe, 372, 0 }, +{ 0x3, 371, 1 }, +{ 0xa, 372, 0 }, +{ 0x1, 370, 0 }, +{ 0x1, 365, 0 }, +{ 0x1, 364, 0 }, +{ 0x1, 363, 0 }, +{ 0x1, 362, 0 }, +{ 0x2, 361, 0 }, +{ 0x1, 361, 0 }, +{ 0x2, 360, 0 }, +{ 0x1, 360, 0 }, +{ 0x2, 359, 0 }, +{ 0x1, 359, 0 }, +{ 0x2, 358, 0 }, +{ 0x1, 358, 0 }, +{ 0x2, 357, 0 }, +{ 0x1, 357, 0 }, +{ 0x2, 356, 0 }, +{ 0x1, 356, 0 }, +{ 0x2, 355, 0 }, +{ 0x1, 355, 0 }, +{ 0x2, 354, 0 }, +{ 0x1, 354, 0 }, +{ 0x1, 353, 0 }, +{ 0x3, 353, 0 }, +{ 0x1, 352, 0 }, +{ 0x3, 352, 0 }, +{ 0x8, 351, 0 }, +{ 0x18, 351, 0 }, +{ 0x4, 351, 0 }, +{ 0xc, 351, 0 }, +{ 0x2, 351, 0 }, +{ 0x1, 351, 0 }, +{ 0x8, 350, 0 }, +{ 0x18, 350, 0 }, +{ 0x4, 350, 0 }, +{ 0xc, 350, 0 }, +{ 0x2, 350, 0 }, +{ 0x1, 350, 0 }, +{ 0x4, 349, 0 }, +{ 0xc, 349, 0 }, +{ 0x2, 349, 0 }, +{ 0x1, 349, 0 }, +{ 0x4, 348, 0 }, +{ 0xc, 348, 0 }, +{ 0x2, 348, 0 }, +{ 0x1, 348, 0 }, +{ 0x4, 347, 0 }, +{ 0xc, 347, 0 }, +{ 0x2, 347, 0 }, +{ 0x1, 347, 0 }, +{ 0x4, 346, 0 }, +{ 0xc, 346, 0 }, +{ 0x2, 346, 0 }, +{ 0x1, 346, 0 }, +{ 0x4, 345, 0 }, +{ 0xc, 345, 0 }, +{ 0x2, 345, 0 }, +{ 0x1, 345, 0 }, +{ 0x4, 344, 0 }, +{ 0xc, 344, 0 }, +{ 0x2, 344, 0 }, +{ 0x1, 344, 0 }, +{ 0x1, 343, 0 }, +{ 0x1, 341, 0 }, +{ 0x2, 340, 0 }, +{ 0x1, 340, 0 }, +{ 0x1, 338, 0 }, +{ 0x1, 337, 0 }, +{ 0x1, 336, 0 }, +{ 0x8, 334, 0 }, +{ 0x4, 334, 0 }, +{ 0x2, 334, 0 }, +{ 0x1, 334, 0 }, +{ 0x1, 333, 0 }, +{ 0x1, 332, 0 }, +{ 0x1, 331, 0 }, +{ 0x2, 330, 0 }, +{ 0x1, 330, 0 }, +{ 0x2, 328, 0 }, +{ 0x1, 328, 0 }, +{ 0x1, 327, 0 }, +{ 0x1, 326, 0 }, +{ 0x8, 325, 0 }, +{ 0x4, 325, 0 }, +{ 0x2, 325, 0 }, +{ 0x1, 325, 0 }, +{ 0x8, 324, 0 }, +{ 0x4, 324, 0 }, +{ 0x2, 324, 0 }, +{ 0x1, 324, 0 }, +{ 0x1, 323, 0 }, +{ 0x2, 322, 0 }, +{ 0x1, 322, 0 }, +{ 0x2, 321, 0 }, +{ 0x1, 321, 0 }, +{ 0x2, 320, 0 }, +{ 0x1, 320, 0 }, +{ 0x2, 319, 0 }, +{ 0x1, 319, 0 }, +{ 0x1, 318, 0 }, +{ 0x1, 317, 0 }, +{ 0x1, 316, 0 }, +{ 0x1, 315, 0 }, +{ 0x1, 314, 0 }, +{ 0x1, 313, 0 }, +{ 0x2, 310, 0 }, +{ 0x1, 310, 0 }, +{ 0x1, 309, 0 }, +{ 0x2, 308, 0 }, +{ 0x1, 308, 0 }, +{ 0x2, 307, 0 }, +{ 0x1, 307, 0 }, +{ 0x1, 306, 0 }, +{ 0x1, 305, 0 }, +{ 0x1, 304, 0 }, +{ 0x1, 303, 0 }, +{ 0x2, 302, 0 }, +{ 0x1, 302, 0 }, +{ 0x2, 301, 0 }, +{ 0x1, 301, 0 }, +{ 0x2, 300, 0 }, +{ 0x1, 300, 0 }, +{ 0x1, 299, 0 }, +{ 0x1, 298, 0 }, +{ 0x2, 297, 0 }, +{ 0x1, 297, 0 }, +{ 0x2, 296, 0 }, +{ 0x1, 296, 0 }, +{ 0x1, 295, 0 }, +{ 0x8, 294, 0 }, +{ 0x4, 294, 0 }, +{ 0x2, 294, 0 }, +{ 0x1, 294, 0 }, +{ 0x8, 293, 0 }, +{ 0x4, 293, 0 }, +{ 0x1, 293, 0 }, +{ 0x1, 292, 0 }, +{ 0x2, 291, 0 }, +{ 0x1, 291, 0 }, +{ 0x1, 290, 0 }, +{ 0x1, 289, 0 }, +{ 0x1, 285, 1 }, +{ 0x1, 286, 1 }, +{ 0x1, 287, 0 }, +{ 0x1, 284, 0 }, +{ 0x1, 283, 0 }, +{ 0x1, 282, 0 }, +{ 0x1, 281, 0 }, +{ 0x1, 280, 0 }, +{ 0x1, 272, 0 }, +{ 0x1, 271, 0 }, +{ 0x1, 270, 0 }, +{ 0x1, 269, 0 }, +{ 0x1, 268, 0 }, +{ 0x1, 267, 0 }, +{ 0x1, 266, 0 }, +{ 0x1, 265, 0 }, +{ 0x1, 264, 0 }, +{ 0x1, 263, 0 }, +{ 0x1, 262, 0 }, +{ 0x1, 261, 0 }, +{ 0x1, 260, 0 }, +{ 0x1, 259, 0 }, +{ 0x1, 258, 0 }, +{ 0x1, 257, 0 }, +{ 0x1, 256, 0 }, +{ 0x1, 255, 0 }, +{ 0x1, 254, 0 }, +{ 0x1, 253, 0 }, +{ 0x1, 252, 0 }, +{ 0x1, 250, 0 }, +{ 0x1, 249, 1 }, +{ 0x1, 369, 0 }, +{ 0x1, 248, 1 }, +{ 0x1, 342, 0 }, +{ 0x1, 247, 0 }, +{ 0x1, 246, 0 }, +{ 0x1, 245, 1 }, +{ 0x2, 342, 0 }, +{ 0x1250, 244, 0 }, +{ 0x3250, 244, 0 }, +{ 0xa50, 244, 0 }, +{ 0x1a50, 244, 0 }, +{ 0x650, 244, 0 }, +{ 0xe50, 244, 0 }, +{ 0x950, 244, 0 }, +{ 0x1950, 244, 0 }, +{ 0x550, 244, 0 }, +{ 0xd50, 244, 0 }, +{ 0x350, 244, 0 }, +{ 0x750, 244, 0 }, +{ 0x2d0, 244, 0 }, +{ 0x6d0, 244, 0 }, +{ 0x1d0, 244, 0 }, +{ 0x3d0, 244, 0 }, +{ 0x930, 244, 0 }, +{ 0x1930, 244, 0 }, +{ 0x530, 244, 0 }, +{ 0xd30, 244, 0 }, +{ 0x330, 244, 0 }, +{ 0x730, 244, 0 }, +{ 0x4b0, 244, 0 }, +{ 0xcb0, 244, 0 }, +{ 0x2b0, 244, 0 }, +{ 0x6b0, 244, 0 }, +{ 0x1b0, 244, 0 }, +{ 0x3b0, 244, 0 }, +{ 0x170, 244, 0 }, +{ 0x370, 244, 0 }, +{ 0xf0, 244, 0 }, +{ 0x1f0, 244, 0 }, +{ 0x9288, 244, 0 }, +{ 0x19288, 244, 0 }, +{ 0x5288, 244, 0 }, +{ 0xd288, 244, 0 }, +{ 0x3288, 244, 0 }, +{ 0x7288, 244, 0 }, +{ 0x4a88, 244, 0 }, +{ 0xca88, 244, 0 }, +{ 0x2a88, 244, 0 }, +{ 0x6a88, 244, 0 }, +{ 0x1a88, 244, 0 }, +{ 0x3a88, 244, 0 }, +{ 0x1688, 244, 0 }, +{ 0x3688, 244, 0 }, +{ 0xe88, 244, 0 }, +{ 0x1e88, 244, 0 }, +{ 0x4988, 244, 0 }, +{ 0xc988, 244, 0 }, +{ 0x2988, 244, 0 }, +{ 0x6988, 244, 0 }, +{ 0x1988, 244, 0 }, +{ 0x3988, 244, 0 }, +{ 0x2588, 244, 0 }, +{ 0x6588, 244, 0 }, +{ 0x1588, 244, 0 }, +{ 0x3588, 244, 0 }, +{ 0xd88, 244, 0 }, +{ 0x1d88, 244, 0 }, +{ 0xb88, 244, 0 }, +{ 0x1b88, 244, 0 }, +{ 0x788, 244, 0 }, +{ 0xf88, 244, 0 }, +{ 0x1248, 244, 0 }, +{ 0x3248, 244, 0 }, +{ 0xa48, 244, 0 }, +{ 0x1a48, 244, 0 }, +{ 0x648, 244, 0 }, +{ 0xe48, 244, 0 }, +{ 0x948, 244, 0 }, +{ 0x1948, 244, 0 }, +{ 0x548, 244, 0 }, +{ 0xd48, 244, 0 }, +{ 0x348, 244, 0 }, +{ 0x748, 244, 0 }, +{ 0x2c8, 244, 0 }, +{ 0x6c8, 244, 0 }, +{ 0x1c8, 244, 0 }, +{ 0x3c8, 244, 0 }, +{ 0x928, 244, 0 }, +{ 0x1928, 244, 0 }, +{ 0x528, 244, 0 }, +{ 0xd28, 244, 0 }, +{ 0x328, 244, 0 }, +{ 0x728, 244, 0 }, +{ 0x4a8, 244, 0 }, +{ 0xca8, 244, 0 }, +{ 0x2a8, 244, 0 }, +{ 0x6a8, 244, 0 }, +{ 0x1a8, 244, 0 }, +{ 0x3a8, 244, 0 }, +{ 0x168, 244, 0 }, +{ 0x368, 244, 0 }, +{ 0xe8, 244, 0 }, +{ 0x1e8, 244, 0 }, +{ 0x1258, 244, 0 }, +{ 0x3258, 244, 0 }, +{ 0xa58, 244, 0 }, +{ 0x1a58, 244, 0 }, +{ 0x658, 244, 0 }, +{ 0xe58, 244, 0 }, +{ 0x958, 244, 0 }, +{ 0x1958, 244, 0 }, +{ 0x558, 244, 0 }, +{ 0xd58, 244, 0 }, +{ 0x358, 244, 0 }, +{ 0x758, 244, 0 }, +{ 0x2d8, 244, 0 }, +{ 0x6d8, 244, 0 }, +{ 0x1d8, 244, 0 }, +{ 0x3d8, 244, 0 }, +{ 0x938, 244, 0 }, +{ 0x1938, 244, 0 }, +{ 0x538, 244, 0 }, +{ 0xd38, 244, 0 }, +{ 0x338, 244, 0 }, +{ 0x738, 244, 0 }, +{ 0x4b8, 244, 0 }, +{ 0xcb8, 244, 0 }, +{ 0x2b8, 244, 0 }, +{ 0x6b8, 244, 0 }, +{ 0x1b8, 244, 0 }, +{ 0x3b8, 244, 0 }, +{ 0x178, 244, 0 }, +{ 0x378, 244, 0 }, +{ 0xf8, 244, 0 }, +{ 0x1f8, 244, 0 }, +{ 0x124, 244, 0 }, +{ 0x324, 244, 0 }, +{ 0xa4, 244, 0 }, +{ 0x1a4, 244, 0 }, +{ 0x64, 244, 0 }, +{ 0xe4, 244, 0 }, +{ 0x94, 244, 0 }, +{ 0x194, 244, 0 }, +{ 0x54, 244, 0 }, +{ 0xd4, 244, 0 }, +{ 0x34, 244, 0 }, +{ 0x74, 244, 0 }, +{ 0x2c, 244, 0 }, +{ 0x6c, 244, 0 }, +{ 0x1c, 244, 0 }, +{ 0x3c, 244, 0 }, +{ 0x92, 244, 0 }, +{ 0x192, 244, 0 }, +{ 0x52, 244, 0 }, +{ 0xd2, 244, 0 }, +{ 0x32, 244, 0 }, +{ 0x72, 244, 0 }, +{ 0x4a, 244, 0 }, +{ 0xca, 244, 0 }, +{ 0x2a, 244, 0 }, +{ 0x6a, 244, 0 }, +{ 0x1a, 244, 0 }, +{ 0x3a, 244, 0 }, +{ 0x16, 244, 0 }, +{ 0x36, 244, 0 }, +{ 0x1e, 244, 0 }, +{ 0x125, 244, 0 }, +{ 0x325, 244, 0 }, +{ 0xa5, 244, 0 }, +{ 0x1a5, 244, 0 }, +{ 0x65, 244, 0 }, +{ 0xe5, 244, 0 }, +{ 0x95, 244, 0 }, +{ 0x195, 244, 0 }, +{ 0x55, 244, 0 }, +{ 0xd5, 244, 0 }, +{ 0x35, 244, 0 }, +{ 0x75, 244, 0 }, +{ 0x2d, 244, 0 }, +{ 0x6d, 244, 0 }, +{ 0x1d, 244, 0 }, +{ 0x3d, 244, 0 }, +{ 0x93, 244, 0 }, +{ 0x193, 244, 0 }, +{ 0x53, 244, 0 }, +{ 0xd3, 244, 0 }, +{ 0x33, 244, 0 }, +{ 0x73, 244, 0 }, +{ 0x4b, 244, 0 }, +{ 0xcb, 244, 0 }, +{ 0x2b, 244, 0 }, +{ 0x6b, 244, 0 }, +{ 0x1b, 244, 0 }, +{ 0x3b, 244, 0 }, +{ 0x17, 244, 0 }, +{ 0x37, 244, 0 }, +{ 0xf, 244, 0 }, +{ 0x1f, 244, 0 }, +{ 0x1, 243, 1 }, +{ 0xe, 244, 0 }, +{ 0x1, 241, 0 }, +{ 0x1, 240, 0 }, +{ 0x1, 239, 0 }, +{ 0x2, 238, 0 }, +{ 0x1, 238, 0 }, +{ 0x2, 237, 0 }, +{ 0x1, 237, 0 }, +{ 0x2, 236, 0 }, +{ 0x1, 236, 0 }, +{ 0x2, 235, 0 }, +{ 0x1, 235, 0 }, +{ 0x1, 234, 1 }, +{ 0x1, 251, 0 }, +{ 0x20, 233, 0 }, +{ 0x10, 233, 0 }, +{ 0x8, 233, 0 }, +{ 0x4, 233, 0 }, +{ 0x44, 233, 0 }, +{ 0x24, 233, 0 }, +{ 0x14, 233, 0 }, +{ 0xc, 233, 0 }, +{ 0x4c, 233, 0 }, +{ 0x2c, 233, 0 }, +{ 0x1c, 233, 0 }, +{ 0x2, 233, 0 }, +{ 0x12, 233, 0 }, +{ 0xa, 233, 0 }, +{ 0x6, 233, 0 }, +{ 0x1, 233, 0 }, +{ 0x20, 232, 0 }, +{ 0x10, 232, 0 }, +{ 0x8, 232, 0 }, +{ 0x4, 232, 0 }, +{ 0x44, 232, 0 }, +{ 0x24, 232, 0 }, +{ 0x14, 232, 0 }, +{ 0xc, 232, 0 }, +{ 0x4c, 232, 0 }, +{ 0x2c, 232, 0 }, +{ 0x1c, 232, 0 }, +{ 0x2, 232, 0 }, +{ 0x12, 232, 0 }, +{ 0xa, 232, 0 }, +{ 0x6, 232, 0 }, +{ 0x1, 232, 0 }, +{ 0x20, 231, 0 }, +{ 0x10, 231, 0 }, +{ 0x8, 231, 0 }, +{ 0x4, 231, 0 }, +{ 0x44, 231, 0 }, +{ 0x24, 231, 0 }, +{ 0x14, 231, 0 }, +{ 0xc, 231, 0 }, +{ 0x4c, 231, 0 }, +{ 0x2c, 231, 0 }, +{ 0x1c, 231, 0 }, +{ 0x2, 231, 0 }, +{ 0x12, 231, 0 }, +{ 0xa, 231, 0 }, +{ 0x6, 231, 0 }, +{ 0x1, 231, 0 }, +{ 0x40, 230, 0 }, +{ 0x140, 230, 0 }, +{ 0xc0, 230, 0 }, +{ 0x20, 230, 0 }, +{ 0xa0, 230, 0 }, +{ 0x60, 230, 0 }, +{ 0x10, 230, 0 }, +{ 0x8, 230, 0 }, +{ 0x14, 230, 0 }, +{ 0x54, 230, 0 }, +{ 0x34, 230, 0 }, +{ 0xc, 230, 0 }, +{ 0x2c, 230, 0 }, +{ 0x1c, 230, 0 }, +{ 0x2, 230, 0 }, +{ 0xa, 230, 0 }, +{ 0x6, 230, 0 }, +{ 0x1, 230, 0 }, +{ 0x40, 229, 0 }, +{ 0x140, 229, 0 }, +{ 0xc0, 229, 0 }, +{ 0x20, 229, 0 }, +{ 0xa0, 229, 0 }, +{ 0x60, 229, 0 }, +{ 0x10, 229, 0 }, +{ 0x8, 229, 0 }, +{ 0x14, 229, 0 }, +{ 0x54, 229, 0 }, +{ 0x34, 229, 0 }, +{ 0xc, 229, 0 }, +{ 0x2c, 229, 0 }, +{ 0x1c, 229, 0 }, +{ 0x2, 229, 0 }, +{ 0xa, 229, 0 }, +{ 0x6, 229, 0 }, +{ 0x1, 229, 0 }, +{ 0x40, 228, 0 }, +{ 0x140, 228, 0 }, +{ 0xc0, 228, 0 }, +{ 0x20, 228, 0 }, +{ 0xa0, 228, 0 }, +{ 0x60, 228, 0 }, +{ 0x10, 228, 0 }, +{ 0x8, 228, 0 }, +{ 0x14, 228, 0 }, +{ 0x54, 228, 0 }, +{ 0x34, 228, 0 }, +{ 0xc, 228, 0 }, +{ 0x2c, 228, 0 }, +{ 0x1c, 228, 0 }, +{ 0x2, 228, 0 }, +{ 0xa, 228, 0 }, +{ 0x6, 228, 0 }, +{ 0x1, 228, 0 }, +{ 0x40, 227, 0 }, +{ 0x140, 227, 0 }, +{ 0xc0, 227, 0 }, +{ 0x20, 227, 0 }, +{ 0xa0, 227, 0 }, +{ 0x60, 227, 0 }, +{ 0x10, 227, 0 }, +{ 0x8, 227, 0 }, +{ 0x14, 227, 0 }, +{ 0x54, 227, 0 }, +{ 0x34, 227, 0 }, +{ 0xc, 227, 0 }, +{ 0x2c, 227, 0 }, +{ 0x1c, 227, 0 }, +{ 0x2, 227, 0 }, +{ 0xa, 227, 0 }, +{ 0x6, 227, 0 }, +{ 0x1, 227, 0 }, +{ 0x40, 226, 0 }, +{ 0x140, 226, 0 }, +{ 0xc0, 226, 0 }, +{ 0x20, 226, 0 }, +{ 0xa0, 226, 0 }, +{ 0x60, 226, 0 }, +{ 0x10, 226, 0 }, +{ 0x8, 226, 0 }, +{ 0x14, 226, 0 }, +{ 0x54, 226, 0 }, +{ 0x34, 226, 0 }, +{ 0xc, 226, 0 }, +{ 0x2c, 226, 0 }, +{ 0x1c, 226, 0 }, +{ 0x2, 226, 0 }, +{ 0xa, 226, 0 }, +{ 0x6, 226, 0 }, +{ 0x1, 226, 0 }, +{ 0x40, 225, 0 }, +{ 0x140, 225, 0 }, +{ 0xc0, 225, 0 }, +{ 0x20, 225, 0 }, +{ 0xa0, 225, 0 }, +{ 0x60, 225, 0 }, +{ 0x10, 225, 0 }, +{ 0x8, 225, 0 }, +{ 0x14, 225, 0 }, +{ 0x54, 225, 0 }, +{ 0x34, 225, 0 }, +{ 0xc, 225, 0 }, +{ 0x2c, 225, 0 }, +{ 0x1c, 225, 0 }, +{ 0x2, 225, 0 }, +{ 0xa, 225, 0 }, +{ 0x6, 225, 0 }, +{ 0x1, 225, 0 }, +{ 0x40, 224, 0 }, +{ 0x140, 224, 0 }, +{ 0xc0, 224, 0 }, +{ 0x20, 224, 0 }, +{ 0xa0, 224, 0 }, +{ 0x60, 224, 0 }, +{ 0x10, 224, 0 }, +{ 0x8, 224, 0 }, +{ 0x14, 224, 0 }, +{ 0x54, 224, 0 }, +{ 0x34, 224, 0 }, +{ 0xc, 224, 0 }, +{ 0x2c, 224, 0 }, +{ 0x1c, 224, 0 }, +{ 0x2, 224, 0 }, +{ 0xa, 224, 0 }, +{ 0x6, 224, 0 }, +{ 0x1, 224, 0 }, +{ 0x40, 223, 0 }, +{ 0x140, 223, 0 }, +{ 0xc0, 223, 0 }, +{ 0x20, 223, 0 }, +{ 0xa0, 223, 0 }, +{ 0x60, 223, 0 }, +{ 0x10, 223, 0 }, +{ 0x8, 223, 0 }, +{ 0x14, 223, 0 }, +{ 0x54, 223, 0 }, +{ 0x34, 223, 0 }, +{ 0xc, 223, 0 }, +{ 0x2c, 223, 0 }, +{ 0x1c, 223, 0 }, +{ 0x2, 223, 0 }, +{ 0xa, 223, 0 }, +{ 0x6, 223, 0 }, +{ 0x1, 223, 0 }, +{ 0x40, 222, 0 }, +{ 0x140, 222, 0 }, +{ 0xc0, 222, 0 }, +{ 0x20, 222, 0 }, +{ 0xa0, 222, 0 }, +{ 0x60, 222, 0 }, +{ 0x10, 222, 0 }, +{ 0x8, 222, 0 }, +{ 0x14, 222, 0 }, +{ 0x54, 222, 0 }, +{ 0x34, 222, 0 }, +{ 0xc, 222, 0 }, +{ 0x2c, 222, 0 }, +{ 0x1c, 222, 0 }, +{ 0x2, 222, 0 }, +{ 0xa, 222, 0 }, +{ 0x6, 222, 0 }, +{ 0x1, 222, 0 }, +{ 0x40, 221, 0 }, +{ 0x140, 221, 0 }, +{ 0xc0, 221, 0 }, +{ 0x20, 221, 0 }, +{ 0xa0, 221, 0 }, +{ 0x60, 221, 0 }, +{ 0x10, 221, 0 }, +{ 0x8, 221, 0 }, +{ 0x14, 221, 0 }, +{ 0x54, 221, 0 }, +{ 0x34, 221, 0 }, +{ 0xc, 221, 0 }, +{ 0x2c, 221, 0 }, +{ 0x1c, 221, 0 }, +{ 0x2, 221, 0 }, +{ 0xa, 221, 0 }, +{ 0x6, 221, 0 }, +{ 0x1, 221, 0 }, +{ 0x40, 220, 0 }, +{ 0x140, 220, 0 }, +{ 0xc0, 220, 0 }, +{ 0x20, 220, 0 }, +{ 0xa0, 220, 0 }, +{ 0x60, 220, 0 }, +{ 0x10, 220, 0 }, +{ 0x8, 220, 0 }, +{ 0x14, 220, 0 }, +{ 0x54, 220, 0 }, +{ 0x34, 220, 0 }, +{ 0xc, 220, 0 }, +{ 0x2c, 220, 0 }, +{ 0x1c, 220, 0 }, +{ 0x2, 220, 0 }, +{ 0xa, 220, 0 }, +{ 0x6, 220, 0 }, +{ 0x1, 220, 0 }, +{ 0x40, 219, 0 }, +{ 0x140, 219, 0 }, +{ 0xc0, 219, 0 }, +{ 0x20, 219, 0 }, +{ 0xa0, 219, 0 }, +{ 0x60, 219, 0 }, +{ 0x10, 219, 0 }, +{ 0x8, 219, 0 }, +{ 0x14, 219, 0 }, +{ 0x54, 219, 0 }, +{ 0x34, 219, 0 }, +{ 0xc, 219, 0 }, +{ 0x2c, 219, 0 }, +{ 0x1c, 219, 0 }, +{ 0x2, 219, 0 }, +{ 0xa, 219, 0 }, +{ 0x6, 219, 0 }, +{ 0x1, 219, 0 }, +{ 0x40, 218, 0 }, +{ 0x140, 218, 0 }, +{ 0xc0, 218, 0 }, +{ 0x20, 218, 0 }, +{ 0xa0, 218, 0 }, +{ 0x60, 218, 0 }, +{ 0x10, 218, 0 }, +{ 0x8, 218, 0 }, +{ 0x14, 218, 0 }, +{ 0x54, 218, 0 }, +{ 0x34, 218, 0 }, +{ 0xc, 218, 0 }, +{ 0x2c, 218, 0 }, +{ 0x1c, 218, 0 }, +{ 0x2, 218, 0 }, +{ 0xa, 218, 0 }, +{ 0x6, 218, 0 }, +{ 0x1, 218, 0 }, +{ 0x40, 217, 0 }, +{ 0x140, 217, 0 }, +{ 0xc0, 217, 0 }, +{ 0x20, 217, 0 }, +{ 0xa0, 217, 0 }, +{ 0x60, 217, 0 }, +{ 0x10, 217, 0 }, +{ 0x8, 217, 0 }, +{ 0x14, 217, 0 }, +{ 0x54, 217, 0 }, +{ 0x34, 217, 0 }, +{ 0xc, 217, 0 }, +{ 0x2c, 217, 0 }, +{ 0x1c, 217, 0 }, +{ 0x2, 217, 0 }, +{ 0xa, 217, 0 }, +{ 0x6, 217, 0 }, +{ 0x1, 217, 0 }, +{ 0x40, 216, 0 }, +{ 0x140, 216, 0 }, +{ 0xc0, 216, 0 }, +{ 0x20, 216, 0 }, +{ 0xa0, 216, 0 }, +{ 0x60, 216, 0 }, +{ 0x10, 216, 0 }, +{ 0x8, 216, 0 }, +{ 0x14, 216, 0 }, +{ 0x54, 216, 0 }, +{ 0x34, 216, 0 }, +{ 0xc, 216, 0 }, +{ 0x2c, 216, 0 }, +{ 0x1c, 216, 0 }, +{ 0x2, 216, 0 }, +{ 0xa, 216, 0 }, +{ 0x6, 216, 0 }, +{ 0x1, 216, 0 }, +{ 0x40, 215, 0 }, +{ 0x140, 215, 0 }, +{ 0xc0, 215, 0 }, +{ 0x20, 215, 0 }, +{ 0xa0, 215, 0 }, +{ 0x60, 215, 0 }, +{ 0x10, 215, 0 }, +{ 0x8, 215, 0 }, +{ 0x14, 215, 0 }, +{ 0x54, 215, 0 }, +{ 0x34, 215, 0 }, +{ 0xc, 215, 0 }, +{ 0x2c, 215, 0 }, +{ 0x1c, 215, 0 }, +{ 0x2, 215, 0 }, +{ 0xa, 215, 0 }, +{ 0x6, 215, 0 }, +{ 0x1, 215, 0 }, +{ 0x40, 214, 0 }, +{ 0x140, 214, 0 }, +{ 0xc0, 214, 0 }, +{ 0x20, 214, 0 }, +{ 0xa0, 214, 0 }, +{ 0x60, 214, 0 }, +{ 0x10, 214, 0 }, +{ 0x8, 214, 0 }, +{ 0x14, 214, 0 }, +{ 0x54, 214, 0 }, +{ 0x34, 214, 0 }, +{ 0xc, 214, 0 }, +{ 0x2c, 214, 0 }, +{ 0x1c, 214, 0 }, +{ 0x2, 214, 0 }, +{ 0xa, 214, 0 }, +{ 0x6, 214, 0 }, +{ 0x1, 214, 0 }, +{ 0x40, 213, 0 }, +{ 0x140, 213, 0 }, +{ 0xc0, 213, 0 }, +{ 0x20, 213, 0 }, +{ 0xa0, 213, 0 }, +{ 0x60, 213, 0 }, +{ 0x10, 213, 0 }, +{ 0x8, 213, 0 }, +{ 0x14, 213, 0 }, +{ 0x54, 213, 0 }, +{ 0x34, 213, 0 }, +{ 0xc, 213, 0 }, +{ 0x2c, 213, 0 }, +{ 0x1c, 213, 0 }, +{ 0x2, 213, 0 }, +{ 0xa, 213, 0 }, +{ 0x6, 213, 0 }, +{ 0x1, 213, 0 }, +{ 0x1, 212, 0 }, +{ 0x5, 212, 0 }, +{ 0x3, 212, 0 }, +{ 0x1, 211, 0 }, +{ 0x5, 211, 0 }, +{ 0x3, 211, 0 }, +{ 0x1, 210, 0 }, +{ 0x5, 210, 0 }, +{ 0x3, 210, 0 }, +{ 0x200, 209, 0 }, +{ 0xa00, 209, 0 }, +{ 0x600, 209, 0 }, +{ 0x100, 209, 0 }, +{ 0x500, 209, 0 }, +{ 0x300, 209, 0 }, +{ 0x80, 209, 0 }, +{ 0x40, 209, 0 }, +{ 0x20, 209, 0 }, +{ 0xa0, 209, 0 }, +{ 0x60, 209, 0 }, +{ 0x50, 209, 0 }, +{ 0x150, 209, 0 }, +{ 0xd0, 209, 0 }, +{ 0x30, 209, 0 }, +{ 0x130, 209, 0 }, +{ 0xb0, 209, 0 }, +{ 0x70, 209, 0 }, +{ 0x170, 209, 0 }, +{ 0xf0, 209, 0 }, +{ 0x8, 209, 0 }, +{ 0x28, 209, 0 }, +{ 0x18, 209, 0 }, +{ 0x4, 209, 0 }, +{ 0x14, 209, 0 }, +{ 0xc, 209, 0 }, +{ 0x2, 209, 0 }, +{ 0xa, 209, 0 }, +{ 0x6, 209, 0 }, +{ 0x1, 209, 0 }, +{ 0x200, 208, 0 }, +{ 0xa00, 208, 0 }, +{ 0x600, 208, 0 }, +{ 0x100, 208, 0 }, +{ 0x500, 208, 0 }, +{ 0x300, 208, 0 }, +{ 0x80, 208, 0 }, +{ 0x40, 208, 0 }, +{ 0x20, 208, 0 }, +{ 0xa0, 208, 0 }, +{ 0x60, 208, 0 }, +{ 0x50, 208, 0 }, +{ 0x150, 208, 0 }, +{ 0xd0, 208, 0 }, +{ 0x30, 208, 0 }, +{ 0x130, 208, 0 }, +{ 0xb0, 208, 0 }, +{ 0x70, 208, 0 }, +{ 0x170, 208, 0 }, +{ 0xf0, 208, 0 }, +{ 0x8, 208, 0 }, +{ 0x28, 208, 0 }, +{ 0x18, 208, 0 }, +{ 0x4, 208, 0 }, +{ 0x14, 208, 0 }, +{ 0xc, 208, 0 }, +{ 0x2, 208, 0 }, +{ 0xa, 208, 0 }, +{ 0x6, 208, 0 }, +{ 0x1, 208, 0 }, +{ 0x200, 207, 0 }, +{ 0xa00, 207, 0 }, +{ 0x600, 207, 0 }, +{ 0x100, 207, 0 }, +{ 0x500, 207, 0 }, +{ 0x300, 207, 0 }, +{ 0x80, 207, 0 }, +{ 0x40, 207, 0 }, +{ 0x20, 207, 0 }, +{ 0xa0, 207, 0 }, +{ 0x60, 207, 0 }, +{ 0x50, 207, 0 }, +{ 0x150, 207, 0 }, +{ 0xd0, 207, 0 }, +{ 0x30, 207, 0 }, +{ 0x130, 207, 0 }, +{ 0xb0, 207, 0 }, +{ 0x70, 207, 0 }, +{ 0x170, 207, 0 }, +{ 0xf0, 207, 0 }, +{ 0x8, 207, 0 }, +{ 0x28, 207, 0 }, +{ 0x18, 207, 0 }, +{ 0x4, 207, 0 }, +{ 0x14, 207, 0 }, +{ 0xc, 207, 0 }, +{ 0x2, 207, 0 }, +{ 0xa, 207, 0 }, +{ 0x6, 207, 0 }, +{ 0x1, 207, 0 }, +{ 0x100, 206, 0 }, +{ 0x500, 206, 0 }, +{ 0x300, 206, 0 }, +{ 0x80, 206, 0 }, +{ 0x280, 206, 0 }, +{ 0x180, 206, 0 }, +{ 0x40, 206, 0 }, +{ 0x20, 206, 0 }, +{ 0x50, 206, 0 }, +{ 0x150, 206, 0 }, +{ 0xd0, 206, 0 }, +{ 0x30, 206, 0 }, +{ 0x130, 206, 0 }, +{ 0xb0, 206, 0 }, +{ 0x70, 206, 0 }, +{ 0x170, 206, 0 }, +{ 0xf0, 206, 0 }, +{ 0x8, 206, 0 }, +{ 0x28, 206, 0 }, +{ 0x18, 206, 0 }, +{ 0x4, 206, 0 }, +{ 0x14, 206, 0 }, +{ 0xc, 206, 0 }, +{ 0x2, 206, 0 }, +{ 0xa, 206, 0 }, +{ 0x6, 206, 0 }, +{ 0x1, 206, 0 }, +{ 0x100, 205, 0 }, +{ 0x500, 205, 0 }, +{ 0x300, 205, 0 }, +{ 0x80, 205, 0 }, +{ 0x280, 205, 0 }, +{ 0x180, 205, 0 }, +{ 0x40, 205, 0 }, +{ 0x20, 205, 0 }, +{ 0x50, 205, 0 }, +{ 0x150, 205, 0 }, +{ 0xd0, 205, 0 }, +{ 0x30, 205, 0 }, +{ 0x130, 205, 0 }, +{ 0xb0, 205, 0 }, +{ 0x70, 205, 0 }, +{ 0x170, 205, 0 }, +{ 0xf0, 205, 0 }, +{ 0x8, 205, 0 }, +{ 0x28, 205, 0 }, +{ 0x18, 205, 0 }, +{ 0x4, 205, 0 }, +{ 0x14, 205, 0 }, +{ 0xc, 205, 0 }, +{ 0x2, 205, 0 }, +{ 0xa, 205, 0 }, +{ 0x6, 205, 0 }, +{ 0x1, 205, 0 }, +{ 0x100, 204, 0 }, +{ 0x500, 204, 0 }, +{ 0x300, 204, 0 }, +{ 0x80, 204, 0 }, +{ 0x280, 204, 0 }, +{ 0x180, 204, 0 }, +{ 0x40, 204, 0 }, +{ 0x20, 204, 0 }, +{ 0x50, 204, 0 }, +{ 0x150, 204, 0 }, +{ 0xd0, 204, 0 }, +{ 0x30, 204, 0 }, +{ 0x130, 204, 0 }, +{ 0xb0, 204, 0 }, +{ 0x70, 204, 0 }, +{ 0x170, 204, 0 }, +{ 0xf0, 204, 0 }, +{ 0x8, 204, 0 }, +{ 0x28, 204, 0 }, +{ 0x18, 204, 0 }, +{ 0x4, 204, 0 }, +{ 0x14, 204, 0 }, +{ 0xc, 204, 0 }, +{ 0x2, 204, 0 }, +{ 0xa, 204, 0 }, +{ 0x6, 204, 0 }, +{ 0x1, 204, 0 }, +{ 0x100, 203, 0 }, +{ 0x500, 203, 0 }, +{ 0x300, 203, 0 }, +{ 0x80, 203, 0 }, +{ 0x280, 203, 0 }, +{ 0x180, 203, 0 }, +{ 0x40, 203, 0 }, +{ 0x20, 203, 0 }, +{ 0x50, 203, 0 }, +{ 0x150, 203, 0 }, +{ 0xd0, 203, 0 }, +{ 0x30, 203, 0 }, +{ 0x130, 203, 0 }, +{ 0xb0, 203, 0 }, +{ 0x70, 203, 0 }, +{ 0x170, 203, 0 }, +{ 0xf0, 203, 0 }, +{ 0x8, 203, 0 }, +{ 0x28, 203, 0 }, +{ 0x18, 203, 0 }, +{ 0x4, 203, 0 }, +{ 0x14, 203, 0 }, +{ 0xc, 203, 0 }, +{ 0x2, 203, 0 }, +{ 0xa, 203, 0 }, +{ 0x6, 203, 0 }, +{ 0x1, 203, 0 }, +{ 0x100, 202, 0 }, +{ 0x500, 202, 0 }, +{ 0x300, 202, 0 }, +{ 0x80, 202, 0 }, +{ 0x280, 202, 0 }, +{ 0x180, 202, 0 }, +{ 0x40, 202, 0 }, +{ 0x20, 202, 0 }, +{ 0x50, 202, 0 }, +{ 0x150, 202, 0 }, +{ 0xd0, 202, 0 }, +{ 0x30, 202, 0 }, +{ 0x130, 202, 0 }, +{ 0xb0, 202, 0 }, +{ 0x70, 202, 0 }, +{ 0x170, 202, 0 }, +{ 0xf0, 202, 0 }, +{ 0x8, 202, 0 }, +{ 0x28, 202, 0 }, +{ 0x18, 202, 0 }, +{ 0x4, 202, 0 }, +{ 0x14, 202, 0 }, +{ 0xc, 202, 0 }, +{ 0x2, 202, 0 }, +{ 0xa, 202, 0 }, +{ 0x6, 202, 0 }, +{ 0x1, 202, 0 }, +{ 0x100, 201, 0 }, +{ 0x500, 201, 0 }, +{ 0x300, 201, 0 }, +{ 0x80, 201, 0 }, +{ 0x280, 201, 0 }, +{ 0x180, 201, 0 }, +{ 0x40, 201, 0 }, +{ 0x20, 201, 0 }, +{ 0x50, 201, 0 }, +{ 0x150, 201, 0 }, +{ 0xd0, 201, 0 }, +{ 0x30, 201, 0 }, +{ 0x130, 201, 0 }, +{ 0xb0, 201, 0 }, +{ 0x70, 201, 0 }, +{ 0x170, 201, 0 }, +{ 0xf0, 201, 0 }, +{ 0x8, 201, 0 }, +{ 0x28, 201, 0 }, +{ 0x18, 201, 0 }, +{ 0x4, 201, 0 }, +{ 0x14, 201, 0 }, +{ 0xc, 201, 0 }, +{ 0x2, 201, 0 }, +{ 0xa, 201, 0 }, +{ 0x6, 201, 0 }, +{ 0x1, 201, 0 }, +{ 0x100, 200, 0 }, +{ 0x500, 200, 0 }, +{ 0x300, 200, 0 }, +{ 0x80, 200, 0 }, +{ 0x280, 200, 0 }, +{ 0x180, 200, 0 }, +{ 0x40, 200, 0 }, +{ 0x20, 200, 0 }, +{ 0x50, 200, 0 }, +{ 0x150, 200, 0 }, +{ 0xd0, 200, 0 }, +{ 0x30, 200, 0 }, +{ 0x130, 200, 0 }, +{ 0xb0, 200, 0 }, +{ 0x70, 200, 0 }, +{ 0x170, 200, 0 }, +{ 0xf0, 200, 0 }, +{ 0x8, 200, 0 }, +{ 0x28, 200, 0 }, +{ 0x18, 200, 0 }, +{ 0x4, 200, 0 }, +{ 0x14, 200, 0 }, +{ 0xc, 200, 0 }, +{ 0x2, 200, 0 }, +{ 0xa, 200, 0 }, +{ 0x6, 200, 0 }, +{ 0x1, 200, 0 }, +{ 0x100, 199, 0 }, +{ 0x500, 199, 0 }, +{ 0x300, 199, 0 }, +{ 0x80, 199, 0 }, +{ 0x280, 199, 0 }, +{ 0x180, 199, 0 }, +{ 0x40, 199, 0 }, +{ 0x20, 199, 0 }, +{ 0x50, 199, 0 }, +{ 0x150, 199, 0 }, +{ 0xd0, 199, 0 }, +{ 0x30, 199, 0 }, +{ 0x130, 199, 0 }, +{ 0xb0, 199, 0 }, +{ 0x70, 199, 0 }, +{ 0x170, 199, 0 }, +{ 0xf0, 199, 0 }, +{ 0x8, 199, 0 }, +{ 0x28, 199, 0 }, +{ 0x18, 199, 0 }, +{ 0x4, 199, 0 }, +{ 0x14, 199, 0 }, +{ 0xc, 199, 0 }, +{ 0x2, 199, 0 }, +{ 0xa, 199, 0 }, +{ 0x6, 199, 0 }, +{ 0x1, 199, 0 }, +{ 0x100, 198, 0 }, +{ 0x500, 198, 0 }, +{ 0x300, 198, 0 }, +{ 0x80, 198, 0 }, +{ 0x280, 198, 0 }, +{ 0x180, 198, 0 }, +{ 0x40, 198, 0 }, +{ 0x20, 198, 0 }, +{ 0x50, 198, 0 }, +{ 0x150, 198, 0 }, +{ 0xd0, 198, 0 }, +{ 0x30, 198, 0 }, +{ 0x130, 198, 0 }, +{ 0xb0, 198, 0 }, +{ 0x70, 198, 0 }, +{ 0x170, 198, 0 }, +{ 0xf0, 198, 0 }, +{ 0x8, 198, 0 }, +{ 0x28, 198, 0 }, +{ 0x18, 198, 0 }, +{ 0x4, 198, 0 }, +{ 0x14, 198, 0 }, +{ 0xc, 198, 0 }, +{ 0x2, 198, 0 }, +{ 0xa, 198, 0 }, +{ 0x6, 198, 0 }, +{ 0x1, 198, 0 }, +{ 0x1, 197, 0 }, +{ 0x1, 196, 0 }, +{ 0x2, 195, 0 }, +{ 0x1, 195, 0 }, +{ 0x1, 194, 0 }, +{ 0x1, 193, 1 }, +{ 0x1, 392, 0 }, +{ 0x1, 192, 1 }, +{ 0x1, 390, 0 }, +{ 0x8, 191, 0 }, +{ 0x4, 191, 0 }, +{ 0x2, 191, 0 }, +{ 0x1, 191, 0 }, +{ 0x1, 190, 0 }, +{ 0x1, 189, 0 }, +{ 0x2, 188, 0 }, +{ 0x1, 188, 0 }, +{ 0x4, 187, 0 }, +{ 0x2, 187, 0 }, +{ 0x1, 187, 0 }, +{ 0x40, 186, 0 }, +{ 0x20, 186, 0 }, +{ 0x10, 186, 0 }, +{ 0x44, 186, 0 }, +{ 0x24, 186, 0 }, +{ 0x14, 186, 0 }, +{ 0xc, 186, 1 }, +{ 0x4, 186, 0 }, +{ 0x22, 186, 0 }, +{ 0x12, 186, 0 }, +{ 0xa, 186, 0 }, +{ 0x6, 186, 1 }, +{ 0x2, 186, 0 }, +{ 0x1, 186, 1 }, +{ 0x8, 186, 0 }, +{ 0x8, 184, 0 }, +{ 0x4, 184, 0 }, +{ 0x2, 184, 0 }, +{ 0x1, 184, 1 }, +{ 0x1, 185, 0 }, +{ 0x1, 183, 0 }, +{ 0x8, 181, 0 }, +{ 0x4, 181, 0 }, +{ 0x2, 181, 0 }, +{ 0x1, 181, 1 }, +{ 0x1, 182, 0 }, +{ 0x8, 179, 0 }, +{ 0x4, 179, 0 }, +{ 0x2, 179, 0 }, +{ 0x1, 179, 1 }, +{ 0x1, 180, 0 }, +{ 0x8, 177, 0 }, +{ 0x4, 177, 0 }, +{ 0x2, 177, 0 }, +{ 0x1, 177, 1 }, +{ 0x1, 178, 0 }, +{ 0x8, 175, 0 }, +{ 0x4, 175, 0 }, +{ 0x2, 175, 0 }, +{ 0x1, 175, 1 }, +{ 0x1, 176, 0 }, +{ 0x10, 174, 0 }, +{ 0x8, 174, 0 }, +{ 0x4, 174, 0 }, +{ 0x1, 174, 1 }, +{ 0x2, 174, 0 }, +{ 0x8, 172, 0 }, +{ 0x4, 172, 0 }, +{ 0x2, 172, 0 }, +{ 0x1, 172, 1 }, +{ 0x1, 173, 0 }, +{ 0x1, 171, 0 }, +{ 0x8, 168, 0 }, +{ 0x4, 168, 0 }, +{ 0x2, 168, 0 }, +{ 0x1, 168, 1 }, +{ 0x1, 169, 0 }, +{ 0x10, 167, 0 }, +{ 0x8, 167, 0 }, +{ 0x4, 167, 0 }, +{ 0x1, 167, 1 }, +{ 0x2, 167, 0 }, +{ 0x8, 165, 0 }, +{ 0x4, 165, 0 }, +{ 0x2, 165, 0 }, +{ 0x1, 165, 1 }, +{ 0x1, 166, 1 }, +{ 0x1, 273, 0 }, +{ 0x4, 164, 0 }, +{ 0x2, 164, 0 }, +{ 0x1, 164, 1 }, +{ 0x1, 170, 0 }, +{ 0x8, 162, 0 }, +{ 0x4, 162, 0 }, +{ 0x2, 162, 0 }, +{ 0x1, 162, 1 }, +{ 0x1, 163, 1 }, +{ 0x1, 274, 0 }, +{ 0x8, 160, 0 }, +{ 0x4, 160, 0 }, +{ 0x2, 160, 0 }, +{ 0x1, 160, 1 }, +{ 0x1, 161, 0 }, +{ 0x442, 158, 0 }, +{ 0x242, 158, 0 }, +{ 0x142, 158, 0 }, +{ 0xc2, 158, 1 }, +{ 0x6, 159, 1 }, +{ 0x1, 377, 0 }, +{ 0x22, 158, 0 }, +{ 0x12, 158, 0 }, +{ 0xa, 158, 0 }, +{ 0x6, 158, 1 }, +{ 0x2, 159, 1 }, +{ 0x2, 311, 0 }, +{ 0x221, 158, 0 }, +{ 0x121, 158, 0 }, +{ 0xa1, 158, 0 }, +{ 0x61, 158, 1 }, +{ 0x3, 159, 1 }, +{ 0x1, 373, 0 }, +{ 0x11, 158, 0 }, +{ 0x9, 158, 0 }, +{ 0x5, 158, 0 }, +{ 0x3, 158, 1 }, +{ 0x1, 159, 1 }, +{ 0x1, 311, 0 }, +{ 0x880, 156, 0 }, +{ 0x480, 156, 0 }, +{ 0x280, 156, 0 }, +{ 0x180, 156, 1 }, +{ 0x80, 157, 1 }, +{ 0xc, 312, 0 }, +{ 0x440, 156, 0 }, +{ 0x240, 156, 0 }, +{ 0x140, 156, 0 }, +{ 0xc0, 156, 1 }, +{ 0x40, 157, 0 }, +{ 0x220, 156, 0 }, +{ 0x120, 156, 0 }, +{ 0xa0, 156, 0 }, +{ 0x60, 156, 1 }, +{ 0x20, 157, 0 }, +{ 0x110, 156, 0 }, +{ 0x90, 156, 0 }, +{ 0x50, 156, 0 }, +{ 0x30, 156, 1 }, +{ 0x10, 157, 0 }, +{ 0x88, 156, 0 }, +{ 0x48, 156, 0 }, +{ 0x28, 156, 0 }, +{ 0x18, 156, 1 }, +{ 0x8, 157, 1 }, +{ 0x1, 329, 0 }, +{ 0x44, 156, 0 }, +{ 0x24, 156, 0 }, +{ 0x14, 156, 0 }, +{ 0xc, 156, 1 }, +{ 0x4, 157, 1 }, +{ 0x6, 312, 0 }, +{ 0x22, 156, 0 }, +{ 0x12, 156, 0 }, +{ 0xa, 156, 0 }, +{ 0x6, 156, 1 }, +{ 0x2, 157, 1 }, +{ 0x3, 312, 0 }, +{ 0x11, 156, 0 }, +{ 0x9, 156, 0 }, +{ 0x5, 156, 0 }, +{ 0x8, 154, 0 }, +{ 0x4, 154, 0 }, +{ 0x2, 154, 0 }, +{ 0x1, 154, 1 }, +{ 0x1, 155, 1 }, +{ 0x1, 275, 0 }, +{ 0x8, 152, 0 }, +{ 0x4, 152, 0 }, +{ 0x2, 152, 0 }, +{ 0x1, 152, 1 }, +{ 0x1, 153, 1 }, +{ 0x1, 276, 0 }, +{ 0x1, 151, 0 }, +{ 0x1, 150, 0 }, +{ 0x1, 149, 0 }, +{ 0x40, 147, 0 }, +{ 0x20, 147, 0 }, +{ 0x10, 147, 0 }, +{ 0x44, 147, 0 }, +{ 0x24, 147, 0 }, +{ 0x14, 147, 0 }, +{ 0xc, 147, 1 }, +{ 0x4, 147, 0 }, +{ 0x22, 147, 0 }, +{ 0x12, 147, 0 }, +{ 0xa, 147, 0 }, +{ 0x6, 147, 1 }, +{ 0x2, 147, 0 }, +{ 0x1, 147, 1 }, +{ 0x8, 147, 0 }, +{ 0x20, 145, 0 }, +{ 0x10, 145, 0 }, +{ 0x8, 145, 0 }, +{ 0x4, 145, 1 }, +{ 0x1, 146, 0 }, +{ 0x22, 145, 0 }, +{ 0x12, 145, 0 }, +{ 0xa, 145, 0 }, +{ 0x6, 145, 1 }, +{ 0x4, 146, 0 }, +{ 0x11, 145, 0 }, +{ 0x9, 145, 0 }, +{ 0x5, 145, 0 }, +{ 0x3, 145, 1 }, +{ 0x2, 146, 0 }, +{ 0x1, 144, 0 }, +{ 0x20, 141, 0 }, +{ 0x10, 141, 0 }, +{ 0x8, 141, 0 }, +{ 0x4, 141, 1 }, +{ 0x1, 142, 0 }, +{ 0x22, 141, 0 }, +{ 0x12, 141, 0 }, +{ 0xa, 141, 0 }, +{ 0x6, 141, 1 }, +{ 0x4, 142, 0 }, +{ 0x11, 141, 0 }, +{ 0x9, 141, 0 }, +{ 0x5, 141, 0 }, +{ 0x3, 141, 1 }, +{ 0x2, 142, 0 }, +{ 0x40, 140, 0 }, +{ 0x20, 140, 0 }, +{ 0x10, 140, 0 }, +{ 0x44, 140, 0 }, +{ 0x24, 140, 0 }, +{ 0x14, 140, 0 }, +{ 0xc, 140, 1 }, +{ 0x4, 140, 0 }, +{ 0x22, 140, 0 }, +{ 0x12, 140, 0 }, +{ 0xa, 140, 0 }, +{ 0x6, 140, 1 }, +{ 0x2, 140, 0 }, +{ 0x1, 140, 1 }, +{ 0x8, 140, 0 }, +{ 0x4, 139, 0 }, +{ 0x2, 139, 0 }, +{ 0x1, 139, 0 }, +{ 0x8, 137, 0 }, +{ 0x4, 137, 0 }, +{ 0x2, 137, 0 }, +{ 0x1, 137, 1 }, +{ 0x1, 138, 1 }, +{ 0x1, 366, 0 }, +{ 0x4, 136, 0 }, +{ 0x2, 136, 1 }, +{ 0x1, 242, 0 }, +{ 0x1, 136, 1 }, +{ 0x1, 143, 0 }, +{ 0x8, 134, 0 }, +{ 0x4, 134, 0 }, +{ 0x2, 134, 0 }, +{ 0x1, 134, 1 }, +{ 0x1, 135, 1 }, +{ 0x1, 367, 0 }, +{ 0x20, 132, 0 }, +{ 0x10, 132, 0 }, +{ 0x8, 132, 0 }, +{ 0x4, 132, 1 }, +{ 0x1, 133, 0 }, +{ 0x2, 132, 1 }, +{ 0xc, 133, 0 }, +{ 0x12, 132, 0 }, +{ 0xa, 132, 0 }, +{ 0x6, 132, 0 }, +{ 0x11, 132, 0 }, +{ 0x9, 132, 0 }, +{ 0x5, 132, 0 }, +{ 0x3, 132, 1 }, +{ 0x2, 133, 0 }, +{ 0x1, 131, 0 }, +{ 0x2, 130, 0 }, +{ 0xa, 130, 0 }, +{ 0x6, 130, 0 }, +{ 0x1, 130, 0 }, +{ 0x5, 130, 0 }, +{ 0x3, 130, 0 }, +{ 0x2, 129, 0 }, +{ 0xa, 129, 0 }, +{ 0x6, 129, 0 }, +{ 0x1, 129, 0 }, +{ 0x5, 129, 0 }, +{ 0x3, 129, 0 }, +{ 0x41, 128, 1 }, +{ 0x40, 148, 0 }, +{ 0x21, 128, 1 }, +{ 0x20, 148, 0 }, +{ 0x11, 128, 1 }, +{ 0x10, 148, 0 }, +{ 0x9, 128, 1 }, +{ 0x1, 128, 1 }, +{ 0x1, 148, 1 }, +{ 0x8, 148, 0 }, +{ 0x45, 128, 1 }, +{ 0x44, 148, 0 }, +{ 0x25, 128, 1 }, +{ 0x24, 148, 0 }, +{ 0x15, 128, 1 }, +{ 0x14, 148, 0 }, +{ 0xd, 128, 1 }, +{ 0x5, 128, 1 }, +{ 0xc, 148, 1 }, +{ 0x4, 148, 0 }, +{ 0x23, 128, 1 }, +{ 0x22, 148, 0 }, +{ 0x13, 128, 1 }, +{ 0x12, 148, 0 }, +{ 0xb, 128, 1 }, +{ 0xa, 148, 0 }, +{ 0x7, 128, 1 }, +{ 0x3, 128, 1 }, +{ 0x6, 148, 1 }, +{ 0x2, 148, 0 }, +{ 0x1, 127, 0 }, +{ 0x442, 125, 0 }, +{ 0x242, 125, 0 }, +{ 0x142, 125, 0 }, +{ 0xc2, 125, 1 }, +{ 0x6, 126, 0 }, +{ 0x22, 125, 0 }, +{ 0x12, 125, 0 }, +{ 0xa, 125, 0 }, +{ 0x221, 125, 0 }, +{ 0x121, 125, 0 }, +{ 0xa1, 125, 0 }, +{ 0x61, 125, 1 }, +{ 0x3, 126, 0 }, +{ 0x11, 125, 0 }, +{ 0x9, 125, 0 }, +{ 0x5, 125, 0 }, +{ 0x1108, 117, 1 }, +{ 0x1108, 121, 0 }, +{ 0x908, 117, 1 }, +{ 0x908, 121, 0 }, +{ 0x508, 117, 1 }, +{ 0x508, 121, 0 }, +{ 0x308, 117, 1 }, +{ 0x18, 118, 1 }, +{ 0x308, 121, 1 }, +{ 0x18, 122, 0 }, +{ 0x88, 117, 1 }, +{ 0x88, 121, 0 }, +{ 0x48, 117, 1 }, +{ 0x48, 121, 0 }, +{ 0x28, 117, 1 }, +{ 0x28, 121, 0 }, +{ 0x18, 117, 1 }, +{ 0x8, 118, 1 }, +{ 0x18, 121, 1 }, +{ 0x8, 122, 0 }, +{ 0x884, 117, 1 }, +{ 0x442, 119, 1 }, +{ 0x884, 121, 1 }, +{ 0x442, 123, 0 }, +{ 0x484, 117, 1 }, +{ 0x242, 119, 1 }, +{ 0x484, 121, 1 }, +{ 0x242, 123, 0 }, +{ 0x284, 117, 1 }, +{ 0x142, 119, 1 }, +{ 0x284, 121, 1 }, +{ 0x142, 123, 0 }, +{ 0x184, 117, 1 }, +{ 0xc, 118, 1 }, +{ 0xc2, 119, 1 }, +{ 0x6, 120, 1 }, +{ 0x184, 121, 1 }, +{ 0xc, 122, 1 }, +{ 0xc2, 123, 1 }, +{ 0x6, 124, 0 }, +{ 0x44, 117, 1 }, +{ 0x22, 119, 1 }, +{ 0x44, 121, 1 }, +{ 0x22, 123, 0 }, +{ 0x24, 117, 1 }, +{ 0x12, 119, 1 }, +{ 0x24, 121, 1 }, +{ 0x12, 123, 0 }, +{ 0x14, 117, 1 }, +{ 0xa, 119, 1 }, +{ 0x14, 121, 1 }, +{ 0xa, 123, 0 }, +{ 0xc, 117, 1 }, +{ 0x4, 118, 1 }, +{ 0x6, 119, 1 }, +{ 0x2, 120, 1 }, +{ 0xc, 121, 1 }, +{ 0x4, 122, 1 }, +{ 0x6, 123, 1 }, +{ 0x2, 124, 0 }, +{ 0x442, 117, 1 }, +{ 0x221, 119, 1 }, +{ 0x442, 121, 1 }, +{ 0x221, 123, 0 }, +{ 0x242, 117, 1 }, +{ 0x121, 119, 1 }, +{ 0x242, 121, 1 }, +{ 0x121, 123, 0 }, +{ 0x142, 117, 1 }, +{ 0xa1, 119, 1 }, +{ 0x142, 121, 1 }, +{ 0xa1, 123, 0 }, +{ 0xc2, 117, 1 }, +{ 0x6, 118, 1 }, +{ 0x61, 119, 1 }, +{ 0x3, 120, 1 }, +{ 0xc2, 121, 1 }, +{ 0x6, 122, 1 }, +{ 0x61, 123, 1 }, +{ 0x3, 124, 0 }, +{ 0x22, 117, 1 }, +{ 0x11, 119, 1 }, +{ 0x22, 121, 1 }, +{ 0x11, 123, 0 }, +{ 0x12, 117, 1 }, +{ 0x9, 119, 1 }, +{ 0x12, 121, 1 }, +{ 0x9, 123, 0 }, +{ 0xa, 117, 1 }, +{ 0x5, 119, 1 }, +{ 0xa, 121, 1 }, +{ 0x5, 123, 0 }, +{ 0x6, 117, 1 }, +{ 0x2, 118, 1 }, +{ 0x3, 119, 1 }, +{ 0x1, 120, 1 }, +{ 0x6, 121, 1 }, +{ 0x2, 122, 1 }, +{ 0x3, 123, 1 }, +{ 0x1, 124, 0 }, +{ 0x221, 117, 1 }, +{ 0x221, 121, 0 }, +{ 0x121, 117, 1 }, +{ 0x121, 121, 0 }, +{ 0xa1, 117, 1 }, +{ 0xa1, 121, 0 }, +{ 0x61, 117, 1 }, +{ 0x3, 118, 1 }, +{ 0x61, 121, 1 }, +{ 0x3, 122, 0 }, +{ 0x11, 117, 1 }, +{ 0x11, 121, 0 }, +{ 0x9, 117, 1 }, +{ 0x9, 121, 0 }, +{ 0x5, 117, 1 }, +{ 0x5, 121, 0 }, +{ 0x3, 117, 1 }, +{ 0x1, 118, 1 }, +{ 0x3, 121, 1 }, +{ 0x1, 122, 0 }, +{ 0x8, 115, 0 }, +{ 0x4, 115, 0 }, +{ 0x2, 115, 0 }, +{ 0x1, 115, 1 }, +{ 0x1, 116, 0 }, +{ 0x1, 113, 1 }, +{ 0x1, 114, 0 }, +{ 0x3, 113, 1 }, +{ 0x3, 114, 0 }, +{ 0x8, 111, 0 }, +{ 0x4, 111, 0 }, +{ 0x2, 111, 0 }, +{ 0x1, 111, 1 }, +{ 0x1, 112, 0 }, +{ 0x1, 110, 1 }, +{ 0x3, 156, 1 }, +{ 0x1, 157, 0 }, +{ 0x1, 109, 0 }, +{ 0x1, 108, 0 }, +{ 0x8, 106, 0 }, +{ 0x4, 106, 0 }, +{ 0x2, 106, 0 }, +{ 0x1, 106, 1 }, +{ 0x1, 107, 1 }, +{ 0x1, 368, 0 }, +{ 0x8, 104, 0 }, +{ 0x4, 104, 0 }, +{ 0x2, 104, 0 }, +{ 0x1, 104, 1 }, +{ 0x1, 105, 0 }, +{ 0x40, 103, 0 }, +{ 0x20, 103, 0 }, +{ 0x10, 103, 1 }, +{ 0x2, 293, 0 }, +{ 0x44, 103, 0 }, +{ 0x24, 103, 0 }, +{ 0x14, 103, 0 }, +{ 0xc, 103, 1 }, +{ 0x4, 103, 0 }, +{ 0x22, 103, 0 }, +{ 0x12, 103, 0 }, +{ 0xa, 103, 0 }, +{ 0x6, 103, 1 }, +{ 0x2, 103, 0 }, +{ 0x1, 103, 1 }, +{ 0x8, 103, 0 }, +{ 0x1, 102, 0 }, +{ 0x2, 101, 1 }, +{ 0x2, 339, 0 }, +{ 0x1, 101, 1 }, +{ 0x1, 339, 0 }, +{ 0x1, 100, 0 }, +{ 0x1, 99, 0 }, +{ 0x1, 98, 0 }, +{ 0x1, 97, 1 }, +{ 0x1, 335, 0 }, +{ 0x1, 96, 0 }, +{ 0x2, 95, 0 }, +{ 0x1, 95, 1 }, +{ 0x6, 125, 1 }, +{ 0x2, 126, 0 }, +{ 0x2, 94, 0 }, +{ 0x1, 94, 1 }, +{ 0x3, 125, 1 }, +{ 0x1, 126, 0 }, +{ 0x1, 93, 0 }, +{ 0x2, 92, 0 }, +{ 0xa, 92, 0 }, +{ 0x6, 92, 0 }, +{ 0x1, 92, 0 }, +{ 0x5, 92, 0 }, +{ 0x3, 92, 0 }, +{ 0x2, 91, 0 }, +{ 0xa, 91, 0 }, +{ 0x6, 91, 0 }, +{ 0x1, 91, 0 }, +{ 0x5, 91, 0 }, +{ 0x3, 91, 0 }, +{ 0x2, 90, 0 }, +{ 0xa, 90, 0 }, +{ 0x6, 90, 0 }, +{ 0x1, 90, 0 }, +{ 0x5, 90, 0 }, +{ 0x3, 90, 0 }, +{ 0x2, 89, 0 }, +{ 0xa, 89, 0 }, +{ 0x6, 89, 0 }, +{ 0x1, 89, 0 }, +{ 0x5, 89, 0 }, +{ 0x3, 89, 0 }, +{ 0x34, 77, 1 }, +{ 0x7, 88, 0 }, +{ 0xc, 77, 1 }, +{ 0x3, 81, 0 }, +{ 0x2, 77, 1 }, +{ 0x1, 78, 1 }, +{ 0x1, 79, 1 }, +{ 0x1, 80, 0 }, +{ 0x6, 77, 1 }, +{ 0x3, 78, 1 }, +{ 0x3, 79, 1 }, +{ 0x3, 80, 0 }, +{ 0x1, 77, 1 }, +{ 0x2, 80, 0 }, +{ 0x9, 77, 1 }, +{ 0x6, 80, 0 }, +{ 0xd, 77, 1 }, +{ 0xe, 88, 0 }, +{ 0x3, 77, 1 }, +{ 0x6, 81, 0 }, +{ 0x28, 75, 1 }, +{ 0x5, 76, 0 }, +{ 0x68, 75, 1 }, +{ 0x7, 87, 0 }, +{ 0x18, 75, 1 }, +{ 0x3, 76, 0 }, +{ 0x14, 75, 1 }, +{ 0xa, 76, 0 }, +{ 0x34, 75, 1 }, +{ 0xe, 87, 0 }, +{ 0xc, 75, 1 }, +{ 0x6, 76, 0 }, +{ 0xa, 75, 1 }, +{ 0x14, 76, 0 }, +{ 0x1a, 75, 1 }, +{ 0x1c, 87, 0 }, +{ 0x6, 75, 1 }, +{ 0xc, 76, 0 }, +{ 0x5, 75, 1 }, +{ 0x28, 76, 0 }, +{ 0xd, 75, 1 }, +{ 0x38, 87, 0 }, +{ 0x3, 75, 1 }, +{ 0x18, 76, 0 }, +{ 0x28, 70, 1 }, +{ 0x5, 74, 0 }, +{ 0x68, 70, 1 }, +{ 0x7, 86, 0 }, +{ 0x18, 70, 1 }, +{ 0x3, 74, 0 }, +{ 0x4, 70, 1 }, +{ 0x2, 71, 1 }, +{ 0x2, 72, 1 }, +{ 0x2, 73, 0 }, +{ 0xc, 70, 1 }, +{ 0x6, 71, 1 }, +{ 0x6, 72, 1 }, +{ 0x6, 73, 0 }, +{ 0x2, 70, 1 }, +{ 0x1, 71, 1 }, +{ 0x1, 72, 1 }, +{ 0x1, 73, 0 }, +{ 0x6, 70, 1 }, +{ 0x3, 71, 1 }, +{ 0x3, 72, 1 }, +{ 0x3, 73, 0 }, +{ 0x1, 70, 1 }, +{ 0x4, 73, 0 }, +{ 0x9, 70, 1 }, +{ 0xc, 73, 0 }, +{ 0x5, 70, 1 }, +{ 0xa, 74, 0 }, +{ 0xd, 70, 1 }, +{ 0xe, 86, 0 }, +{ 0x3, 70, 1 }, +{ 0x6, 74, 0 }, +{ 0x68, 60, 1 }, +{ 0x7, 69, 0 }, +{ 0x18, 60, 1 }, +{ 0x3, 64, 0 }, +{ 0x2, 60, 1 }, +{ 0x1, 61, 1 }, +{ 0x1, 62, 1 }, +{ 0x1, 63, 0 }, +{ 0x6, 60, 1 }, +{ 0x3, 61, 1 }, +{ 0x3, 62, 1 }, +{ 0x3, 63, 0 }, +{ 0x1, 60, 1 }, +{ 0x4, 63, 0 }, +{ 0x9, 60, 1 }, +{ 0xc, 63, 0 }, +{ 0xd, 60, 1 }, +{ 0xe, 69, 0 }, +{ 0x3, 60, 1 }, +{ 0x6, 64, 0 }, +{ 0x28, 58, 1 }, +{ 0x5, 59, 0 }, +{ 0x68, 58, 1 }, +{ 0x7, 68, 0 }, +{ 0x18, 58, 1 }, +{ 0x3, 59, 0 }, +{ 0x14, 58, 1 }, +{ 0xa, 59, 0 }, +{ 0x34, 58, 1 }, +{ 0xe, 68, 0 }, +{ 0xc, 58, 1 }, +{ 0x6, 59, 0 }, +{ 0xa, 58, 1 }, +{ 0x14, 59, 0 }, +{ 0x1a, 58, 1 }, +{ 0x1c, 68, 0 }, +{ 0x6, 58, 1 }, +{ 0xc, 59, 0 }, +{ 0x5, 58, 1 }, +{ 0x28, 59, 0 }, +{ 0xd, 58, 1 }, +{ 0x38, 68, 0 }, +{ 0x3, 58, 1 }, +{ 0x18, 59, 0 }, +{ 0x28, 53, 1 }, +{ 0x5, 57, 0 }, +{ 0x68, 53, 1 }, +{ 0x7, 67, 0 }, +{ 0x18, 53, 1 }, +{ 0x3, 57, 0 }, +{ 0x4, 53, 1 }, +{ 0x2, 54, 1 }, +{ 0x2, 55, 1 }, +{ 0x2, 56, 0 }, +{ 0xc, 53, 1 }, +{ 0x6, 54, 1 }, +{ 0x6, 55, 1 }, +{ 0x6, 56, 0 }, +{ 0x2, 53, 1 }, +{ 0x1, 54, 1 }, +{ 0x1, 55, 1 }, +{ 0x1, 56, 0 }, +{ 0x6, 53, 1 }, +{ 0x3, 54, 1 }, +{ 0x3, 55, 1 }, +{ 0x3, 56, 0 }, +{ 0x1, 53, 1 }, +{ 0x4, 56, 0 }, +{ 0x9, 53, 1 }, +{ 0xc, 56, 0 }, +{ 0x5, 53, 1 }, +{ 0xa, 57, 0 }, +{ 0xd, 53, 1 }, +{ 0xe, 67, 0 }, +{ 0x3, 53, 1 }, +{ 0x6, 57, 0 }, +{ 0x2, 52, 0 }, +{ 0x1, 52, 0 }, +{ 0x1, 50, 0 }, +{ 0x3, 49, 0 }, +{ 0x5, 48, 0 }, +{ 0x3, 48, 0 }, +{ 0x5, 47, 0 }, +{ 0x3, 47, 0 }, +{ 0x3, 46, 0 }, +{ 0x2, 45, 0 }, +{ 0x1, 45, 0 }, +{ 0x8, 43, 1 }, +{ 0x38, 44, 1 }, +{ 0xe8, 44, 0 }, +{ 0x1248, 43, 0 }, +{ 0x3248, 43, 0 }, +{ 0xa48, 43, 0 }, +{ 0x1a48, 43, 0 }, +{ 0x648, 43, 0 }, +{ 0xe48, 43, 0 }, +{ 0x948, 43, 0 }, +{ 0x1948, 43, 0 }, +{ 0x548, 43, 0 }, +{ 0xd48, 43, 0 }, +{ 0x348, 43, 0 }, +{ 0x748, 43, 0 }, +{ 0x2c8, 43, 0 }, +{ 0x6c8, 43, 0 }, +{ 0x1c8, 43, 0 }, +{ 0x3c8, 43, 0 }, +{ 0x28, 43, 1 }, +{ 0x78, 44, 1 }, +{ 0x1e8, 44, 0 }, +{ 0x498, 43, 1 }, +{ 0x488, 44, 0 }, +{ 0xc98, 43, 1 }, +{ 0xc88, 44, 0 }, +{ 0x298, 43, 1 }, +{ 0x288, 44, 0 }, +{ 0x698, 43, 1 }, +{ 0x688, 44, 0 }, +{ 0x198, 43, 1 }, +{ 0x188, 44, 0 }, +{ 0x398, 43, 1 }, +{ 0x388, 44, 0 }, +{ 0x258, 43, 1 }, +{ 0x248, 44, 0 }, +{ 0x658, 43, 1 }, +{ 0x648, 44, 0 }, +{ 0x158, 43, 1 }, +{ 0x148, 44, 0 }, +{ 0x358, 43, 1 }, +{ 0x348, 44, 0 }, +{ 0xd8, 43, 1 }, +{ 0xc8, 44, 0 }, +{ 0x1d8, 43, 1 }, +{ 0x1c8, 44, 0 }, +{ 0x78, 43, 1 }, +{ 0x58, 44, 0 }, +{ 0xf8, 43, 1 }, +{ 0xd8, 44, 0 }, +{ 0x4, 43, 1 }, +{ 0x1c, 44, 1 }, +{ 0x74, 44, 0 }, +{ 0x924, 43, 0 }, +{ 0x1924, 43, 0 }, +{ 0x524, 43, 0 }, +{ 0xd24, 43, 0 }, +{ 0x324, 43, 0 }, +{ 0x724, 43, 0 }, +{ 0x4a4, 43, 0 }, +{ 0xca4, 43, 0 }, +{ 0x2a4, 43, 0 }, +{ 0x6a4, 43, 0 }, +{ 0x1a4, 43, 0 }, +{ 0x3a4, 43, 0 }, +{ 0x164, 43, 0 }, +{ 0x364, 43, 0 }, +{ 0xe4, 43, 0 }, +{ 0x1e4, 43, 0 }, +{ 0x14, 43, 1 }, +{ 0x3c, 44, 1 }, +{ 0xf4, 44, 0 }, +{ 0x24c, 43, 1 }, +{ 0x244, 44, 0 }, +{ 0x64c, 43, 1 }, +{ 0x644, 44, 0 }, +{ 0x14c, 43, 1 }, +{ 0x144, 44, 0 }, +{ 0x34c, 43, 1 }, +{ 0x344, 44, 0 }, +{ 0xcc, 43, 1 }, +{ 0xc4, 44, 0 }, +{ 0x1cc, 43, 1 }, +{ 0x1c4, 44, 0 }, +{ 0x12c, 43, 1 }, +{ 0x124, 44, 0 }, +{ 0x32c, 43, 1 }, +{ 0x324, 44, 0 }, +{ 0xac, 43, 1 }, +{ 0xa4, 44, 0 }, +{ 0x1ac, 43, 1 }, +{ 0x1a4, 44, 0 }, +{ 0x6c, 43, 1 }, +{ 0x64, 44, 0 }, +{ 0xec, 43, 1 }, +{ 0xe4, 44, 0 }, +{ 0x3c, 43, 1 }, +{ 0x2c, 44, 0 }, +{ 0x7c, 43, 1 }, +{ 0x6c, 44, 0 }, +{ 0x2, 43, 1 }, +{ 0xe, 44, 1 }, +{ 0x3a, 44, 0 }, +{ 0x492, 43, 0 }, +{ 0xc92, 43, 0 }, +{ 0x292, 43, 0 }, +{ 0x692, 43, 0 }, +{ 0x192, 43, 0 }, +{ 0x392, 43, 0 }, +{ 0x252, 43, 0 }, +{ 0x652, 43, 0 }, +{ 0x152, 43, 0 }, +{ 0x352, 43, 0 }, +{ 0xd2, 43, 0 }, +{ 0x1d2, 43, 0 }, +{ 0xb2, 43, 0 }, +{ 0x1b2, 43, 0 }, +{ 0x72, 43, 0 }, +{ 0xf2, 43, 0 }, +{ 0xa, 43, 1 }, +{ 0x1e, 44, 1 }, +{ 0x7a, 44, 0 }, +{ 0x126, 43, 1 }, +{ 0x122, 44, 0 }, +{ 0x326, 43, 1 }, +{ 0x322, 44, 0 }, +{ 0xa6, 43, 1 }, +{ 0xa2, 44, 0 }, +{ 0x1a6, 43, 1 }, +{ 0x1a2, 44, 0 }, +{ 0x66, 43, 1 }, +{ 0x62, 44, 0 }, +{ 0xe6, 43, 1 }, +{ 0xe2, 44, 0 }, +{ 0x96, 43, 1 }, +{ 0x92, 44, 0 }, +{ 0x196, 43, 1 }, +{ 0x192, 44, 0 }, +{ 0x56, 43, 1 }, +{ 0x52, 44, 0 }, +{ 0xd6, 43, 1 }, +{ 0xd2, 44, 0 }, +{ 0x36, 43, 1 }, +{ 0x32, 44, 0 }, +{ 0x76, 43, 1 }, +{ 0x72, 44, 0 }, +{ 0x1e, 43, 1 }, +{ 0x16, 44, 0 }, +{ 0x3e, 43, 1 }, +{ 0x36, 44, 0 }, +{ 0x1, 43, 1 }, +{ 0x7, 44, 1 }, +{ 0x1d, 44, 0 }, +{ 0x249, 43, 0 }, +{ 0x649, 43, 0 }, +{ 0x149, 43, 0 }, +{ 0x349, 43, 0 }, +{ 0xc9, 43, 0 }, +{ 0x1c9, 43, 0 }, +{ 0x129, 43, 0 }, +{ 0x329, 43, 0 }, +{ 0xa9, 43, 0 }, +{ 0x1a9, 43, 0 }, +{ 0x69, 43, 0 }, +{ 0xe9, 43, 0 }, +{ 0x59, 43, 0 }, +{ 0xd9, 43, 0 }, +{ 0x39, 43, 0 }, +{ 0x79, 43, 0 }, +{ 0x5, 43, 1 }, +{ 0xf, 44, 1 }, +{ 0x3d, 44, 0 }, +{ 0x93, 43, 1 }, +{ 0x91, 44, 0 }, +{ 0x193, 43, 1 }, +{ 0x191, 44, 0 }, +{ 0x53, 43, 1 }, +{ 0x51, 44, 0 }, +{ 0xd3, 43, 1 }, +{ 0xd1, 44, 0 }, +{ 0x33, 43, 1 }, +{ 0x31, 44, 0 }, +{ 0x73, 43, 1 }, +{ 0x71, 44, 0 }, +{ 0x4b, 43, 1 }, +{ 0x49, 44, 0 }, +{ 0xcb, 43, 1 }, +{ 0xc9, 44, 0 }, +{ 0x2b, 43, 1 }, +{ 0x29, 44, 0 }, +{ 0x6b, 43, 1 }, +{ 0x69, 44, 0 }, +{ 0x1b, 43, 1 }, +{ 0x19, 44, 0 }, +{ 0x3b, 43, 1 }, +{ 0x39, 44, 0 }, +{ 0xf, 43, 1 }, +{ 0xb, 44, 0 }, +{ 0x1f, 43, 1 }, +{ 0x1b, 44, 0 }, +{ 0x4, 41, 1 }, +{ 0x1c, 42, 1 }, +{ 0x74, 42, 0 }, +{ 0x924, 41, 0 }, +{ 0x1924, 41, 0 }, +{ 0x524, 41, 0 }, +{ 0xd24, 41, 0 }, +{ 0x324, 41, 0 }, +{ 0x724, 41, 0 }, +{ 0x4a4, 41, 0 }, +{ 0xca4, 41, 0 }, +{ 0x2a4, 41, 0 }, +{ 0x6a4, 41, 0 }, +{ 0x1a4, 41, 0 }, +{ 0x3a4, 41, 0 }, +{ 0x164, 41, 0 }, +{ 0x364, 41, 0 }, +{ 0xe4, 41, 0 }, +{ 0x1e4, 41, 0 }, +{ 0x14, 41, 1 }, +{ 0x3c, 42, 1 }, +{ 0xf4, 42, 0 }, +{ 0x24c, 41, 1 }, +{ 0x244, 42, 0 }, +{ 0x64c, 41, 1 }, +{ 0x644, 42, 0 }, +{ 0x14c, 41, 1 }, +{ 0x144, 42, 0 }, +{ 0x34c, 41, 1 }, +{ 0x344, 42, 0 }, +{ 0xcc, 41, 1 }, +{ 0xc4, 42, 0 }, +{ 0x1cc, 41, 1 }, +{ 0x1c4, 42, 0 }, +{ 0x12c, 41, 1 }, +{ 0x124, 42, 0 }, +{ 0x32c, 41, 1 }, +{ 0x324, 42, 0 }, +{ 0xac, 41, 1 }, +{ 0xa4, 42, 0 }, +{ 0x1ac, 41, 1 }, +{ 0x1a4, 42, 0 }, +{ 0x6c, 41, 1 }, +{ 0x64, 42, 0 }, +{ 0xec, 41, 1 }, +{ 0xe4, 42, 0 }, +{ 0x3c, 41, 1 }, +{ 0x2c, 42, 0 }, +{ 0x7c, 41, 1 }, +{ 0x6c, 42, 0 }, +{ 0xa, 41, 1 }, +{ 0x3a, 42, 1 }, +{ 0xea, 42, 0 }, +{ 0x124a, 41, 0 }, +{ 0x324a, 41, 0 }, +{ 0xa4a, 41, 0 }, +{ 0x1a4a, 41, 0 }, +{ 0x64a, 41, 0 }, +{ 0xe4a, 41, 0 }, +{ 0x94a, 41, 0 }, +{ 0x194a, 41, 0 }, +{ 0x54a, 41, 0 }, +{ 0xd4a, 41, 0 }, +{ 0x34a, 41, 0 }, +{ 0x74a, 41, 0 }, +{ 0x2ca, 41, 0 }, +{ 0x6ca, 41, 0 }, +{ 0x1ca, 41, 0 }, +{ 0x3ca, 41, 0 }, +{ 0x2a, 41, 1 }, +{ 0x7a, 42, 1 }, +{ 0x1ea, 42, 0 }, +{ 0x49a, 41, 1 }, +{ 0x48a, 42, 0 }, +{ 0xc9a, 41, 1 }, +{ 0xc8a, 42, 0 }, +{ 0x29a, 41, 1 }, +{ 0x28a, 42, 0 }, +{ 0x69a, 41, 1 }, +{ 0x68a, 42, 0 }, +{ 0x19a, 41, 1 }, +{ 0x18a, 42, 0 }, +{ 0x39a, 41, 1 }, +{ 0x38a, 42, 0 }, +{ 0x25a, 41, 1 }, +{ 0x24a, 42, 0 }, +{ 0x65a, 41, 1 }, +{ 0x64a, 42, 0 }, +{ 0x15a, 41, 1 }, +{ 0x14a, 42, 0 }, +{ 0x35a, 41, 1 }, +{ 0x34a, 42, 0 }, +{ 0xda, 41, 1 }, +{ 0xca, 42, 0 }, +{ 0x1da, 41, 1 }, +{ 0x1ca, 42, 0 }, +{ 0x7a, 41, 1 }, +{ 0x5a, 42, 0 }, +{ 0xfa, 41, 1 }, +{ 0xda, 42, 0 }, +{ 0x6, 41, 1 }, +{ 0x1e, 42, 1 }, +{ 0x76, 42, 0 }, +{ 0x926, 41, 0 }, +{ 0x1926, 41, 0 }, +{ 0x526, 41, 0 }, +{ 0xd26, 41, 0 }, +{ 0x326, 41, 0 }, +{ 0x726, 41, 0 }, +{ 0x4a6, 41, 0 }, +{ 0xca6, 41, 0 }, +{ 0x2a6, 41, 0 }, +{ 0x6a6, 41, 0 }, +{ 0x1a6, 41, 0 }, +{ 0x3a6, 41, 0 }, +{ 0x166, 41, 0 }, +{ 0x366, 41, 0 }, +{ 0xe6, 41, 0 }, +{ 0x1e6, 41, 0 }, +{ 0x16, 41, 1 }, +{ 0x3e, 42, 1 }, +{ 0xf6, 42, 0 }, +{ 0x24e, 41, 1 }, +{ 0x246, 42, 0 }, +{ 0x64e, 41, 1 }, +{ 0x646, 42, 0 }, +{ 0x14e, 41, 1 }, +{ 0x146, 42, 0 }, +{ 0x34e, 41, 1 }, +{ 0x346, 42, 0 }, +{ 0xce, 41, 1 }, +{ 0xc6, 42, 0 }, +{ 0x1ce, 41, 1 }, +{ 0x1c6, 42, 0 }, +{ 0x12e, 41, 1 }, +{ 0x126, 42, 0 }, +{ 0x32e, 41, 1 }, +{ 0x326, 42, 0 }, +{ 0xae, 41, 1 }, +{ 0xa6, 42, 0 }, +{ 0x1ae, 41, 1 }, +{ 0x1a6, 42, 0 }, +{ 0x6e, 41, 1 }, +{ 0x66, 42, 0 }, +{ 0xee, 41, 1 }, +{ 0xe6, 42, 0 }, +{ 0x3e, 41, 1 }, +{ 0x2e, 42, 0 }, +{ 0x7e, 41, 1 }, +{ 0x6e, 42, 0 }, +{ 0x1, 41, 1 }, +{ 0x7, 42, 1 }, +{ 0x1d, 42, 0 }, +{ 0x249, 41, 0 }, +{ 0x649, 41, 0 }, +{ 0x149, 41, 0 }, +{ 0x349, 41, 0 }, +{ 0xc9, 41, 0 }, +{ 0x1c9, 41, 0 }, +{ 0x129, 41, 0 }, +{ 0x329, 41, 0 }, +{ 0xa9, 41, 0 }, +{ 0x1a9, 41, 0 }, +{ 0x69, 41, 0 }, +{ 0xe9, 41, 0 }, +{ 0x59, 41, 0 }, +{ 0xd9, 41, 0 }, +{ 0x39, 41, 0 }, +{ 0x79, 41, 0 }, +{ 0x5, 41, 1 }, +{ 0xf, 42, 1 }, +{ 0x3d, 42, 0 }, +{ 0x93, 41, 1 }, +{ 0x91, 42, 0 }, +{ 0x193, 41, 1 }, +{ 0x191, 42, 0 }, +{ 0x53, 41, 1 }, +{ 0x51, 42, 0 }, +{ 0xd3, 41, 1 }, +{ 0xd1, 42, 0 }, +{ 0x33, 41, 1 }, +{ 0x31, 42, 0 }, +{ 0x73, 41, 1 }, +{ 0x71, 42, 0 }, +{ 0x4b, 41, 1 }, +{ 0x49, 42, 0 }, +{ 0xcb, 41, 1 }, +{ 0xc9, 42, 0 }, +{ 0x2b, 41, 1 }, +{ 0x29, 42, 0 }, +{ 0x6b, 41, 1 }, +{ 0x69, 42, 0 }, +{ 0x1b, 41, 1 }, +{ 0x19, 42, 0 }, +{ 0x3b, 41, 1 }, +{ 0x39, 42, 0 }, +{ 0xf, 41, 1 }, +{ 0xb, 42, 0 }, +{ 0x1f, 41, 1 }, +{ 0x1b, 42, 0 }, +{ 0x51, 39, 0 }, +{ 0xd1, 39, 1 }, +{ 0xc, 60, 1 }, +{ 0x6, 63, 1 }, +{ 0x3, 65, 1 }, +{ 0x3, 66, 0 }, +{ 0x31, 39, 1 }, +{ 0x11, 40, 0 }, +{ 0x71, 39, 1 }, +{ 0x31, 40, 1 }, +{ 0x4, 60, 1 }, +{ 0x2, 63, 1 }, +{ 0x1, 65, 1 }, +{ 0x1, 66, 0 }, +{ 0x29, 39, 0 }, +{ 0x69, 39, 1 }, +{ 0x28, 60, 1 }, +{ 0x5, 64, 0 }, +{ 0x19, 39, 1 }, +{ 0x9, 40, 0 }, +{ 0x39, 39, 1 }, +{ 0x19, 40, 1 }, +{ 0x5, 60, 1 }, +{ 0xa, 64, 0 }, +{ 0x15, 39, 0 }, +{ 0x35, 39, 1 }, +{ 0x3, 82, 1 }, +{ 0x3, 83, 1 }, +{ 0x3, 84, 1 }, +{ 0x3, 85, 0 }, +{ 0xd, 39, 1 }, +{ 0x5, 40, 0 }, +{ 0x1d, 39, 1 }, +{ 0xd, 40, 1 }, +{ 0x1, 82, 1 }, +{ 0x1, 83, 1 }, +{ 0x1, 84, 1 }, +{ 0x1, 85, 0 }, +{ 0xb, 39, 0 }, +{ 0x1b, 39, 1 }, +{ 0x14, 77, 1 }, +{ 0x5, 81, 0 }, +{ 0x7, 39, 1 }, +{ 0x3, 40, 0 }, +{ 0xf, 39, 1 }, +{ 0x7, 40, 1 }, +{ 0x5, 77, 1 }, +{ 0xa, 81, 0 }, +{ 0x51, 37, 1 }, +{ 0x50, 37, 0 }, +{ 0xd1, 37, 1 }, +{ 0xd0, 37, 0 }, +{ 0x31, 37, 1 }, +{ 0x30, 37, 1 }, +{ 0x11, 38, 1 }, +{ 0x10, 38, 0 }, +{ 0x71, 37, 1 }, +{ 0x70, 37, 1 }, +{ 0x31, 38, 1 }, +{ 0x30, 38, 0 }, +{ 0x29, 37, 1 }, +{ 0x28, 37, 0 }, +{ 0x69, 37, 1 }, +{ 0x68, 37, 0 }, +{ 0x19, 37, 1 }, +{ 0x18, 37, 1 }, +{ 0x9, 38, 1 }, +{ 0x8, 38, 0 }, +{ 0x39, 37, 1 }, +{ 0x38, 37, 1 }, +{ 0x19, 38, 1 }, +{ 0x18, 38, 0 }, +{ 0x15, 37, 1 }, +{ 0x14, 37, 0 }, +{ 0x35, 37, 1 }, +{ 0x34, 37, 0 }, +{ 0xd, 37, 1 }, +{ 0xc, 37, 1 }, +{ 0x5, 38, 1 }, +{ 0x4, 38, 0 }, +{ 0x1d, 37, 1 }, +{ 0x1c, 37, 1 }, +{ 0xd, 38, 1 }, +{ 0xc, 38, 0 }, +{ 0xb, 37, 1 }, +{ 0xa, 37, 0 }, +{ 0x1b, 37, 1 }, +{ 0x1a, 37, 0 }, +{ 0x7, 37, 1 }, +{ 0x6, 37, 1 }, +{ 0x3, 38, 1 }, +{ 0x2, 38, 0 }, +{ 0xf, 37, 1 }, +{ 0xe, 37, 1 }, +{ 0x7, 38, 1 }, +{ 0x6, 38, 0 }, +{ 0x8, 36, 0 }, +{ 0x18, 36, 0 }, +{ 0x2, 36, 1 }, +{ 0xc, 36, 0 }, +{ 0x1, 36, 1 }, +{ 0x4, 36, 0 }, +{ 0x1, 32, 1 }, +{ 0x1, 33, 1 }, +{ 0x1, 34, 0 }, +{ 0x1, 31, 0 }, +{ 0x1, 30, 0 }, +{ 0x51, 28, 0 }, +{ 0xd1, 28, 0 }, +{ 0x31, 28, 1 }, +{ 0x11, 29, 0 }, +{ 0x71, 28, 1 }, +{ 0x31, 29, 0 }, +{ 0x29, 28, 0 }, +{ 0x69, 28, 0 }, +{ 0x19, 28, 1 }, +{ 0x9, 29, 0 }, +{ 0x39, 28, 1 }, +{ 0x19, 29, 0 }, +{ 0x15, 28, 0 }, +{ 0x35, 28, 0 }, +{ 0xd, 28, 1 }, +{ 0x5, 29, 0 }, +{ 0x1d, 28, 1 }, +{ 0xd, 29, 0 }, +{ 0xb, 28, 0 }, +{ 0x1b, 28, 0 }, +{ 0x7, 28, 1 }, +{ 0x3, 29, 0 }, +{ 0xf, 28, 1 }, +{ 0x7, 29, 0 }, +{ 0xa2, 26, 0 }, +{ 0x1a2, 26, 0 }, +{ 0x62, 26, 1 }, +{ 0x22, 27, 0 }, +{ 0xe2, 26, 1 }, +{ 0x62, 27, 0 }, +{ 0x52, 26, 0 }, +{ 0xd2, 26, 0 }, +{ 0x32, 26, 1 }, +{ 0x12, 27, 0 }, +{ 0x72, 26, 1 }, +{ 0x32, 27, 0 }, +{ 0x2a, 26, 0 }, +{ 0x6a, 26, 0 }, +{ 0x1a, 26, 1 }, +{ 0xa, 27, 0 }, +{ 0x3a, 26, 1 }, +{ 0x1a, 27, 0 }, +{ 0x16, 26, 0 }, +{ 0x36, 26, 0 }, +{ 0xe, 26, 1 }, +{ 0x6, 27, 0 }, +{ 0x1e, 26, 1 }, +{ 0xe, 27, 0 }, +{ 0x51, 26, 0 }, +{ 0xd1, 26, 0 }, +{ 0x31, 26, 1 }, +{ 0x11, 27, 0 }, +{ 0x71, 26, 1 }, +{ 0x31, 27, 0 }, +{ 0x29, 26, 0 }, +{ 0x69, 26, 0 }, +{ 0x19, 26, 1 }, +{ 0x9, 27, 0 }, +{ 0x39, 26, 1 }, +{ 0x19, 27, 0 }, +{ 0x15, 26, 0 }, +{ 0x35, 26, 0 }, +{ 0xd, 26, 1 }, +{ 0x5, 27, 0 }, +{ 0x1d, 26, 1 }, +{ 0xd, 27, 0 }, +{ 0xb, 26, 0 }, +{ 0x1b, 26, 0 }, +{ 0x7, 26, 1 }, +{ 0x3, 27, 0 }, +{ 0xf, 26, 1 }, +{ 0x7, 27, 0 }, +{ 0x51, 24, 0 }, +{ 0xd1, 24, 0 }, +{ 0x31, 24, 1 }, +{ 0x11, 25, 0 }, +{ 0x71, 24, 1 }, +{ 0x31, 25, 0 }, +{ 0x29, 24, 0 }, +{ 0x69, 24, 0 }, +{ 0x19, 24, 1 }, +{ 0x9, 25, 0 }, +{ 0x39, 24, 1 }, +{ 0x19, 25, 0 }, +{ 0x15, 24, 0 }, +{ 0x35, 24, 0 }, +{ 0xd, 24, 1 }, +{ 0x5, 25, 0 }, +{ 0x1d, 24, 1 }, +{ 0xd, 25, 0 }, +{ 0xb, 24, 0 }, +{ 0x1b, 24, 0 }, +{ 0x7, 24, 1 }, +{ 0x3, 25, 0 }, +{ 0xf, 24, 1 }, +{ 0x7, 25, 0 }, +{ 0xa2, 22, 0 }, +{ 0x1a2, 22, 0 }, +{ 0x62, 22, 1 }, +{ 0x22, 23, 0 }, +{ 0xe2, 22, 1 }, +{ 0x62, 23, 0 }, +{ 0x52, 22, 0 }, +{ 0xd2, 22, 0 }, +{ 0x32, 22, 1 }, +{ 0x12, 23, 0 }, +{ 0x72, 22, 1 }, +{ 0x32, 23, 0 }, +{ 0x2a, 22, 0 }, +{ 0x6a, 22, 0 }, +{ 0x1a, 22, 1 }, +{ 0xa, 23, 0 }, +{ 0x3a, 22, 1 }, +{ 0x1a, 23, 0 }, +{ 0x16, 22, 0 }, +{ 0x36, 22, 0 }, +{ 0xe, 22, 1 }, +{ 0x6, 23, 0 }, +{ 0x1e, 22, 1 }, +{ 0xe, 23, 0 }, +{ 0x51, 22, 0 }, +{ 0xd1, 22, 0 }, +{ 0x31, 22, 1 }, +{ 0x11, 23, 0 }, +{ 0x71, 22, 1 }, +{ 0x31, 23, 0 }, +{ 0x29, 22, 0 }, +{ 0x69, 22, 0 }, +{ 0x19, 22, 1 }, +{ 0x9, 23, 0 }, +{ 0x39, 22, 1 }, +{ 0x19, 23, 0 }, +{ 0x15, 22, 0 }, +{ 0x35, 22, 0 }, +{ 0xd, 22, 1 }, +{ 0x5, 23, 0 }, +{ 0x1d, 22, 1 }, +{ 0xd, 23, 0 }, +{ 0xb, 22, 0 }, +{ 0x1b, 22, 0 }, +{ 0x7, 22, 1 }, +{ 0x3, 23, 0 }, +{ 0xf, 22, 1 }, +{ 0x7, 23, 0 }, +{ 0x51, 20, 1 }, +{ 0x50, 20, 0 }, +{ 0xd1, 20, 1 }, +{ 0xd0, 20, 0 }, +{ 0x31, 20, 1 }, +{ 0x30, 20, 1 }, +{ 0x11, 21, 1 }, +{ 0x10, 21, 0 }, +{ 0x71, 20, 1 }, +{ 0x70, 20, 1 }, +{ 0x31, 21, 1 }, +{ 0x30, 21, 0 }, +{ 0x29, 20, 1 }, +{ 0x28, 20, 0 }, +{ 0x69, 20, 1 }, +{ 0x68, 20, 0 }, +{ 0x19, 20, 1 }, +{ 0x18, 20, 1 }, +{ 0x9, 21, 1 }, +{ 0x8, 21, 0 }, +{ 0x39, 20, 1 }, +{ 0x38, 20, 1 }, +{ 0x19, 21, 1 }, +{ 0x18, 21, 0 }, +{ 0x15, 20, 1 }, +{ 0x14, 20, 0 }, +{ 0x35, 20, 1 }, +{ 0x34, 20, 0 }, +{ 0xd, 20, 1 }, +{ 0xc, 20, 1 }, +{ 0x5, 21, 1 }, +{ 0x4, 21, 0 }, +{ 0x1d, 20, 1 }, +{ 0x1c, 20, 1 }, +{ 0xd, 21, 1 }, +{ 0xc, 21, 0 }, +{ 0xb, 20, 1 }, +{ 0xa, 20, 0 }, +{ 0x1b, 20, 1 }, +{ 0x1a, 20, 0 }, +{ 0x7, 20, 1 }, +{ 0x6, 20, 1 }, +{ 0x3, 21, 1 }, +{ 0x2, 21, 0 }, +{ 0xf, 20, 1 }, +{ 0xe, 20, 1 }, +{ 0x7, 21, 1 }, +{ 0x6, 21, 0 }, +{ 0x8, 19, 0 }, +{ 0x18, 19, 0 }, +{ 0x2, 19, 1 }, +{ 0xc, 19, 0 }, +{ 0x1, 19, 1 }, +{ 0x4, 19, 0 }, +{ 0x51, 17, 0 }, +{ 0xd1, 17, 0 }, +{ 0x31, 17, 1 }, +{ 0x11, 18, 0 }, +{ 0x71, 17, 1 }, +{ 0x31, 18, 0 }, +{ 0x29, 17, 0 }, +{ 0x69, 17, 0 }, +{ 0x19, 17, 1 }, +{ 0x9, 18, 0 }, +{ 0x39, 17, 1 }, +{ 0x19, 18, 0 }, +{ 0x15, 17, 0 }, +{ 0x35, 17, 0 }, +{ 0xd, 17, 1 }, +{ 0x5, 18, 0 }, +{ 0x1d, 17, 1 }, +{ 0xd, 18, 0 }, +{ 0xb, 17, 0 }, +{ 0x1b, 17, 0 }, +{ 0x7, 17, 1 }, +{ 0x3, 18, 0 }, +{ 0xf, 17, 1 }, +{ 0x7, 18, 0 }, +{ 0x51, 15, 0 }, +{ 0xd1, 15, 0 }, +{ 0x31, 15, 1 }, +{ 0x11, 16, 0 }, +{ 0x71, 15, 1 }, +{ 0x31, 16, 0 }, +{ 0x29, 15, 0 }, +{ 0x69, 15, 0 }, +{ 0x19, 15, 1 }, +{ 0x9, 16, 0 }, +{ 0x39, 15, 1 }, +{ 0x19, 16, 0 }, +{ 0x15, 15, 0 }, +{ 0x35, 15, 0 }, +{ 0xd, 15, 1 }, +{ 0x5, 16, 0 }, +{ 0x1d, 15, 1 }, +{ 0xd, 16, 0 }, +{ 0xb, 15, 0 }, +{ 0x1b, 15, 0 }, +{ 0x7, 15, 1 }, +{ 0x3, 16, 0 }, +{ 0xf, 15, 1 }, +{ 0x7, 16, 0 }, +{ 0x288, 13, 0 }, +{ 0x688, 13, 0 }, +{ 0x188, 13, 1 }, +{ 0x88, 14, 0 }, +{ 0x388, 13, 1 }, +{ 0x188, 14, 0 }, +{ 0x148, 13, 0 }, +{ 0x348, 13, 0 }, +{ 0xc8, 13, 1 }, +{ 0x48, 14, 0 }, +{ 0x1c8, 13, 1 }, +{ 0xc8, 14, 0 }, +{ 0xa8, 13, 0 }, +{ 0x1a8, 13, 0 }, +{ 0x68, 13, 1 }, +{ 0x28, 14, 0 }, +{ 0xe8, 13, 1 }, +{ 0x68, 14, 0 }, +{ 0x58, 13, 0 }, +{ 0xd8, 13, 0 }, +{ 0x38, 13, 1 }, +{ 0x18, 14, 0 }, +{ 0x78, 13, 1 }, +{ 0x38, 14, 0 }, +{ 0x51, 13, 1 }, +{ 0xa0, 13, 0 }, +{ 0xd1, 13, 1 }, +{ 0x1a0, 13, 0 }, +{ 0x31, 13, 1 }, +{ 0x60, 13, 1 }, +{ 0x11, 14, 1 }, +{ 0x20, 14, 0 }, +{ 0x71, 13, 1 }, +{ 0xe0, 13, 1 }, +{ 0x31, 14, 1 }, +{ 0x60, 14, 0 }, +{ 0x29, 13, 1 }, +{ 0x50, 13, 0 }, +{ 0x69, 13, 1 }, +{ 0xd0, 13, 0 }, +{ 0x19, 13, 1 }, +{ 0x30, 13, 1 }, +{ 0x9, 14, 1 }, +{ 0x10, 14, 0 }, +{ 0x39, 13, 1 }, +{ 0x70, 13, 1 }, +{ 0x19, 14, 1 }, +{ 0x30, 14, 0 }, +{ 0x15, 13, 1 }, +{ 0x14, 13, 0 }, +{ 0x35, 13, 1 }, +{ 0x34, 13, 0 }, +{ 0xd, 13, 1 }, +{ 0xc, 13, 1 }, +{ 0x5, 14, 1 }, +{ 0x4, 14, 0 }, +{ 0x1d, 13, 1 }, +{ 0x1c, 13, 1 }, +{ 0xd, 14, 1 }, +{ 0xc, 14, 0 }, +{ 0xb, 13, 1 }, +{ 0xa, 13, 0 }, +{ 0x1b, 13, 1 }, +{ 0x1a, 13, 0 }, +{ 0x7, 13, 1 }, +{ 0x6, 13, 1 }, +{ 0x3, 14, 1 }, +{ 0x2, 14, 0 }, +{ 0xf, 13, 1 }, +{ 0xe, 13, 1 }, +{ 0x7, 14, 1 }, +{ 0x6, 14, 0 }, +{ 0x8, 12, 0 }, +{ 0x18, 12, 0 }, +{ 0x2, 12, 1 }, +{ 0xc, 12, 0 }, +{ 0x1, 12, 1 }, +{ 0x4, 12, 0 }, +{ 0x1, 11, 0 }, +{ 0x1, 10, 0 }, +{ 0x1, 9, 0 }, +{ 0x1, 8, 0 }, +{ 0x1, 7, 0 }, +{ 0x1, 6, 0 }, +{ 0x1, 5, 0 }, +{ 0x1, 4, 0 }, +{ 0x1, 3, 0 }, +{ 0x1, 1, 0 }, +{ 0x1, 0, 0 }, +}; + diff -urN test4.official/arch/ia64/kdb/ia64-asmtab.h test4.official.kdb/arch/ia64/kdb/ia64-asmtab.h --- test4.official/arch/ia64/kdb/ia64-asmtab.h Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/arch/ia64/kdb/ia64-asmtab.h Fri Aug 11 11:25:45 2000 @@ -0,0 +1,145 @@ +/* ia64-asmtab.h -- Header for compacted IA-64 opcode tables. + Copyright (C) 1999 Free Software Foundation, Inc. + Contributed by Bob Manson of Cygnus Support + + This file is part of GDB, GAS, and the GNU binutils. + + GDB, GAS, and the GNU binutils are free software; you can redistribute + them and/or modify them under the terms of the GNU General Public + License as published by the Free Software Foundation; either version + 2, or (at your option) any later version. + + GDB, GAS, and the GNU binutils are distributed in the hope that they + will be useful, but WITHOUT ANY WARRANTY; without even the implied + warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See + the GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this file; see the file COPYING. If not, write to the + Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA + 02111-1307, USA. */ + +#ifndef IA64_ASMTAB_H +#define IA64_ASMTAB_H + +#include "ia64.h" + +/* The primary opcode table is made up of the following: */ +struct ia64_main_table +{ + /* The entry in the string table that corresponds to the name of this + opcode. */ + unsigned short name_index; + + /* The type of opcode; corresponds to the TYPE field in + struct ia64_opcode. */ + unsigned char opcode_type; + + /* The number of outputs for this opcode. */ + unsigned char num_outputs; + + /* The base insn value for this opcode. It may be modified by completers. */ + ia64_insn opcode; + + /* The mask of valid bits in OPCODE. Zeros indicate operand fields. */ + ia64_insn mask; + + /* The operands of this instruction. Corresponds to the OPERANDS field + in struct ia64_opcode. */ + unsigned char operands[5]; + + /* The flags for this instruction. Corresponds to the FLAGS field in + struct ia64_opcode. */ + short flags; + + /* The tree of completers for this instruction; this is an offset into + completer_table. */ + short completers; +}; + +/* Each instruction has a set of possible "completers", or additional + suffixes that can alter the instruction's behavior, and which has + potentially different dependencies. + + The completer entries modify certain bits in the instruction opcode. + Which bits are to be modified are marked by the BITS, MASK and + OFFSET fields. The completer entry may also note dependencies for the + opcode. + + These completers are arranged in a DAG; the pointers are indexes + into the completer_table array. The completer DAG is searched by + find_completer () and ia64_find_matching_opcode (). + + Note that each completer needs to be applied in turn, so that if we + have the instruction + cmp.lt.unc + the completer entries for both "lt" and "unc" would need to be applied + to the opcode's value. + + Some instructions do not require any completers; these contain an + empty completer entry. Instructions that require a completer do + not contain an empty entry. + + Terminal completers (those completers that validly complete an + instruction) are marked by having the TERMINAL_COMPLETER flag set. + + Only dependencies listed in the terminal completer for an opcode are + considered to apply to that opcode instance. */ + +struct ia64_completer_table +{ + /* The bit value that this completer sets. */ + unsigned int bits; + + /* And its mask. 1s are bits that are to be modified in the + instruction. */ + unsigned int mask; + + /* The entry in the string table that corresponds to the name of this + completer. */ + unsigned short name_index; + + /* An alternative completer, or -1 if this is the end of the chain. */ + short alternative; + + /* A pointer to the DAG of completers that can potentially follow + this one, or -1. */ + short subentries; + + /* The bit offset in the instruction where BITS and MASK should be + applied. */ + unsigned char offset : 7; + + unsigned char terminal_completer : 1; + + /* Index into the dependency list table */ + short dependencies; +}; + +/* This contains sufficient information for the disassembler to resolve + the complete name of the original instruction. */ +struct ia64_dis_names +{ + /* COMPLETER_INDEX represents the tree of completers that make up + the instruction. The LSB represents the top of the tree for the + specified instruction. + + A 0 bit indicates to go to the next alternate completer via the + alternative field; a 1 bit indicates that the current completer + is part of the instruction, and to go down the subentries index. + We know we've reached the final completer when we run out of 1 + bits. + + There is always at least one 1 bit. */ + unsigned int completer_index : 20; + + /* The index in the main_table[] array for the instruction. */ + unsigned short insn_index : 11; + + /* If set, the next entry in this table is an alternate possibility + for this instruction encoding. Which one to use is determined by + the instruction type and other factors (see opcode_verify ()). */ + unsigned int next_flag : 1; +}; + +#endif diff -urN test4.official/arch/ia64/kdb/ia64-dis.c test4.official.kdb/arch/ia64/kdb/ia64-dis.c --- test4.official/arch/ia64/kdb/ia64-dis.c Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/arch/ia64/kdb/ia64-dis.c Fri Aug 11 11:25:45 2000 @@ -0,0 +1,265 @@ +/* ia64-dis.c -- Disassemble ia64 instructions + Copyright (C) 1998, 1999 Free Software Foundation, Inc. + Contributed by David Mosberger-Tang + + This file is part of GDB, GAS, and the GNU binutils. + + GDB, GAS, and the GNU binutils are free software; you can redistribute + them and/or modify them under the terms of the GNU General Public + License as published by the Free Software Foundation; either version + 2, or (at your option) any later version. + + GDB, GAS, and the GNU binutils are distributed in the hope that they + will be useful, but WITHOUT ANY WARRANTY; without even the implied + warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See + the GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this file; see the file COPYING. If not, write to the + Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA + 02111-1307, USA. */ + +#include +#include + +#include "dis-asm.h" +#include "ia64.h" + +#define NELEMS(a) ((int) (sizeof (a) / sizeof (a[0]))) + +/* Disassemble ia64 instruction. */ + +/* Return the instruction type for OPCODE found in unit UNIT. */ + +static enum ia64_insn_type +unit_to_type (ia64_insn opcode, enum ia64_unit unit) +{ + enum ia64_insn_type type; + int op; + + op = IA64_OP (opcode); + + if (op >= 8 && (unit == IA64_UNIT_I || unit == IA64_UNIT_M)) + { + type = IA64_TYPE_A; + } + else + { + switch (unit) + { + case IA64_UNIT_I: + type = IA64_TYPE_I; break; + case IA64_UNIT_M: + type = IA64_TYPE_M; break; + case IA64_UNIT_B: + type = IA64_TYPE_B; break; + case IA64_UNIT_F: + type = IA64_TYPE_F; break; + case IA64_UNIT_L: + case IA64_UNIT_X: + type = IA64_TYPE_X; break; + default: + type = -1; + } + } + return type; +} + +int +print_insn_ia64 (bfd_vma memaddr, struct disassemble_info *info) +{ + ia64_insn t0, t1, slot[3], template, s_bit, insn; + int slotnum, j, status, need_comma, retval, slot_multiplier; + const struct ia64_operand *odesc; + struct ia64_opcode *idesc = 0; + const char *err, *str, *tname; + BFD_HOST_U_64_BIT value; + bfd_byte bundle[16]; + enum ia64_unit unit; + char regname[16]; + + if (info->bytes_per_line == 0) + info->bytes_per_line = 6; + info->display_endian = info->endian; + + slot_multiplier = info->bytes_per_line; + retval = slot_multiplier; + + slotnum = (((long) memaddr) & 0xf) / slot_multiplier; + if (slotnum > 2) + return -1; + + memaddr -= (memaddr & 0xf); + status = (*info->read_memory_func) (memaddr, bundle, sizeof (bundle), info); + if (status != 0) + { + (*info->memory_error_func) (status, memaddr, info); + return -1; + } + /* bundles are always in little-endian byte order */ + t0 = bfd_getl64 (bundle); + t1 = bfd_getl64 (bundle + 8); + s_bit = t0 & 1; + template = (t0 >> 1) & 0xf; + slot[0] = (t0 >> 5) & 0x1ffffffffffLL; + slot[1] = ((t0 >> 46) & 0x3ffff) | ((t1 & 0x7fffff) << 18); + slot[2] = (t1 >> 23) & 0x1ffffffffffLL; + + tname = ia64_templ_desc[template].name; + if (slotnum == 0) + (*info->fprintf_func) (info->stream, "[%s] ", tname); + else + (*info->fprintf_func) (info->stream, " ", tname); + + unit = ia64_templ_desc[template].exec_unit[slotnum]; + + if (template == 2 && slotnum == 1) + { + /* skip L slot in MLI template: */ + slotnum = 2; + retval += slot_multiplier; + } + + insn = slot[slotnum]; + + if (unit == IA64_UNIT_NIL) + goto decoding_failed; + + idesc = ia64_dis_opcode (insn, unit_to_type (insn, unit)); + if (idesc == NULL) + goto decoding_failed; + + /* print predicate, if any: */ + + if ((idesc->flags & IA64_OPCODE_NO_PRED) + || (insn & 0x3f) == 0) + (*info->fprintf_func) (info->stream, " "); + else + (*info->fprintf_func) (info->stream, "(p%02d) ", (int)(insn & 0x3f)); + + /* now the actual instruction: */ + + (*info->fprintf_func) (info->stream, "%s", idesc->name); + if (idesc->operands[0]) + (*info->fprintf_func) (info->stream, " "); + + need_comma = 0; + for (j = 0; j < NELEMS (idesc->operands) && idesc->operands[j]; ++j) + { + odesc = elf64_ia64_operands + idesc->operands[j]; + + if (need_comma) + (*info->fprintf_func) (info->stream, ","); + + if (odesc - elf64_ia64_operands == IA64_OPND_IMMU64) + { + /* special case of 64 bit immediate load: */ + value = ((insn >> 13) & 0x7f) | (((insn >> 27) & 0x1ff) << 7) + | (((insn >> 22) & 0x1f) << 16) | (((insn >> 21) & 0x1) << 21) + | (slot[1] << 22) | (((insn >> 36) & 0x1) << 63); + } + else if (odesc - elf64_ia64_operands == IA64_OPND_IMMU62) + { + /* 62-bit immediate for nop.x/break.x */ + value = ((slot[1] & 0x1ffffffffffLL) << 21) + | (((insn >> 36) & 0x1) << 20) + | ((insn >> 6) & 0xfffff); + } + else + { + err = (*odesc->extract) (odesc, insn, &value); + if (err) + { + (*info->fprintf_func) (info->stream, "%s", err); + goto done; + } + } + + switch (odesc->class) + { + case IA64_OPND_CLASS_CST: + (*info->fprintf_func) (info->stream, "%s", odesc->str); + break; + + case IA64_OPND_CLASS_REG: + if (odesc->str[0] == 'a' && odesc->str[1] == 'r') + { + switch (value) + { + case 0: case 1: case 2: case 3: + case 4: case 5: case 6: case 7: + sprintf (regname, "ar.k%u", (unsigned int) value); + break; + case 16: strcpy (regname, "ar.rsc"); break; + case 17: strcpy (regname, "ar.bsp"); break; + case 18: strcpy (regname, "ar.bspstore"); break; + case 19: strcpy (regname, "ar.rnat"); break; + case 32: strcpy (regname, "ar.ccv"); break; + case 36: strcpy (regname, "ar.unat"); break; + case 40: strcpy (regname, "ar.fpsr"); break; + case 44: strcpy (regname, "ar.itc"); break; + case 64: strcpy (regname, "ar.pfs"); break; + case 65: strcpy (regname, "ar.lc"); break; + case 66: strcpy (regname, "ar.ec"); break; + default: + sprintf (regname, "ar%u", (unsigned int) value); + break; + } + (*info->fprintf_func) (info->stream, "%s", regname); + } + else + (*info->fprintf_func) (info->stream, "%s%d", odesc->str, (int)value); + break; + + case IA64_OPND_CLASS_IND: + (*info->fprintf_func) (info->stream, "%s[r%d]", odesc->str, (int)value); + break; + + case IA64_OPND_CLASS_ABS: + str = 0; + if (odesc - elf64_ia64_operands == IA64_OPND_MBTYPE4) + switch (value) + { + case 0x0: str = "@brcst"; break; + case 0x8: str = "@mix"; break; + case 0x9: str = "@shuf"; break; + case 0xa: str = "@alt"; break; + case 0xb: str = "@rev"; break; + } + + if (str) + (*info->fprintf_func) (info->stream, "%s", str); + else if (odesc->flags & IA64_OPND_FLAG_DECIMAL_SIGNED) + (*info->fprintf_func) (info->stream, "%ld", value); + else if (odesc->flags & IA64_OPND_FLAG_DECIMAL_UNSIGNED) + (*info->fprintf_func) (info->stream, "%lu", value); + else + (*info->fprintf_func) (info->stream, "0x%lx", value); + break; + + case IA64_OPND_CLASS_REL: + (*info->print_address_func) (memaddr + value, info); + break; + } + + need_comma = 1; + if (j + 1 == idesc->num_outputs) + { + (*info->fprintf_func) (info->stream, "="); + need_comma = 0; + } + } + if (slotnum + 1 == ia64_templ_desc[template].group_boundary + || ((slotnum == 2) && s_bit)) + (*info->fprintf_func) (info->stream, ";;"); + + done: + if (slotnum == 2) + retval += 16 - 3*slot_multiplier; + + return retval; + + decoding_failed: + (*info->fprintf_func) (info->stream, " data8 %#011lx", insn); + goto done; +} diff -urN test4.official/arch/ia64/kdb/ia64-opc.c test4.official.kdb/arch/ia64/kdb/ia64-opc.c --- test4.official/arch/ia64/kdb/ia64-opc.c Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/arch/ia64/kdb/ia64-opc.c Fri Aug 11 11:25:45 2000 @@ -0,0 +1,788 @@ +/* ia64-opc.c -- Functions to access the compacted opcode table + Copyright (C) 1999 Free Software Foundation, Inc. + Written by Bob Manson of Cygnus Solutions, + + This file is part of GDB, GAS, and the GNU binutils. + + GDB, GAS, and the GNU binutils are free software; you can redistribute + them and/or modify them under the terms of the GNU General Public + License as published by the Free Software Foundation; either version + 2, or (at your option) any later version. + + GDB, GAS, and the GNU binutils are distributed in the hope that they + will be useful, but WITHOUT ANY WARRANTY; without even the implied + warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See + the GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this file; see the file COPYING. If not, write to the + Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA + 02111-1307, USA. */ + +#include +#include +#include + +#include "ia64-asmtab.h" +#include "ia64-asmtab.c" + +const struct ia64_templ_desc ia64_templ_desc[16] = + { + { 0, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_I }, "MII" }, /* 0 */ + { 2, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_I }, "MII" }, + { 0, { IA64_UNIT_M, IA64_UNIT_L, IA64_UNIT_X }, "MLX" }, + { 0, { 0, }, "-3-" }, + { 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_I }, "MMI" }, /* 4 */ + { 1, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_I }, "MMI" }, + { 0, { IA64_UNIT_M, IA64_UNIT_F, IA64_UNIT_I }, "MFI" }, + { 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_F }, "MMF" }, + { 0, { IA64_UNIT_M, IA64_UNIT_I, IA64_UNIT_B }, "MIB" }, /* 8 */ + { 0, { IA64_UNIT_M, IA64_UNIT_B, IA64_UNIT_B }, "MBB" }, + { 0, { 0, }, "-a-" }, + { 0, { IA64_UNIT_B, IA64_UNIT_B, IA64_UNIT_B }, "BBB" }, + { 0, { IA64_UNIT_M, IA64_UNIT_M, IA64_UNIT_B }, "MMB" }, /* c */ + { 0, { 0, }, "-d-" }, + { 0, { IA64_UNIT_M, IA64_UNIT_F, IA64_UNIT_B }, "MFB" }, + { 0, { 0, }, "-f-" }, + }; + +#define abort() dis_abort(__LINE__) + +static void +dis_abort(int line) +{ + panic("Aborting dissembler in %s @ line %d\n", __FILE__, line); +} + + +/* Copy the prefix contained in *PTR (up to a '.' or a NUL) to DEST. + PTR will be adjusted to point to the start of the next portion + of the opcode, or at the NUL character. */ + +static void +get_opc_prefix (ptr, dest) + const char **ptr; + char *dest; +{ + char *c = strchr (*ptr, '.'); + if (c != NULL) + { + memcpy (dest, *ptr, c - *ptr); + dest[c - *ptr] = '\0'; + *ptr = c + 1; + } + else + { + int l = strlen (*ptr); + memcpy (dest, *ptr, l); + dest[l] = '\0'; + *ptr += l; + } +} + +/* Find the index of the entry in the string table corresponding to + STR; return -1 if one does not exist. */ + +static short +find_string_ent (str) + const char *str; +{ + short start = 0; + short end = sizeof (ia64_strings) / sizeof (const char *); + short i = (start + end) / 2; + + if (strcmp (str, ia64_strings[end - 1]) > 0) + { + return -1; + } + while (start <= end) + { + int c = strcmp (str, ia64_strings[i]); + if (c < 0) + { + end = i - 1; + } + else if (c == 0) + { + return i; + } + else + { + start = i + 1; + } + i = (start + end) / 2; + } + return -1; +} + +/* Find the opcode in the main opcode table whose name is STRINGINDEX, or + return -1 if one does not exist. */ + +static short +find_main_ent (nameindex) + short nameindex; +{ + short start = 0; + short end = sizeof (main_table) / sizeof (struct ia64_main_table); + short i = (start + end) / 2; + + if (nameindex < main_table[0].name_index + || nameindex > main_table[end - 1].name_index) + { + return -1; + } + while (start <= end) + { + if (nameindex < main_table[i].name_index) + { + end = i - 1; + } + else if (nameindex == main_table[i].name_index) + { + while (i > 0 && main_table[i - 1].name_index == nameindex) + { + i--; + } + return i; + } + else + { + start = i + 1; + } + i = (start + end) / 2; + } + return -1; +} + +/* Find the index of the entry in the completer table that is part of + MAIN_ENT (starting from PREV_COMPLETER) that matches NAME, or + return -1 if one does not exist. */ + +static short +find_completer (main_ent, prev_completer, name) + short main_ent; + short prev_completer; + const char *name; +{ + short name_index = find_string_ent (name); + + if (name_index < 0) + { + return -1; + } + + if (prev_completer == -1) + { + prev_completer = main_table[main_ent].completers; + } + else + { + prev_completer = completer_table[prev_completer].subentries; + } + + while (prev_completer != -1) + { + if (completer_table[prev_completer].name_index == name_index) + { + return prev_completer; + } + prev_completer = completer_table[prev_completer].alternative; + } + return -1; +} + +/* Apply the completer referred to by COMPLETER_INDEX to OPCODE, and + return the result. */ + +static ia64_insn +apply_completer (opcode, completer_index) + ia64_insn opcode; + int completer_index; +{ + ia64_insn mask = completer_table[completer_index].mask; + ia64_insn bits = completer_table[completer_index].bits; + int shiftamt = (completer_table[completer_index].offset & 63); + + mask = mask << shiftamt; + bits = bits << shiftamt; + opcode = (opcode & ~mask) | bits; + return opcode; +} + +/* Extract BITS number of bits starting from OP_POINTER + BITOFFSET in + the dis_table array, and return its value. (BITOFFSET is numbered + starting from MSB to LSB, so a BITOFFSET of 0 indicates the MSB of the + first byte in OP_POINTER.) */ + +static int +extract_op_bits (op_pointer, bitoffset, bits) + int op_pointer; + int bitoffset; + int bits; +{ + int res = 0; + + op_pointer += (bitoffset / 8); + + if (bitoffset % 8) + { + unsigned int op = dis_table[op_pointer++]; + int numb = 8 - (bitoffset % 8); + int mask = (1 << numb) - 1; + int bata = (bits < numb) ? bits : numb; + int delta = numb - bata; + + res = (res << bata) | ((op & mask) >> delta); + bitoffset += bata; + bits -= bata; + } + while (bits >= 8) + { + res = (res << 8) | (dis_table[op_pointer++] & 255); + bits -= 8; + } + if (bits > 0) + { + unsigned int op = (dis_table[op_pointer++] & 255); + res = (res << bits) | (op >> (8 - bits)); + } + return res; +} + +/* Examine the state machine entry at OP_POINTER in the dis_table + array, and extract its values into OPVAL and OP. The length of the + state entry in bits is returned. */ + +static int +extract_op (op_pointer, opval, op) + int op_pointer; + int *opval; + unsigned int *op; +{ + int oplen = 5; + + *op = dis_table[op_pointer]; + + if ((*op) & 0x40) + { + opval[0] = extract_op_bits (op_pointer, oplen, 5); + oplen += 5; + } + switch ((*op) & 0x30) + { + case 0x10: + { + opval[1] = extract_op_bits (op_pointer, oplen, 8); + oplen += 8; + opval[1] += op_pointer; + break; + } + case 0x20: + { + opval[1] = extract_op_bits (op_pointer, oplen, 16); + if (! (opval[1] & 32768)) + { + opval[1] += op_pointer; + } + oplen += 16; + break; + } + case 0x30: + { + oplen--; + opval[2] = extract_op_bits (op_pointer, oplen, 12); + oplen += 12; + opval[2] |= 32768; + break; + } + } + if (((*op) & 0x08) && (((*op) & 0x30) != 0x30)) + { + opval[2] = extract_op_bits (op_pointer, oplen, 16); + oplen += 16; + if (! (opval[2] & 32768)) + { + opval[2] += op_pointer; + } + } + return oplen; +} + +/* Returns a non-zero value if the opcode in the main_table list at + PLACE matches OPCODE and is of type TYPE. */ + +static int +opcode_verify (opcode, place, type) + ia64_insn opcode; + int place; + enum ia64_insn_type type; +{ + if (main_table[place].opcode_type != type) + { + return 0; + } + if (main_table[place].flags + & (IA64_OPCODE_F2_EQ_F3 | IA64_OPCODE_LEN_EQ_64MCNT)) + { + const struct ia64_operand *o1, *o2; + ia64_insn f2, f3; + + if (main_table[place].flags & IA64_OPCODE_F2_EQ_F3) + { + o1 = elf64_ia64_operands + IA64_OPND_F2; + o2 = elf64_ia64_operands + IA64_OPND_F3; + (*o1->extract) (o1, opcode, &f2); + (*o2->extract) (o2, opcode, &f3); + if (f2 != f3) + return 0; + } + else + { + ia64_insn len, count; + + /* length must equal 64-count: */ + o1 = elf64_ia64_operands + IA64_OPND_LEN6; + o2 = elf64_ia64_operands + main_table[place].operands[2]; + (*o1->extract) (o1, opcode, &len); + (*o2->extract) (o2, opcode, &count); + if (len != 64 - count) + return 0; + } + } + return 1; +} + +/* Find an instruction entry in the ia64_dis_names array that matches + opcode OPCODE and is of type TYPE. Returns either a positive index + into the array, or a negative value if an entry for OPCODE could + not be found. */ + +static int +locate_opcode_ent (opcode, type) + ia64_insn opcode; + enum ia64_insn_type type; +{ + int currtest[41]; + int bitpos[41]; + int op_ptr[41]; + int currstatenum = 0; + + currtest[currstatenum] = 0; + op_ptr[currstatenum] = 0; + bitpos[currstatenum] = 40; + + while (1) + { + int op_pointer = op_ptr[currstatenum]; + unsigned int op; + int currbitnum = bitpos[currstatenum]; + int oplen; + int opval[3]; + int next_op; + int currbit; + + oplen = extract_op (op_pointer, opval, &op); + + bitpos[currstatenum] = currbitnum; + + /* Skip opval[0] bits in the instruction. */ + if (op & 0x40) + { + currbitnum -= opval[0]; + } + + /* The value of the current bit being tested. */ + currbit = opcode & (((ia64_insn) 1) << currbitnum) ? 1 : 0; + next_op = -1; + + /* We always perform the tests specified in the current state in + a particular order, falling through to the next test if the + previous one failed. */ + switch (currtest[currstatenum]) + { + case 0: + currtest[currstatenum]++; + if (currbit == 0 && (op & 0x80)) + { + /* Check for a zero bit. If this test solely checks for + a zero bit, we can check for up to 8 consecutive zero + bits (the number to check is specified by the lower 3 + bits in the state code.) + + If the state instruction matches, we go to the very + next state instruction; otherwise, try the next test. */ + + if ((op & 0xf8) == 0x80) + { + int count = op & 0x7; + int x; + + for (x = 0; x <= count; x++) + { + int i = + opcode & (((ia64_insn) 1) << (currbitnum - x)) ? 1 : 0; + if (i) + { + break; + } + } + if (x > count) + { + next_op = op_pointer + ((oplen + 7) / 8); + currbitnum -= count; + break; + } + } + else if (! currbit) + { + next_op = op_pointer + ((oplen + 7) / 8); + break; + } + } + /* FALLTHROUGH */ + case 1: + /* If the bit in the instruction is one, go to the state + instruction specified by opval[1]. */ + currtest[currstatenum]++; + if (currbit && (op & 0x30) != 0 && ((op & 0x30) != 0x30)) + { + next_op = opval[1]; + break; + } + /* FALLTHROUGH */ + case 2: + /* Don't care. Skip the current bit and go to the state + instruction specified by opval[2]. + + An encoding of 0x30 is special; this means that a 12-bit + offset into the ia64_dis_names[] array is specified. */ + currtest[currstatenum]++; + if ((op & 0x08) || ((op & 0x30) == 0x30)) + { + next_op = opval[2]; + break; + } + } + + /* If bit 15 is set in the address of the next state, an offset + in the ia64_dis_names array was specified instead. We then + check to see if an entry in the list of opcodes matches the + opcode we were given; if so, we have succeeded. */ + + if ((next_op >= 0) && (next_op & 32768)) + { + short disent = next_op & 32767; + + if (next_op > 65535) + { + abort (); + } + + /* Run through the list of opcodes to check, trying to find + one that matches. */ + while (disent >= 0) + { + int place = ia64_dis_names[disent].insn_index; + + if (opcode_verify (opcode, place, type)) + { + break; + } + if (ia64_dis_names[disent].next_flag) + { + disent++; + } + else + { + disent = -1; + } + } + + if (disent >= 0) + { + return disent; + } + else + { + /* Failed to match; try the next test in this state. */ + next_op = -2; + } + } + + /* next_op == -1 is "back up to the previous state". + next_op == -2 is "stay in this state and try the next test". + Otherwise, transition to the state indicated by next_op. */ + + if (next_op == -1) + { + currstatenum--; + if (currstatenum < 0) + { + return -1; + } + } + else if (next_op >= 0) + { + currstatenum++; + bitpos[currstatenum] = currbitnum - 1; + op_ptr[currstatenum] = next_op; + currtest[currstatenum] = 0; + } + } +} + +/* Construct an ia64_opcode entry based on OPCODE, NAME and PLACE. */ +#if 1 +static struct ia64_opcode * +make_ia64_opcode (opcode, name, place, depind) + ia64_insn opcode; + const char *name; + int place; + int depind; +{ +#define MAX_NAME 16 + static struct ia64_opcode stat_res; + static char stat_name[MAX_NAME]; + + struct ia64_opcode *res = & stat_res; + + res->name = stat_name; + + strcpy(stat_name, name); + + res->type = main_table[place].opcode_type; + res->num_outputs = main_table[place].num_outputs; + res->opcode = opcode; + res->mask = main_table[place].mask; + res->operands[0] = main_table[place].operands[0]; + res->operands[1] = main_table[place].operands[1]; + res->operands[2] = main_table[place].operands[2]; + res->operands[3] = main_table[place].operands[3]; + res->operands[4] = main_table[place].operands[4]; + res->flags = main_table[place].flags; + res->ent_index = place; + res->dependencies = &op_dependencies[depind]; + return res; +} +#else +static struct ia64_opcode * +make_ia64_opcode (opcode, name, place, depind) + ia64_insn opcode; + const char *name; + int place; + int depind; +{ + struct ia64_opcode *res = +/* (struct ia64_opcode *) xmalloc (sizeof (struct ia64_opcode));*/ + (struct ia64_opcode *) malloc (sizeof (struct ia64_opcode)); +/* res->name = xstrdup (name);*/ + res->name = strdup (name); +printf("make_opcode: malloc=%p:%p\n", res, res->name); + res->type = main_table[place].opcode_type; + res->num_outputs = main_table[place].num_outputs; + res->opcode = opcode; + res->mask = main_table[place].mask; + res->operands[0] = main_table[place].operands[0]; + res->operands[1] = main_table[place].operands[1]; + res->operands[2] = main_table[place].operands[2]; + res->operands[3] = main_table[place].operands[3]; + res->operands[4] = main_table[place].operands[4]; + res->flags = main_table[place].flags; + res->ent_index = place; + res->dependencies = &op_dependencies[depind]; + return res; +} +#endif + +/* Determine the ia64_opcode entry for the opcode specified by INSN + and TYPE. If a valid entry is not found, return NULL. */ +struct ia64_opcode * +ia64_dis_opcode (insn, type) + ia64_insn insn; + enum ia64_insn_type type; +{ + int disent = locate_opcode_ent (insn, type); + + if (disent < 0) + { + return NULL; + } + else + { + unsigned int cb = ia64_dis_names[disent].completer_index; + static char name[128]; + int place = ia64_dis_names[disent].insn_index; + int ci = main_table[place].completers; + ia64_insn tinsn = main_table[place].opcode; + + strcpy (name, ia64_strings [main_table[place].name_index]); + + while (cb) + { + if (cb & 1) + { + int cname = completer_table[ci].name_index; + + tinsn = apply_completer (tinsn, ci); + + if (ia64_strings[cname][0] != '\0') + { + strcat (name, "."); + strcat (name, ia64_strings[cname]); + } + if (cb != 1) + { + ci = completer_table[ci].subentries; + } + } + else + { + ci = completer_table[ci].alternative; + } + if (ci < 0) + { + abort (); + } + cb = cb >> 1; + } + if (tinsn != (insn & main_table[place].mask)) + { + abort (); + } + return make_ia64_opcode (insn, name, place, + completer_table[ci].dependencies); + } +} + +/* Search the main_opcode table starting from PLACE for an opcode that + matches NAME. Return NULL if one is not found. */ + +static struct ia64_opcode * +ia64_find_matching_opcode (name, place) + const char *name; + short place; +{ + char op[129]; + const char *suffix; + short name_index; + + if (strlen (name) > 128) + { + return NULL; + } + suffix = name; + get_opc_prefix (&suffix, op); + name_index = find_string_ent (op); + if (name_index < 0) + { + return NULL; + } + + while (main_table[place].name_index == name_index) + { + const char *curr_suffix = suffix; + ia64_insn curr_insn = main_table[place].opcode; + short completer = -1; + + do { + if (suffix[0] == '\0') + { + completer = find_completer (place, completer, suffix); + } + else + { + get_opc_prefix (&curr_suffix, op); + completer = find_completer (place, completer, op); + } + if (completer != -1) + { + curr_insn = apply_completer (curr_insn, completer); + } + } while (completer != -1 && curr_suffix[0] != '\0'); + + if (completer != -1 && curr_suffix[0] == '\0' + && completer_table[completer].terminal_completer) + { + int depind = completer_table[completer].dependencies; + return make_ia64_opcode (curr_insn, name, place, depind); + } + else + { + place++; + } + } + return NULL; +} + +/* Find the next opcode after PREV_ENT that matches PREV_ENT, or return NULL + if one does not exist. + + It is the caller's responsibility to invoke ia64_free_opcode () to + release any resources used by the returned entry. */ + +struct ia64_opcode * +ia64_find_next_opcode (prev_ent) + struct ia64_opcode *prev_ent; +{ + return ia64_find_matching_opcode (prev_ent->name, + prev_ent->ent_index + 1); +} + +/* Find the first opcode that matches NAME, or return NULL if it does + not exist. + + It is the caller's responsibility to invoke ia64_free_opcode () to + release any resources used by the returned entry. */ + +struct ia64_opcode * +ia64_find_opcode (name) + const char *name; +{ + char op[129]; + const char *suffix; + short place; + short name_index; + + if (strlen (name) > 128) + { + return NULL; + } + suffix = name; + get_opc_prefix (&suffix, op); + name_index = find_string_ent (op); + if (name_index < 0) + { + return NULL; + } + + place = find_main_ent (name_index); + + if (place < 0) + { + return NULL; + } + return ia64_find_matching_opcode (name, place); +} + +#if 0 +void +ia64_free_opcode (ent) + struct ia64_opcode *ent; +{ + free ((void *)ent->name); + free (ent); +} + +#endif + +const struct ia64_dependency * +ia64_find_dependency (index) + int index; +{ + index = DEP(index); + + if (index < 0 || index >= sizeof(dependencies) / sizeof(dependencies[0])) + return NULL; + + return &dependencies[index]; +} diff -urN test4.official/arch/ia64/kdb/ia64-opc.h test4.official.kdb/arch/ia64/kdb/ia64-opc.h --- test4.official/arch/ia64/kdb/ia64-opc.h Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/arch/ia64/kdb/ia64-opc.h Fri Aug 11 11:25:45 2000 @@ -0,0 +1,129 @@ +/* ia64-opc.h -- IA-64 opcode table. + Copyright (C) 1998, 1999 Free Software Foundation, Inc. + Contributed by David Mosberger-Tang + + This file is part of GDB, GAS, and the GNU binutils. + + GDB, GAS, and the GNU binutils are free software; you can redistribute + them and/or modify them under the terms of the GNU General Public + License as published by the Free Software Foundation; either version + 2, or (at your option) any later version. + + GDB, GAS, and the GNU binutils are distributed in the hope that they + will be useful, but WITHOUT ANY WARRANTY; without even the implied + warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See + the GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this file; see the file COPYING. If not, write to the + Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA + 02111-1307, USA. */ + +#ifndef IA64_OPC_H +#define IA64_OPC_H + +#include "ia64.h" + +/* define a couple of abbreviations: */ + +#define bOp(x) (((ia64_insn) ((x) & 0xf)) << 37) +#define mOp bOp (-1) +#define Op(x) bOp (x), mOp + +#define FIRST IA64_OPCODE_FIRST +#define X_IN_MLX IA64_OPCODE_X_IN_MLX +#define LAST IA64_OPCODE_LAST +#define PRIV IA64_OPCODE_PRIV +#define NO_PRED IA64_OPCODE_NO_PRED +#define SLOT2 IA64_OPCODE_SLOT2 +#define PSEUDO IA64_OPCODE_PSEUDO +#define F2_EQ_F3 IA64_OPCODE_F2_EQ_F3 +#define LEN_EQ_64MCNT IA64_OPCODE_LEN_EQ_64MCNT +#define MOD_RRBS IA64_OPCODE_MOD_RRBS + +#define AR_CCV IA64_OPND_AR_CCV +#define AR_PFS IA64_OPND_AR_PFS +#define C1 IA64_OPND_C1 +#define C8 IA64_OPND_C8 +#define C16 IA64_OPND_C16 +#define GR0 IA64_OPND_GR0 +#define IP IA64_OPND_IP +#define PR IA64_OPND_PR +#define PR_ROT IA64_OPND_PR_ROT +#define PSR IA64_OPND_PSR +#define PSR_L IA64_OPND_PSR_L +#define PSR_UM IA64_OPND_PSR_UM + +#define AR3 IA64_OPND_AR3 +#define B1 IA64_OPND_B1 +#define B2 IA64_OPND_B2 +#define CR3 IA64_OPND_CR3 +#define F1 IA64_OPND_F1 +#define F2 IA64_OPND_F2 +#define F3 IA64_OPND_F3 +#define F4 IA64_OPND_F4 +#define P1 IA64_OPND_P1 +#define P2 IA64_OPND_P2 +#define R1 IA64_OPND_R1 +#define R2 IA64_OPND_R2 +#define R3 IA64_OPND_R3 +#define R3_2 IA64_OPND_R3_2 + +#define CPUID_R3 IA64_OPND_CPUID_R3 +#define DBR_R3 IA64_OPND_DBR_R3 +#define DTR_R3 IA64_OPND_DTR_R3 +#define ITR_R3 IA64_OPND_ITR_R3 +#define IBR_R3 IA64_OPND_IBR_R3 +#define MR3 IA64_OPND_MR3 +#define MSR_R3 IA64_OPND_MSR_R3 +#define PKR_R3 IA64_OPND_PKR_R3 +#define PMC_R3 IA64_OPND_PMC_R3 +#define PMD_R3 IA64_OPND_PMD_R3 +#define RR_R3 IA64_OPND_RR_R3 + +#define CCNT5 IA64_OPND_CCNT5 +#define CNT2a IA64_OPND_CNT2a +#define CNT2b IA64_OPND_CNT2b +#define CNT2c IA64_OPND_CNT2c +#define CNT5 IA64_OPND_CNT5 +#define CNT6 IA64_OPND_CNT6 +#define CPOS6a IA64_OPND_CPOS6a +#define CPOS6b IA64_OPND_CPOS6b +#define CPOS6c IA64_OPND_CPOS6c +#define IMM1 IA64_OPND_IMM1 +#define IMM14 IA64_OPND_IMM14 +#define IMM17 IA64_OPND_IMM17 +#define IMM22 IA64_OPND_IMM22 +#define IMM44 IA64_OPND_IMM44 +#define SOF IA64_OPND_SOF +#define SOL IA64_OPND_SOL +#define SOR IA64_OPND_SOR +#define IMM8 IA64_OPND_IMM8 +#define IMM8U4 IA64_OPND_IMM8U4 +#define IMM8M1 IA64_OPND_IMM8M1 +#define IMM8M1U4 IA64_OPND_IMM8M1U4 +#define IMM8M1U8 IA64_OPND_IMM8M1U8 +#define IMM9a IA64_OPND_IMM9a +#define IMM9b IA64_OPND_IMM9b +#define IMMU2 IA64_OPND_IMMU2 +#define IMMU21 IA64_OPND_IMMU21 +#define IMMU24 IA64_OPND_IMMU24 +#define IMMU62 IA64_OPND_IMMU62 +#define IMMU64 IA64_OPND_IMMU64 +#define IMMU7a IA64_OPND_IMMU7a +#define IMMU7b IA64_OPND_IMMU7b +#define IMMU9 IA64_OPND_IMMU9 +#define INC3 IA64_OPND_INC3 +#define LEN4 IA64_OPND_LEN4 +#define LEN6 IA64_OPND_LEN6 +#define MBTYPE4 IA64_OPND_MBTYPE4 +#define MHTYPE8 IA64_OPND_MHTYPE8 +#define POS6 IA64_OPND_POS6 +#define TAG13 IA64_OPND_TAG13 +#define TAG13b IA64_OPND_TAG13b +#define TGT25 IA64_OPND_TGT25 +#define TGT25b IA64_OPND_TGT25b +#define TGT25c IA64_OPND_TGT25c +#define TGT64 IA64_OPND_TGT64 + +#endif diff -urN test4.official/arch/ia64/kdb/ia64.h test4.official.kdb/arch/ia64/kdb/ia64.h --- test4.official/arch/ia64/kdb/ia64.h Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/arch/ia64/kdb/ia64.h Fri Aug 11 11:25:45 2000 @@ -0,0 +1,388 @@ +/* ia64.h -- Header file for ia64 opcode table + Copyright (C) 1998, 1999 David Mosberger-Tang + + See the file HP-COPYRIGHT for additional information. */ + +#ifndef opcode_ia64_h +#define opcode_ia64_h + +#include + +#include "minbfd.h" + + +typedef BFD_HOST_U_64_BIT ia64_insn; + +enum ia64_insn_type + { + IA64_TYPE_NIL = 0, /* illegal type */ + IA64_TYPE_A, /* integer alu (I- or M-unit) */ + IA64_TYPE_I, /* non-alu integer (I-unit) */ + IA64_TYPE_M, /* memory (M-unit) */ + IA64_TYPE_B, /* branch (B-unit) */ + IA64_TYPE_F, /* floating-point (F-unit) */ + IA64_TYPE_X, /* long encoding (X-unit) */ + IA64_TYPE_DYN, /* Dynamic opcode */ + IA64_NUM_TYPES + }; + +enum ia64_unit + { + IA64_UNIT_NIL = 0, /* illegal unit */ + IA64_UNIT_I, /* integer unit */ + IA64_UNIT_M, /* memory unit */ + IA64_UNIT_B, /* branching unit */ + IA64_UNIT_F, /* floating-point unit */ + IA64_UNIT_L, /* long "unit" */ + IA64_UNIT_X, /* may be integer or branch unit */ + IA64_NUM_UNITS + }; + +/* Changes to this enumeration must be propagated to the operand table in + bfd/cpu-ia64-opc.c + */ +enum ia64_opnd + { + IA64_OPND_NIL, /* no operand---MUST BE FIRST!*/ + + /* constants */ + IA64_OPND_AR_CCV, /* application register ccv (ar.ccv) */ + IA64_OPND_AR_PFS, /* application register pfs (ar.pfs) */ + IA64_OPND_C1, /* the constant 1 */ + IA64_OPND_C8, /* the constant 8 */ + IA64_OPND_C16, /* the constant 16 */ + IA64_OPND_GR0, /* gr0 */ + IA64_OPND_IP, /* instruction pointer (ip) */ + IA64_OPND_PR, /* predicate register (pr) */ + IA64_OPND_PR_ROT, /* rotating predicate register (pr.rot) */ + IA64_OPND_PSR, /* processor status register (psr) */ + IA64_OPND_PSR_L, /* processor status register L (psr.l) */ + IA64_OPND_PSR_UM, /* processor status register UM (psr.um) */ + + /* register operands: */ + IA64_OPND_AR3, /* third application register # (bits 20-26) */ + IA64_OPND_B1, /* branch register # (bits 6-8) */ + IA64_OPND_B2, /* branch register # (bits 13-15) */ + IA64_OPND_CR3, /* third control register # (bits 20-26) */ + IA64_OPND_F1, /* first floating-point register # */ + IA64_OPND_F2, /* second floating-point register # */ + IA64_OPND_F3, /* third floating-point register # */ + IA64_OPND_F4, /* fourth floating-point register # */ + IA64_OPND_P1, /* first predicate # */ + IA64_OPND_P2, /* second predicate # */ + IA64_OPND_R1, /* first register # */ + IA64_OPND_R2, /* second register # */ + IA64_OPND_R3, /* third register # */ + IA64_OPND_R3_2, /* third register # (limited to gr0-gr3) */ + + /* indirect operands: */ + IA64_OPND_CPUID_R3, /* cpuid[reg] */ + IA64_OPND_DBR_R3, /* dbr[reg] */ + IA64_OPND_DTR_R3, /* dtr[reg] */ + IA64_OPND_ITR_R3, /* itr[reg] */ + IA64_OPND_IBR_R3, /* ibr[reg] */ + IA64_OPND_MR3, /* memory at addr of third register # */ + IA64_OPND_MSR_R3, /* msr[reg] */ + IA64_OPND_PKR_R3, /* pkr[reg] */ + IA64_OPND_PMC_R3, /* pmc[reg] */ + IA64_OPND_PMD_R3, /* pmd[reg] */ + IA64_OPND_RR_R3, /* rr[reg] */ + + /* immediate operands: */ + IA64_OPND_CCNT5, /* 5-bit count (31 - bits 20-24) */ + IA64_OPND_CNT2a, /* 2-bit count (1 + bits 27-28) */ + IA64_OPND_CNT2b, /* 2-bit count (bits 27-28): 1, 2, 3 */ + IA64_OPND_CNT2c, /* 2-bit count (bits 30-31): 0, 7, 15, or 16 */ + IA64_OPND_CNT5, /* 5-bit count (bits 14-18) */ + IA64_OPND_CNT6, /* 6-bit count (bits 27-32) */ + IA64_OPND_CPOS6a, /* 6-bit count (63 - bits 20-25) */ + IA64_OPND_CPOS6b, /* 6-bit count (63 - bits 14-19) */ + IA64_OPND_CPOS6c, /* 6-bit count (63 - bits 31-36) */ + IA64_OPND_IMM1, /* signed 1-bit immediate (bit 36) */ + IA64_OPND_IMMU2, /* unsigned 2-bit immediate (bits 13-14) */ + IA64_OPND_IMMU7a, /* unsigned 7-bit immediate (bits 13-19) */ + IA64_OPND_IMMU7b, /* unsigned 7-bit immediate (bits 20-26) */ + IA64_OPND_SOF, /* 8-bit stack frame size */ + IA64_OPND_SOL, /* 8-bit size of locals */ + IA64_OPND_SOR, /* 6-bit number of rotating registers (scaled by 8) */ + IA64_OPND_IMM8, /* signed 8-bit immediate (bits 13-19 & 36) */ + IA64_OPND_IMM8U4, /* cmp4*u signed 8-bit immediate (bits 13-19 & 36) */ + IA64_OPND_IMM8M1, /* signed 8-bit immediate -1 (bits 13-19 & 36) */ + IA64_OPND_IMM8M1U4, /* cmp4*u signed 8-bit immediate -1 (bits 13-19 & 36)*/ + IA64_OPND_IMM8M1U8, /* cmp*u signed 8-bit immediate -1 (bits 13-19 & 36) */ + IA64_OPND_IMMU9, /* unsigned 9-bit immediate (bits 33-34, 20-26) */ + IA64_OPND_IMM9a, /* signed 9-bit immediate (bits 6-12, 27, 36) */ + IA64_OPND_IMM9b, /* signed 9-bit immediate (bits 13-19, 27, 36) */ + IA64_OPND_IMM14, /* signed 14-bit immediate (bits 13-19, 27-32, 36) */ + IA64_OPND_IMM17, /* signed 17-bit immediate (2*bits 6-12, 24-31, 36) */ + IA64_OPND_IMMU21, /* unsigned 21-bit immediate (bits 6-25, 36) */ + IA64_OPND_IMM22, /* signed 22-bit immediate (bits 13-19, 22-36) */ + IA64_OPND_IMMU24, /* unsigned 24-bit immediate (bits 6-26, 31-32, 36) */ + IA64_OPND_IMM44, /* signed 44-bit immediate (2^16*bits 6-32, 36) */ + IA64_OPND_IMMU62, /* unsigned 62-bit immediate */ + IA64_OPND_IMMU64, /* unsigned 64-bit immediate (lotsa bits...) */ + IA64_OPND_INC3, /* signed 3-bit (bits 13-15): +/-1, 4, 8, 16 */ + IA64_OPND_LEN4, /* 4-bit count (bits 27-30 + 1) */ + IA64_OPND_LEN6, /* 6-bit count (bits 27-32 + 1) */ + IA64_OPND_MBTYPE4, /* 4-bit mux type (bits 20-23) */ + IA64_OPND_MHTYPE8, /* 8-bit mux type (bits 20-27) */ + IA64_OPND_POS6, /* 6-bit count (bits 14-19) */ + IA64_OPND_TAG13, /* signed 13-bit tag (ip + 16*bits 6-12, 33-34) */ + IA64_OPND_TAG13b, /* signed 13-bit tag (ip + 16*bits 24-32) */ + IA64_OPND_TGT25, /* signed 25-bit (ip + 16*bits 6-25, 36) */ + IA64_OPND_TGT25b, /* signed 25-bit (ip + 16*bits 6-12, 20-32, 36) */ + IA64_OPND_TGT25c, /* signed 25-bit (ip + 16*bits 13-32, 36) */ + IA64_OPND_TGT64, /* 64-bit (ip + 16*bits 13-32, 36, 2-40(L)) */ + + IA64_OPND_COUNT /* # of operand types (MUST BE LAST!) */ + }; + +enum ia64_dependency_mode +{ + IA64_DV_RAW, + IA64_DV_WAW, + IA64_DV_WAR, +}; + +enum ia64_dependency_semantics +{ + IA64_DVS_NONE, + IA64_DVS_IMPLIED, + IA64_DVS_IMPLIEDF, + IA64_DVS_DATA, + IA64_DVS_INSTR, + IA64_DVS_SPECIFIC, + IA64_DVS_OTHER, +}; + +enum ia64_resource_specifier +{ + IA64_RS_ANY, + IA64_RS_AR_K, + IA64_RS_AR_UNAT, + IA64_RS_AR, /* 8-15, 20, 22-23, 31, 33-35, 37-39, 41-43, 45-47, 67-111 */ + IA64_RS_ARb, /* 48-63, 112-127 */ + IA64_RS_BR, + IA64_RS_CFM, + IA64_RS_CPUID, + IA64_RS_CR_IRR, + IA64_RS_CR_LRR, + IA64_RS_CR, /* 3-7,10-15,18,26-63,75-79,82-127 */ + IA64_RS_DBR, + IA64_RS_FR, + IA64_RS_FRb, + IA64_RS_GR0, + IA64_RS_GR, + IA64_RS_IBR, + IA64_RS_INSERVICE, /* CR[EOI] or CR[IVR] */ + IA64_RS_MSR, + IA64_RS_PKR, + IA64_RS_PMC, + IA64_RS_PMD, + IA64_RS_PR, + IA64_RS_PR63, + IA64_RS_RR, + + IA64_RS_ARX, /* ARs not in RS_AR or RS_ARb */ + IA64_RS_CRX, /* CRs not in RS_CR */ + IA64_RS_PSR, /* PSR bits */ + IA64_RS_RSE, /* implementation-specific RSE resources */ + IA64_RS_AR_FPSR, +}; + +enum ia64_rse_resource +{ + IA64_RSE_N_STACKED_PHYS, + IA64_RSE_BOF, + IA64_RSE_STORE_REG, + IA64_RSE_LOAD_REG, + IA64_RSE_BSPLOAD, + IA64_RSE_RNATBITINDEX, + IA64_RSE_CFLE, + IA64_RSE_NDIRTY, +}; + +/* Information about a given resource dependency */ +struct ia64_dependency +{ + /* Name of the resource */ + const char *name; + /* Does this dependency need further specification? */ + enum ia64_resource_specifier specifier; + /* Mode of dependency */ + enum ia64_dependency_mode mode; + /* Dependency semantics */ + enum ia64_dependency_semantics semantics; + /* Register index, if applicable (distinguishes AR, CR, and PSR deps) */ +#define REG_NONE (-1) + int regindex; + /* Special info on semantics */ + const char *info; +}; + +/* Two arrays of indexes into the ia64_dependency table. + chks are dependencies to check for conflicts when an opcode is + encountered; regs are dependencies to register (mark as used) when an + opcode is used. chks correspond to readers (RAW) or writers (WAW or + WAR) of a resource, while regs correspond to writers (RAW or WAW) and + readers (WAR) of a resource. */ +struct ia64_opcode_dependency +{ + int nchks; + const unsigned short *chks; + int nregs; + const unsigned short *regs; +}; + +/* encode/extract the note/index for a dependency */ +#define RDEP(N,X) (((N)<<11)|(X)) +#define NOTE(X) (((X)>>11)&0x1F) +#define DEP(X) ((X)&0x7FF) + +/* A template descriptor describes the execution units that are active + for each of the three slots. It also specifies the location of + instruction group boundaries that may be present between two slots. */ +struct ia64_templ_desc + { + int group_boundary; /* 0=no boundary, 1=between slot 0 & 1, etc. */ + enum ia64_unit exec_unit[3]; + const char *name; + }; + +/* The opcode table is an array of struct ia64_opcode. */ + +struct ia64_opcode + { + /* The opcode name. */ + const char *name; + + /* The type of the instruction: */ + enum ia64_insn_type type; + + /* Number of output operands: */ + int num_outputs; + + /* The opcode itself. Those bits which will be filled in with + operands are zeroes. */ + ia64_insn opcode; + + /* The opcode mask. This is used by the disassembler. This is a + mask containing ones indicating those bits which must match the + opcode field, and zeroes indicating those bits which need not + match (and are presumably filled in by operands). */ + ia64_insn mask; + + /* An array of operand codes. Each code is an index into the + operand table. They appear in the order which the operands must + appear in assembly code, and are terminated by a zero. */ + enum ia64_opnd operands[5]; + + /* One bit flags for the opcode. These are primarily used to + indicate specific processors and environments support the + instructions. The defined values are listed below. */ + unsigned int flags; + + /* Used by ia64_find_next_opcode (). */ + short ent_index; + + /* Opcode dependencies. */ + const struct ia64_opcode_dependency *dependencies; + }; + +/* Values defined for the flags field of a struct ia64_opcode. */ + +#define IA64_OPCODE_FIRST (1<<0) /* must be first in an insn group */ +#define IA64_OPCODE_X_IN_MLX (1<<1) /* insn is allowed in X slot of MLX */ +#define IA64_OPCODE_LAST (1<<2) /* must be last in an insn group */ +#define IA64_OPCODE_PRIV (1<<3) /* privileged instruct */ +#define IA64_OPCODE_SLOT2 (1<<4) /* insn allowed in slot 2 only */ +#define IA64_OPCODE_NO_PRED (1<<5) /* insn cannot be predicated */ +#define IA64_OPCODE_PSEUDO (1<<6) /* insn is a pseudo-op */ +#define IA64_OPCODE_F2_EQ_F3 (1<<7) /* constraint: F2 == F3 */ +#define IA64_OPCODE_LEN_EQ_64MCNT (1<<8) /* constraint: LEN == 64-CNT */ +#define IA64_OPCODE_MOD_RRBS (1<<9) /* modifies all rrbs in CFM */ + +/* A macro to extract the major opcode from an instruction. */ +#define IA64_OP(i) (((i) >> 37) & 0xf) + +enum ia64_operand_class + { + IA64_OPND_CLASS_CST, /* constant */ + IA64_OPND_CLASS_REG, /* register */ + IA64_OPND_CLASS_IND, /* indirect register */ + IA64_OPND_CLASS_ABS, /* absolute value */ + IA64_OPND_CLASS_REL, /* IP-relative value */ + }; + +/* The operands table is an array of struct ia64_operand. */ + +struct ia64_operand +{ + enum ia64_operand_class class; + + /* Set VALUE as the operand bits for the operand of type SELF in the + instruction pointed to by CODE. If an error occurs, *CODE is not + modified and the returned string describes the cause of the + error. If no error occurs, NULL is returned. */ + const char *(*insert) (const struct ia64_operand *self, ia64_insn value, + ia64_insn *code); + + /* Extract the operand bits for an operand of type SELF from + instruction CODE store them in *VALUE. If an error occurs, the + cause of the error is described by the string returned. If no + error occurs, NULL is returned. */ + const char *(*extract) (const struct ia64_operand *self, ia64_insn code, + ia64_insn *value); + + /* A string whose meaning depends on the operand class. */ + + const char *str; + + struct bit_field + { + /* The number of bits in the operand. */ + int bits; + + /* How far the operand is left shifted in the instruction. */ + int shift; + } + field[4]; /* no operand has more than this many bit-fields */ + + unsigned int flags; + + const char *desc; /* brief description */ +}; + +/* Values defined for the flags field of a struct ia64_operand. */ + +/* Disassemble as signed decimal (instead of hex): */ +#define IA64_OPND_FLAG_DECIMAL_SIGNED (1<<0) +/* Disassemble as unsigned decimal (instead of hex): */ +#define IA64_OPND_FLAG_DECIMAL_UNSIGNED (1<<1) + +extern const struct ia64_templ_desc ia64_templ_desc[16]; + +/* The tables are sorted by major opcode number and are otherwise in + the order in which the disassembler should consider instructions. */ +extern struct ia64_opcode ia64_opcodes_a[]; +extern struct ia64_opcode ia64_opcodes_i[]; +extern struct ia64_opcode ia64_opcodes_m[]; +extern struct ia64_opcode ia64_opcodes_b[]; +extern struct ia64_opcode ia64_opcodes_f[]; +extern struct ia64_opcode ia64_opcodes_d[]; + + +extern struct ia64_opcode *ia64_find_opcode (const char *name); +extern struct ia64_opcode *ia64_find_next_opcode (struct ia64_opcode *ent); + +extern struct ia64_opcode *ia64_dis_opcode (ia64_insn insn, + enum ia64_insn_type type); + +extern void ia64_free_opcode (struct ia64_opcode *ent); +extern const struct ia64_dependency *ia64_find_dependency (int index); + +/* To avoid circular library dependencies, this array is implemented + in bfd/cpu-ia64-opc.c: */ +extern const struct ia64_operand elf64_ia64_operands[IA64_OPND_COUNT]; + +#endif /* opcode_ia64_h */ diff -urN test4.official/arch/ia64/kdb/kdb_traps.c test4.official.kdb/arch/ia64/kdb/kdb_traps.c --- test4.official/arch/ia64/kdb/kdb_traps.c Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/arch/ia64/kdb/kdb_traps.c Fri Aug 11 11:25:45 2000 @@ -0,0 +1,55 @@ +#include +#include +#include +#include + +static struct kdb_bp_support { + unsigned long addr ; + int slot ; +} kdb_bp_info[NR_CPUS] ; + + +extern void kdb_bp_install (void); + +/* + * This gets invoked right before a call to ia64_fault(). + * Returns zero the normal fault handler should be invoked. + */ +long +ia64_kdb_fault_handler (unsigned long vector, unsigned long isr, unsigned long ifa, + unsigned long iim, unsigned long itir, unsigned long arg5, + unsigned long arg6, unsigned long arg7, unsigned long stack) +{ + struct switch_stack *sw = (struct switch_stack *) &stack; + struct pt_regs *regs = (struct pt_regs *) (sw + 1); + int bundle_slot; + + /* + * TBD + * If KDB is configured, enter KDB for any fault. + */ + if ((vector == 29) || (vector == 35) || (vector == 36)) { + if (!user_mode(regs)) { + bundle_slot = ia64_psr(regs)->ri; + if (vector == 29) { + if (bundle_slot == 0) { + kdb_bp_info[0].addr = regs->cr_iip; + kdb_bp_info[0].slot = bundle_slot; + kdb(KDB_REASON_FLTDBG, 0, regs); + } else { + if ((bundle_slot < 3) && + (kdb_bp_info[0].addr == regs->cr_iip)) + { + ia64_psr(regs)->id = 1; + ia64_psr(regs)->db = 1; + kdb_bp_install() ; + } else /* some error ?? */ + kdb(KDB_REASON_FLTDBG, 0, regs); + } + } else /* single step or taken branch */ + kdb(KDB_REASON_DEBUG, 0, regs); + return 1; + } + } + return 0; +} diff -urN test4.official/arch/ia64/kdb/kdba_bp.c test4.official.kdb/arch/ia64/kdb/kdba_bp.c --- test4.official/arch/ia64/kdb/kdba_bp.c Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/arch/ia64/kdb/kdba_bp.c Fri Aug 11 11:25:45 2000 @@ -0,0 +1,398 @@ +/* + * Minimalist Kernel Debugger + * + * Copyright (C) 1999 Silicon Graphics, Inc. + * Copyright (C) Scott Lurndal (slurn@engr.sgi.com) + * Copyright (C) Scott Foehner (sfoehner@engr.sgi.com) + * Copyright (C) Srinivasa Thirumalachar (sprasad@engr.sgi.com) + * Copyright (C) David Mosberger-Tang + * Copyright (C) 2000 Stephane Eranian + * + * Written March 1999 by Scott Lurndal at Silicon Graphics, Inc. + * + * Modifications from: + * Richard Bass 1999/07/20 + * Many bug fixes and enhancements. + * Scott Foehner + * Port to ia64 + * Srinivasa Thirumalachar + * RSE support for ia64 + * Stephane Eranian + * Enabled disassembler support. Code cleanups + */ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include + +extern kdb_state_t kdb_state ; +kdb_machreg_t dbregs[KDB_MAXHARDBPT]; + +extern char *rwtypes[]; +extern kdb_bp_t breakpoints[KDB_MAXBPT]; +extern void get_fault_regs(fault_regs_t *fr); + +/* + * Start of breakpoint management routines + */ + +/* + * Arg: bp structure + */ + +int +kdb_allocdbreg(kdb_bp_t *bp) +{ + int i=0; + + /* For inst bkpt, just return. No hw reg alloc to be done. */ + + if (bp->bp_mode == BKPTMODE_INST) { + return i; + } else if (bp->bp_mode == BKPTMODE_DATAW) { + for(i=0; ibp_mode == BKPTMODE_DATAW) + dbregs[bp->bp_reg] = 0xffffffff; +} + +void +kdb_initdbregs(void) +{ + int i; + + for(i=0; ibp_addr ; + bundle_t *bundle = (bundle_t *)bp->bp_longinst; + + /* save current bundle */ + *bundle = *(bundle_t *)addr ; + + /* Set the break point! */ + ((bundle_t *)addr)->lform.low8 = ( + (((bundle_t *)addr)->lform.low8 & ~INST_SLOT0_MASK) | + BREAK_INSTR); + + /* set flag */ + bp->bp_instvalid = 1 ; + + /* flush icache as it is stale now */ + ia64_flush_icache_page((unsigned long)addr) ; + +#ifdef KDB_DEBUG + kdb_printf ("[0x%016lx]: install 0x%016lx with 0x%016lx\n", + addr, bundle->lform.low8, addr[0]) ; +#endif + return 0 ; +} + +int +install_databkpt(kdb_bp_t *bp) +{ + unsigned long dbreg_addr = bp->bp_reg * 2; + unsigned long dbreg_cond = dbreg_addr + 1; + unsigned long value = 0x8fffffffffffffff; + unsigned long addr = (unsigned long)bp->bp_addr; + __asm__ ("mov dbr[%0]=%1"::"r"(dbreg_cond),"r"(value)); +// __asm__ ("movl %0,%%db0\n\t"::"r"(contents)); + __asm__ ("mov dbr[%0]=%1"::"r"(dbreg_addr),"r"(addr)); + ia64_insn_group_barrier(); + ia64_srlz_i(); + ia64_insn_group_barrier(); + +#ifdef KDB_DEBUG + kdb_printf("installed dbkpt at 0x%016lx\n", addr) ; +#endif + return 0; +} + +int +kdbinstalldbreg(kdb_bp_t *bp) +{ + if (bp->bp_mode == BKPTMODE_INST) { + return install_instbkpt(bp) ; + } else if (bp->bp_mode == BKPTMODE_DATAW) { + return install_databkpt(bp) ; + } + return 0; +} + +void +remove_instbkpt(kdb_bp_t *bp) +{ + unsigned long *addr = (unsigned long *)bp->bp_addr ; + bundle_t *bundle = (bundle_t *)bp->bp_longinst; + + if (!bp->bp_instvalid) + /* Nothing to remove. If we just alloced the bkpt + * but never resumed, the bp_inst will not be valid. */ + return ; + +#ifdef KDB_DEBUG + kdb_printf ("[0x%016lx]: remove 0x%016lx with 0x%016lx\n", + addr, addr[0], bundle->lform.low8) ; +#endif + + /* restore current bundle */ + *(bundle_t *)addr = *bundle ; + /* reset the flag */ + bp->bp_instvalid = 0 ; + ia64_flush_icache_page((unsigned long)addr) ; +} + +void +remove_databkpt(kdb_bp_t *bp) +{ + int regnum = bp->bp_reg ; + unsigned long dbreg_addr = regnum * 2; + unsigned long dbreg_cond = dbreg_addr + 1; + unsigned long value = 0x0fffffffffffffff; + __asm__ ("mov dbr[%0]=%1"::"r"(dbreg_cond),"r"(value)); +// __asm__ ("movl %0,%%db0\n\t"::"r"(contents)); + ia64_insn_group_barrier(); + ia64_srlz_i(); + ia64_insn_group_barrier(); + +#ifdef KDB_DEBUG + kdb_printf("removed dbkpt at 0x%016lx\n", bp->bp_addr) ; +#endif +} + +void +kdbremovedbreg(kdb_bp_t *bp) +{ + if (bp->bp_mode == BKPTMODE_INST) { + remove_instbkpt(bp) ; + } else if (bp->bp_mode == BKPTMODE_DATAW) { + remove_databkpt(bp) ; + } +} + +#if 0 +kdb_machreg_t +kdb_getdr6(void) +{ + return kdb_getdr(6); +} + +kdb_machreg_t +kdb_getdr7(void) +{ + return kdb_getdr(7); +} + +kdb_machreg_t +kdb_getdr(int regnum) +{ + kdb_machreg_t contents = 0; + unsigned long reg = (unsigned long)regnum; + + __asm__ ("mov %0=ibr[%1]"::"r"(contents),"r"(reg)); +// __asm__ ("mov ibr[%0]=%1"::"r"(dbreg_cond),"r"(value)); + + return contents; +} + + +kdb_machreg_t +kdb_getcr(int regnum) +{ + kdb_machreg_t contents = 0; + return contents; +} + +void +kdb_putdr6(kdb_machreg_t contents) +{ + kdb_putdr(6, contents); +} + +void +kdb_putdr7(kdb_machreg_t contents) +{ + kdb_putdr(7, contents); +} + +void +kdb_putdr(int regnum, kdb_machreg_t contents) +{ +} + +void +get_fault_regs(fault_regs_t *fr) +{ + fr->ifa = 0 ; + fr->isr = 0 ; + + __asm__ ("rsm psr.ic;;") ; + ia64_srlz_d(); + __asm__ ("mov %0=cr.ifa" : "=r"(fr->ifa)); + __asm__ ("mov %0=cr.isr" : "=r"(fr->isr)); + __asm__ ("ssm psr.ic;;") ; + ia64_srlz_d(); +} +#endif + +/* + * kdb_db_trap + * + * Perform breakpoint processing upon entry to the + * processor debugger fault. Determine and print + * the active breakpoint. + * + * Parameters: + * ef Exception frame containing machine register state + * reason Why did we enter kdb - fault or break + * Outputs: + * None. + * Returns: + * 0 Standard instruction or data breakpoint encountered + * 1 Single Step fault ('ss' command) + * 2 Single Step fault, caller should continue ('ssb' command) + * Locking: + * None. + * Remarks: + * Yup, there be goto's here. + */ + +int +kdb_db_trap(struct pt_regs *ef, int reason) +{ + int i, rv=0; + + /* Trying very hard to not change the interface to kdb. + * So, eventhough we have these values in the fault function + * it is not passed in but read again. + */ + fault_regs_t faultregs ; + + if (reason == KDB_REASON_FLTDBG) + get_fault_regs(&faultregs) ; + + /* Prevent it from continuously faulting */ + + ia64_psr(ef)->id = 1; + ia64_psr(ef)->dd = 1; + if (ia64_psr(ef)->ss) { + /* single step */ + ia64_psr(ef)->ss = 0; + + if ((kdb_state.bkpt_handling_state == BKPTSTATE_HANDLED) + && (kdb_state.cmd_given == CMDGIVEN_GO)) + ; + else + kdba_id1(ef->cr_iip + ia64_psr(ef)->ri); + rv = 1; + kdb_state.reason_for_entry = ENTRYREASON_SSTEP ; + goto handled; + } else + kdb_state.reason_for_entry = ENTRYREASON_GO ; + + /* + * Determine which breakpoint was encountered. + */ + for(i=0; icr_iip) || + ((faultregs.ifa) && + (breakpoints[i].bp_addr == faultregs.ifa)))) { + /* + * Hit this breakpoint. Remove it while we are + * handling hit to avoid recursion. XXX ?? + */ + if (breakpoints[i].bp_addr == faultregs.ifa) + kdb_printf("Data breakpoint #%d for 0x%lx at 0x%lx\n", + i, breakpoints[i].bp_addr, ef->cr_iip + ia64_psr(ef)->ri); + else + kdb_printf("%s breakpoint #%d at 0x%lx\n", + rwtypes[0], + i, breakpoints[i].bp_addr); + + /* + * For an instruction breakpoint, disassemble + * the current instruction. + */ + kdba_id1(ef->cr_iip); + + goto handled; + } + } + +#if 0 +unknown: +#endif + kdb_printf("Unknown breakpoint. Should forward. \n"); + /* Need a flag for this. The skip should be done XXX + * when a go or single step command is done for this session. + * For now it is here. + */ + ia64_increment_ip(ef) ; + return rv ; + +handled: + + /* We are here after handling a break inst/data bkpt */ + if (kdb_state.bkpt_handling_state == BKPTSTATE_NOT_HANDLED) { + kdb_state.bkpt_handling_state = BKPTSTATE_HANDLED ; + if (kdb_state.reason_for_entry == ENTRYREASON_GO) { + kdba_setsinglestep(ef) ; + kdb_state.kdb_action = ACTION_NOBPINSTALL; + /* We dont want bp install just this once */ + kdb_state.cmd_given = CMDGIVEN_UNKNOWN ; + } + } else if (kdb_state.bkpt_handling_state == BKPTSTATE_HANDLED) { + kdb_state.bkpt_handling_state = BKPTSTATE_NOT_HANDLED ; + if (kdb_state.reason_for_entry == ENTRYREASON_SSTEP) { + if (kdb_state.cmd_given == CMDGIVEN_GO) + kdb_state.kdb_action = ACTION_NOPROMPT ; + kdb_state.cmd_given = CMDGIVEN_UNKNOWN ; + } + } else + kdb_printf("Unknown value of bkpt state\n") ; + + return rv; + +} diff -urN test4.official/arch/ia64/kdb/kdba_bt.c test4.official.kdb/arch/ia64/kdb/kdba_bt.c --- test4.official/arch/ia64/kdb/kdba_bt.c Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/arch/ia64/kdb/kdba_bt.c Fri Aug 11 11:25:45 2000 @@ -0,0 +1,105 @@ +/** + * Minimalist Kernel Debugger + * Machine dependent stack traceback code for IA-64. + * + * Copyright (C) 1999 Goutham Rao + * Copyright (C) 1999 Sreenivas Subramoney + * Intel Corporation, August 1999. + * Copyright (C) 1999-2000 Hewlett-Packard Co + * Copyright (C) 1999-2000 David Mosberger-Tang + * + * 00/05/30 D. Mosberger Update for new unwind implementation. + * 99/12/03 D. Mosberger Reimplemented based on API. + * 99/12/06 D. Mosberger Added support for backtracing other processes. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +/* + * Minimal stack back trace functionality. + */ + +int +kdba_bt_process(struct task_struct *p, int argcount) +{ + return kdba_bt_stack(ia64_task_regs(p), NULL, argcount, p); +} + +int +kdba_bt_stack(struct pt_regs *regs, unsigned long *addr, int argcount, + struct task_struct *p) +{ + struct unw_frame_info info; + char *name; + + if (addr) { + kdb_printf("bt
is unsupported for IA-64\n"); + return 0; + } + + if (p == current) { + /* + * Upon entering kdb, the stack frame looks like this: + * + * +---------------------+ + * | struct pt_regs | + * +---------------------+ + * | | + * | kernel stack | + * | | + * +=====================+ <--- top of stack upon entering kdb + * | struct pt_regs | + * +---------------------+ + * | struct switch_stack | + * +---------------------+ + */ + if (user_mode(regs)) { + /* We are not implementing stack backtrace from user mode code */ + kdb_printf ("Not in Kernel\n"); + return 0; + } + unw_init_from_current(&info, regs); + } else { + /* + * For a blocked task, the stack frame looks like this: + * + * +---------------------+ + * | struct pt_regs | + * +---------------------+ + * | | + * | kernel stack | + * | | + * +---------------------+ + * | struct switch_stack | + * +=====================+ <--- task->thread.ksp + */ + unw_init_from_blocked_task(&info, p); + } + + kdb_printf("Ret Address (ip) Mem Stack (sp) Reg Stack (bsp) Name\n\n"); + do { + unsigned long ip, sp, bsp; + + unw_get_ip(&info, &ip); + if (ip == 0) + break; + + name = kdbnearsym(ip); + if (!name) { + kdb_printf("Interrupt\n"); + return 0; + } + unw_get_sp(&info, &sp); + unw_get_bsp(&info, &bsp); + kdb_printf("0x%016lx: v+0x%08lx v+0x%08lx %s\n", + ip, sp - PAGE_OFFSET, bsp - PAGE_OFFSET, name); + } while (unw_unwind(&info) >= 0); + return 0; +} diff -urN test4.official/arch/ia64/kdb/kdba_dis.c test4.official.kdb/arch/ia64/kdb/kdba_dis.c --- test4.official/arch/ia64/kdb/kdba_dis.c Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/arch/ia64/kdb/kdba_dis.c Fri Aug 11 11:25:45 2000 @@ -0,0 +1,186 @@ +/* + * KDB IA-64 disassembler module + * + * Copyright (C) 2000 Hewlett-Packard Co + * Copyright (C) 2000 Stephane Eranian + * + * This code provides the KDB interface to the BFD code that disassembles + * IA-64 code. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "dis-asm.h" + +#define KDBA_PRINTBUF_LEN 64 /* buffer len to print a single instr */ +#define KDBA_READBUFFER_LEN 256 /* buffer for BFD disassembler */ + +#define BUNDLE_MULTIPLIER 3 /* how many instr/bundle */ +#define BUNDLE_SIZE 16 /* how many bytes/bundle */ +#define KDBA_DEFAULT_IDLEN 3 /* default number of bundles to disassemble */ + +static char kdba_dis_readbuffer[KDBA_READBUFFER_LEN]; + +static int +kdba_dis_memread(bfd_vma memaddr, bfd_byte *buffer, int length, struct disassemble_info *info) +{ + /* needs some bounds checking here ! */ + memcpy(buffer, (void *)memaddr, length); + + return 0; +} + +static void +kdba_dis_error(int status, bfd_vma memaddr, struct disassemble_info *info) +{ + kdb_printf("KDB: status=%d\n", status); +} + +/* print address, used for branch targets */ +static void +kdba_dis_printaddr(bfd_vma addr, struct disassemble_info *info) +{ + char *near_symbol; + + + near_symbol = kdbnearsym(addr); + if (near_symbol) { + bfd_vma sym_addr, diff; + + /* do a reverse search to get offset, if any */ + sym_addr = kdbgetsymval(near_symbol); + diff = addr - sym_addr; + + if (diff) + kdb_printf("<%s+0x%lx>", near_symbol, diff); + else + kdb_printf("<%s>", near_symbol); + } else + kdb_printf("<%016lx>", addr); +} + +/* figure out if there is a symbol at addr, 1 is exists, 0 otherwise */ +static int +kdba_dis_symbol(bfd_vma addr, struct disassemble_info * info) +{ + return 0; +} + +/* does the printing of an instruction */ +static int +kdba_dis_print(void *flow, const char *fmt, ...) +{ + va_list ap; + char buffer[KDBA_PRINTBUF_LEN]; + int ret; + + va_start(ap, fmt); + + vsprintf(buffer, fmt, ap); + + ret = kdb_printf(buffer); + + va_end(ap); + + return ret; +} + + +static +struct disassemble_info info={ + fprintf_func: kdba_dis_print, + endian: BFD_ENDIAN_LITTLE, + read_memory_func: kdba_dis_memread, + memory_error_func: kdba_dis_error, + print_address_func: kdba_dis_printaddr, + symbol_at_address_func: kdba_dis_symbol, + buffer: kdba_dis_readbuffer, + buffer_length: KDBA_READBUFFER_LEN, + bytes_per_line: 1, + bytes_per_chunk: 4, + display_endian: BFD_ENDIAN_LITTLE, + octets_per_byte: 1, +}; + + +/* iterate over icount instructions (3instr/bundle) */ +static int +kdba_do_id(u64 pc, u64 icount) +{ + int ret; + int slot=0; + + while (icount--) { + kdb_printf("%016lx ", pc+slot); + kdba_dis_printaddr(pc+slot, NULL); + kdb_printf(": ", pc+slot); + ret = print_insn_ia64((bfd_vma)(pc+slot), &info); + kdb_printf("\n"); + if (ret < 0) break; + slot += ret; + if (slot == 16) { pc += 16; slot = 0; } + } + return 0; +} + + +/* + * Display 1 bundles to give a little bit of context + * cannot display more than 1 because of page mapping constraints. + */ +void +kdba_id1(unsigned long pc) +{ + kdba_do_id(pc, 1*BUNDLE_MULTIPLIER); +} + + +int +kdba_id(int argc, const char **argv, const char **envp, kdb_eframe_t regs) +{ + static u64 last_pc; + static unsigned long last_len; + u64 pc = 0; + int nextarg = 1; + int diag; + unsigned long len; + unsigned long offset = 0; + + if (argc < 1) { + if (last_pc == 0) { + kdb_printf("Usage: id [] [bundle_count]\n"); + return KDB_ARGCOUNT; + } + pc = last_pc; + len = last_len; + goto skip_parsing; + } + + if (argc > 1) { + diag = kdbgetularg(argv[2], &len); + if (diag) return diag; + } else + len = KDBA_DEFAULT_IDLEN; + + diag = kdbgetaddrarg(argc, argv, &nextarg, &pc, &offset, NULL, regs); + if (diag) return diag; + last_len = len; + + pc &= ~0xf; /* pc is 16-byte aligned */ + +skip_parsing: + + last_pc = pc + BUNDLE_SIZE*len; + + return kdba_do_id(pc, len*BUNDLE_MULTIPLIER); +} diff -urN test4.official/arch/ia64/kdb/kdba_io.c test4.official.kdb/arch/ia64/kdb/kdba_io.c --- test4.official/arch/ia64/kdb/kdba_io.c Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/arch/ia64/kdb/kdba_io.c Fri Aug 11 17:26:58 2000 @@ -0,0 +1,480 @@ +/* + * Kernel Debugger Console I/O handler + * + * Copyright (C) 1999 Silicon Graphics, Inc. + * Copyright (C) Scott Lurndal (slurn@engr.sgi.com) + * Copyright (C) Scott Foehner (sfoehner@engr.sgi.com) + * Copyright (C) Srinivasa Thirumalachar (sprasad@engr.sgi.com) + * Copyright (C) 2000 Stephane Eranian + * + * See the file LIA-COPYRIGHT for additional information. + * + * Written March 1999 by Scott Lurndal at Silicon Graphics, Inc. + * + * Modifications from: + * Chuck Fleckenstein 1999/07/20 + * Move kdb_info struct declaration to this file + * for cases where serial support is not compiled into + * the kernel. + * + * Masahiro Adegawa 1999/07/20 + * Handle some peculiarities of japanese 86/106 + * keyboards. + * + * marc@mucom.co.il 1999/07/20 + * Catch buffer overflow for serial input. + * + * Scott Foehner + * Port to ia64 + * + * Scott Lurndal 2000/01/03 + * Restructure for v1.0 + * Stephane Eranian 2000/06/05 + * Restructure to avoid code duplication. + * Added kdb_input_t abstraction. + * Added more command line editing support. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +int kdb_port = 0; /* which serial line to use */ +int kdb_source = 0; /* 1=coming from serial, 0 coming from VGA/ps2 */ + +/* + * This data type is used to provide an extra level of abstraction + * and factor in the code for input processing + * + * Even though we have 3 different possible sources of input we do + * only support 2 in the current code. + */ +typedef union { + struct kdb_serial_desc { /* KDB-internal serial access */ + int kdb_port; + } kdb_ser_desc; + + struct kdb_simcons_desc { /* access via console abstraction */ + struct console *console; /* which console for input/output */ + } kdb_simcons_desc; +} kdb_io_desc_t; + +/* + * some shortcuts + */ +#define io_console kdb_simcons_desc.console +#define desc_kdb_port kdb_ser_desc.kdb_port + +/* + * This type is the abstraction manipulated the generic code. It encapsulate all the + * required information to get input/output from a console + */ +typedef struct { + char (*inputch)(kdb_io_desc_t *desc); /* input 1 character */ + void (*outputch)(kdb_io_desc_t *desc,char ch); /* output 1 character */ + kdb_io_desc_t kdb_io_desc; /* opaque information for low level code */ +} kdb_input_t; + + +/* + * This module contains code to read characters from the keyboard or a serial + * port. + * + * It is used by the kernel debugger, and is polled, not interrupt driven. + * + */ + +/* + * send: Send a byte to the keyboard controller. Used primarily to + * alter LED settings. + */ + +static void +kdb_kbdsend(unsigned char byte) +{ + while (inb(KBD_STATUS_REG) & KBD_STAT_IBF) + ; + outb(KBD_DATA_REG, byte); +} + +static void +kdb_kbdsetled(int leds) +{ + kdb_kbdsend(KBD_CMD_SET_LEDS); + kdb_kbdsend((unsigned char)leds); +} + +void +kdb_resetkeyboard(void) +{ +#if 0 + kdb_kbdsend(KBD_CMD_ENABLE); +#endif +} + +#ifdef CONFIG_IA64_HP_SIM +/* + * Function used at initialization time to find a valid console + */ +static void +kdb_simcons_init(kdb_input_t *inout) +{ + struct console *c; + + /* + * we look for a console that can do BOTH in and out + */ + for (c = console_drivers; c; c = c->next) { + if ((c->flags & CON_ENABLED) && c->wait_key && c->write) break; + } + + if ( !(c->wait_key && c->write) ) { + panic("kdb_io: can't do console i/o!"); + } + + inout->kdb_io_desc.io_console = c; +} + +static char +simcons_inputch(kdb_io_desc_t *desc) +{ + return (char)desc->io_console->wait_key(desc->io_console); +} + +static void +simcons_outputch(kdb_io_desc_t *desc, char ch) +{ + desc->io_console->write(desc->io_console, &ch, 1); +} +#endif /* CONFIG_IA64_HP_SIM */ + +/* + * Code used to directly access real serial console (won't work with HPSIM) + */ +#define serial_inp(info, offset) inb((info) + (offset)) +#define serial_out(info, offset, v) outb((v), (info) + (offset)) + +static char +serial_inputch(kdb_io_desc_t *desc) +{ + while ((serial_inp(desc->desc_kdb_port, UART_LSR) & UART_LSR_DR) == 0); + + return (char)serial_inp(desc->desc_kdb_port, UART_RX); +} + +static void +serial_outputch(kdb_io_desc_t *desc, char ch) +{ + serial_out(desc->desc_kdb_port, UART_TX, ch); +} + +#ifndef CONFIG_IA64_HP_SIM +/* + * The function returns a ASCII character code from the PS/2 keyboard input + */ +static char +vgacons_inputch(kdb_io_desc_t *desc) +{ + int scancode, scanstatus; + static int shift_lock = 0; /* CAPS LOCK state (0-off, 1-on) */ + static int shift_key = 0; /* Shift next keypress */ + static int ctrl_key = 0; + static int leds = 2; /* Num lock */ + u_short keychar; + extern u_short plain_map[], shift_map[], ctrl_map[]; + + for (;;) { + /* + * Wait for a valid scancode + */ + while ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0) ; + + /* + * Fetch the scancode + */ + scancode = inb(KBD_DATA_REG); + scanstatus = inb(KBD_STATUS_REG); + + /* + * Ignore mouse events. + */ + if (scanstatus & KBD_STAT_MOUSE_OBF) continue; + + /* + * Ignore release, trigger on make + * (except for shift keys, where we want to + * keep the shift state so long as the key is + * held down). + */ + + if (((scancode&0x7f) == 0x2a) || ((scancode&0x7f) == 0x36)) { + /* + * Next key may use shift table + */ + shift_key = (scancode & 0x80) ? 0 : 1; + continue; + } + + if ((scancode&0x7f) == 0x1d) { + /* + * Left ctrl key + */ + ctrl_key = (scancode & 0x80) ? 0 : 1; + continue; + } + + if ((scancode & 0x80) != 0) continue; + + scancode &= 0x7f; + /* + * Translate scancode + */ + + if (scancode == 0x3a) { + /* + * Toggle caps lock + */ + shift_lock ^= 1; + leds ^= 0x4; /* toggle caps lock led */ + + kdb_kbdsetled(leds); + continue; + } + + if (scancode == 0x0e) return '\b'; + + if (scancode == 0xe0) continue; + + /* + * For Japanese 86/106 keyboards + * See comment in drivers/char/pc_keyb.c. + * - Masahiro Adegawa + */ + if (scancode == 0x73) { + scancode = 0x59; + } else if (scancode == 0x7d) { + scancode = 0x7c; + } + + if (!(shift_lock || shift_key || ctrl_key)) { + keychar = plain_map[scancode]; + } else if (shift_lock || shift_key) { + keychar = shift_map[scancode]; + } else if (ctrl_key) { + keychar = ctrl_map[scancode]; + } else { + keychar = 0x0020; + printk("Unknown state/scancode (%d)\n", scancode); + } + + if ((scancode & 0x7f) == 0x1c) { + /* + * enter key. All done. Absorb the release scancode. + */ + while ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0) + ; + + /* + * Fetch the scancode + */ + scancode = inb(KBD_DATA_REG); + scanstatus = inb(KBD_STATUS_REG); + + while (scanstatus & KBD_STAT_MOUSE_OBF) { + scancode = inb(KBD_DATA_REG); + scanstatus = inb(KBD_STATUS_REG); + } + + if (scancode != 0x9c) { + /* + * Wasn't an enter-release, why not? + */ + printk("kdb: expected enter got 0x%x status 0x%x\n", + scancode, scanstatus); + } + return '\r'; + } + return keychar&0xff; + } +} + +/* + * Output one character to the console, supposedly the VGA console ? + * + * XXX: not good, given how input is done. This should be symetric. + * + */ +static void +vgacons_outputch(kdb_io_desc_t *desc, char ch) +{ + printk("%c", ch); +} +#endif /* ! CONFIG_IA64_HP_SIM */ + +/* + * Main input processing routine + * + * It will fill up the buffer with input characters. + * Some of the control characters are handled internally. Others require upper + * level intervention and are therefore passed back into buffer. + * buffer[0] contains the ASCII code of the control character. + * Currently used to handle CTRL-N/CTRL-P. + * + */ + +static void +kdb_readinput(kdb_input_t *inout, char *buffer, size_t bufsize) +{ + char ch; + kdb_io_desc_t *desc = &inout->kdb_io_desc; + char *cp = buffer; + + /* Reserve space for newline and null byte */ + bufsize -= 2; + + /* print current content, if any */ + while (*cp && *cp != '\n') { + inout->outputch(desc, *cp); + cp++; bufsize--; + } + + for(;;) { + ch = inout->inputch(desc); + switch(ch) { + case 3: /* CTRL-C */ + buffer[0] = ch; + buffer[1] = '\0'; + inout->outputch(desc, 10); + inout->outputch(desc, 13); + return; + + case 127: /* BS, make sure we cover both */ + case 8: /* CTRL-H */ + if (cp > buffer) { + --cp, bufsize++; + inout->outputch(desc,'\b'); + inout->outputch(desc,' '); + inout->outputch(desc,'\b'); + } + break; + + case '\n': + case 13: /* CR */ + *cp++ = '\n'; + *cp = '\0'; + inout->outputch(desc, ch); + inout->outputch(desc, 10); + return; + + case 14: /* CTRL-N handled upper level */ + case 16: /* CTRL-P handled upper level */ + buffer[0]=ch; + buffer[1]='\0'; + + /* fall through */ + + case 21: /* CTRL-U */ + while (cp > buffer) { + --cp, ++bufsize; + inout->outputch(desc,'\b'); + inout->outputch(desc,' '); + inout->outputch(desc,'\b'); + } + if (ch != 21) return; + break; + + default: + /* + * Discard excess characters + */ + if (bufsize > 0) { + *cp++ = ch; + bufsize--; + inout->outputch(desc, ch); + } + } + } +} + +#ifdef CONFIG_IA64_HP_SIM +/* + * Input/Output via simulator's console (serial console) + * + * It is okay to use the console abstraction for HP_SIM because it + * calls directly into the simulator's interface via SSC(). + */ +static kdb_input_t simcons_inout={ + inputch: simcons_inputch, + outputch: simcons_outputch, +}; +#else /* CONFIG_IA64_HP_SIM */ +/* + * Local RAW serial access. This one is slightly better than calling through + * the console layer and it breaks a dependency. However interference at + * the UART levels are to be expected when trying to k-debug the serial driver + * + */ +static kdb_input_t sercons_inout={ + inputch: serial_inputch, + outputch: serial_outputch, +}; + +/* + * Input/Output via the VGA/PS2 console + */ +static kdb_input_t vgacons_inout={ + inputch: vgacons_inputch, + outputch: vgacons_outputch, +}; +#endif /* CONFIG_IA64_HP_SIM */ + +static char * +kdb_getscancode(char *buffer, size_t bufsize) +{ + static int cons_init_done; + static kdb_input_t *sercons = NULL, *vgacons = NULL; + + + if (!cons_init_done) { +#ifdef CONFIG_IA64_HP_SIM + kdb_simcons_init(&simcons_inout); + sercons = &simcons_inout; +#else + sercons = &sercons_inout; + vgacons = &vgacons_inout; + /* record which serial port to use */ + sercons->kdb_io_desc.desc_kdb_port = kdb_port; +#endif + cons_init_done = 1; + } + /* + * kdb source=1: + * - use serial console (raw serial or serial console for HPSIM) + * + * kdb_source=0: + * - use VGA/PS2 console (not working with USB) + */ + switch (kdb_source) { + case 0: + kdb_readinput(vgacons, buffer, bufsize); + break; + case 1: + kdb_readinput(sercons, buffer, bufsize); + break; + } + + return buffer; +} + +char * +kdba_read(char *buffer, size_t bufsize) +{ + return kdb_getscancode(buffer, bufsize); +} diff -urN test4.official/arch/ia64/kdb/kdbasupport.c test4.official.kdb/arch/ia64/kdb/kdbasupport.c --- test4.official/arch/ia64/kdb/kdbasupport.c Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/arch/ia64/kdb/kdbasupport.c Fri Aug 11 11:25:45 2000 @@ -0,0 +1,1222 @@ +/* + * Kernel Debugger Architecture Dependent Support Functions + * + * Copyright (C) 1999 Silicon Graphics, Inc. + * Copyright (C) Scott Lurndal (slurn@engr.sgi.com) + * Copyright (C) Scott Foehner (sfoehner@engr.sgi.com) + * Copyright (C) Srinivasa Thirumalachar (sprasad@engr.sgi.com) + * Copyright (C) David Mosberger-Tang + * + * See the file LIA-COPYRIGHT for additional information. + * + * Written March 1999 by Scott Lurndal at Silicon Graphics, Inc. + * + * Modifications from: + * Richard Bass 1999/07/20 + * Many bug fixes and enhancements. + * Scott Foehner + * Port to ia64 + * Srinivasa Thirumalachar + * RSE support for ia64 + * Scott Lurndal 1999/12/12 + * v1.0 restructuring. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +char *kdb_diemsg = NULL; +#if defined(CONFIG_SMP) +unsigned long smp_kdb_wait; +#endif + +static int +kdb_ia64_itm (int argc, const char **argv, const char **envp, kdb_eframe_t ef) +{ + int diag; + unsigned long val; + + diag = kdbgetularg(argv[1], &val); + if (diag) + return diag; + kdb_printf("new itm=%0xlx\n", val); + + ia64_set_itm(val); + return 0; +} + +static int +kdb_ia64_sir (int argc, const char **argv, const char **envp, kdb_eframe_t ef) +{ + kdba_show_intregs(); + + return 0; +} + +void +kdba_show_intregs(void) +{ + u64 lid, tpr, lrr0, lrr1, itv, pmv, cmcv; + + asm ("mov %0=cr.lid" : "=r"(lid)); + asm ("mov %0=cr.tpr" : "=r"(tpr)); + asm ("mov %0=cr.lrr0" : "=r"(lrr0)); + asm ("mov %0=cr.lrr1" : "=r"(lrr1)); + printk("lid=0x%lx, tpr=0x%lx, lrr0=0x%lx, llr1=0x%lx\n", lid, tpr, lrr0, lrr1); + + asm ("mov %0=cr.itv" : "=r"(itv)); + asm ("mov %0=cr.pmv" : "=r"(pmv)); + asm ("mov %0=cr.cmcv" : "=r"(cmcv)); + printk("itv=0x%lx, pmv=0x%lx, cmcv=0x%lx\n", itv, pmv, cmcv); + + printk("irr=0x%016lx,0x%016lx,0x%016lx,0x%016lx\n", + ia64_get_irr0(), ia64_get_irr1(), ia64_get_irr2(), ia64_get_irr3()); + + printk("itc=0x%016lx, itm=0x%016lx\n", ia64_get_itc(), ia64_get_itm()); +} + +void +kdba_installdbreg(kdb_bp_t *bp) +{ +#if 0 + kdb_machreg_t dr7; + + dr7 = kdb_getdr7(); + + kdb_putdr(bp->bp_hard->bph_reg, bp->bp_addr); + + dr7 |= DR7_GE; + + switch (bp->bp_hard->bph_reg){ + case 0: + DR7_RW0SET(dr7,bp->bp_hard->bph_mode); + DR7_LEN0SET(dr7,bp->bp_hard->bph_length); + DR7_G0SET(dr7); + break; + case 1: + DR7_RW1SET(dr7,bp->bp_hard->bph_mode); + DR7_LEN1SET(dr7,bp->bp_hard->bph_length); + DR7_G1SET(dr7); + break; + case 2: + DR7_RW2SET(dr7,bp->bp_hard->bph_mode); + DR7_LEN2SET(dr7,bp->bp_hard->bph_length); + DR7_G2SET(dr7); + break; + case 3: + DR7_RW3SET(dr7,bp->bp_hard->bph_mode); + DR7_LEN3SET(dr7,bp->bp_hard->bph_length); + DR7_G3SET(dr7); + break; + default: + kdb_printf("Bad debug register!! %d\n", + bp->bp_hard->bph_reg); + break; + } + + kdb_putdr7(dr7); + return; +#endif +} + +void +kdba_removedbreg(kdb_bp_t *bp) +{ +#if 0 + int regnum; + kdb_machreg_t dr7; + + if (!bp->bp_hard) + return; + + regnum = bp->bp_hard->bph_reg; + + dr7 = kdb_getdr7(); + + kdb_putdr(regnum, 0); + + switch (regnum) { + case 0: + DR7_G0CLR(dr7); + DR7_L0CLR(dr7); + break; + case 1: + DR7_G1CLR(dr7); + DR7_L1CLR(dr7); + break; + case 2: + DR7_G2CLR(dr7); + DR7_L2CLR(dr7); + break; + case 3: + DR7_G3CLR(dr7); + DR7_L3CLR(dr7); + break; + default: + kdb_printf("Bad debug register!! %d\n", regnum); + break; + } + + kdb_putdr7(dr7); +#endif +} + +kdb_machreg_t +kdb_getdr(int regnum) +{ + kdb_machreg_t contents = 0; + unsigned long reg = (unsigned long)regnum; + + __asm__ ("mov %0=ibr[%1]"::"r"(contents),"r"(reg)); +// __asm__ ("mov ibr[%0]=%1"::"r"(dbreg_cond),"r"(value)); + + return contents; +} + + +kdb_machreg_t +kdb_getcr(int regnum) +{ + kdb_machreg_t contents = 0; + return contents; +} + +void +kdb_putdr(int regnum, kdb_machreg_t contents) +{ +} + +void +get_fault_regs(fault_regs_t *fr) +{ + fr->ifa = 0 ; + fr->isr = 0 ; + + __asm__ ("rsm psr.ic;;") ; + ia64_srlz_d(); + __asm__ ("mov %0=cr.ifa" : "=r"(fr->ifa)); + __asm__ ("mov %0=cr.isr" : "=r"(fr->isr)); + __asm__ ("ssm psr.ic;;") ; + ia64_srlz_d(); +} + +/* + * kdba_getregcontents + * + * Return the contents of the register specified by the + * input string argument. Return an error if the string + * does not match a machine register. + * + * The following pseudo register names are supported: + * ®s - Prints address of exception frame + * kesp - Prints kernel stack pointer at time of fault + * sstk - Prints switch stack for ia64 + * % - Uses the value of the registers at the + * last time the user process entered kernel + * mode, instead of the registers at the time + * kdb was entered. + * + * Parameters: + * regname Pointer to string naming register + * regs Pointer to structure containing registers. + * Outputs: + * *contents Pointer to unsigned long to recieve register contents + * Returns: + * 0 Success + * KDB_BADREG Invalid register name + * Locking: + * None. + * Remarks: + * + * Note that this function is really machine independent. The kdb + * register list is not, however. + */ + +static struct kdbregs { + char *reg_name; + size_t reg_offset; +} kdbreglist[] = { + { " psr", offsetof(struct pt_regs, cr_ipsr) }, + { " ifs", offsetof(struct pt_regs, cr_ifs) }, + { " ip", offsetof(struct pt_regs, cr_iip) }, + + { "unat", offsetof(struct pt_regs, ar_unat) }, + { " pfs", offsetof(struct pt_regs, ar_pfs) }, + { " rsc", offsetof(struct pt_regs, ar_rsc) }, + + { "rnat", offsetof(struct pt_regs, ar_rnat) }, + { "bsps", offsetof(struct pt_regs, ar_bspstore) }, + { " pr", offsetof(struct pt_regs, pr) }, + + { "ldrs", offsetof(struct pt_regs, loadrs) }, + { " ccv", offsetof(struct pt_regs, ar_ccv) }, + { "fpsr", offsetof(struct pt_regs, ar_fpsr) }, + + { " b0", offsetof(struct pt_regs, b0) }, + { " b6", offsetof(struct pt_regs, b6) }, + { " b7", offsetof(struct pt_regs, b7) }, + + { " r1",offsetof(struct pt_regs, r1) }, + { " r2",offsetof(struct pt_regs, r2) }, + { " r3",offsetof(struct pt_regs, r3) }, + + { " r8",offsetof(struct pt_regs, r8) }, + { " r9",offsetof(struct pt_regs, r9) }, + { " r10",offsetof(struct pt_regs, r10) }, + + { " r11",offsetof(struct pt_regs, r11) }, + { " r12",offsetof(struct pt_regs, r12) }, + { " r13",offsetof(struct pt_regs, r13) }, + + { " r14",offsetof(struct pt_regs, r14) }, + { " r15",offsetof(struct pt_regs, r15) }, + { " r16",offsetof(struct pt_regs, r16) }, + + { " r17",offsetof(struct pt_regs, r17) }, + { " r18",offsetof(struct pt_regs, r18) }, + { " r19",offsetof(struct pt_regs, r19) }, + + { " r20",offsetof(struct pt_regs, r20) }, + { " r21",offsetof(struct pt_regs, r21) }, + { " r22",offsetof(struct pt_regs, r22) }, + + { " r23",offsetof(struct pt_regs, r23) }, + { " r24",offsetof(struct pt_regs, r24) }, + { " r25",offsetof(struct pt_regs, r25) }, + + { " r26",offsetof(struct pt_regs, r26) }, + { " r27",offsetof(struct pt_regs, r27) }, + { " r28",offsetof(struct pt_regs, r28) }, + + { " r29",offsetof(struct pt_regs, r29) }, + { " r30",offsetof(struct pt_regs, r30) }, + { " r31",offsetof(struct pt_regs, r31) }, + +}; + +static const int nkdbreglist = sizeof(kdbreglist) / sizeof(struct kdbregs); + +int +kdba_getregcontents(const char *regname, + struct pt_regs *regs, + unsigned long *contents) +{ + int i; + + if (strcmp(regname, "®s") == 0) { + *contents = (unsigned long)regs; + return 0; + } + + if (strcmp(regname, "sstk") == 0) { + *contents = (unsigned long)getprsregs(regs) ; + return 0; + } + + if (strcmp(regname, "isr") == 0) { + fault_regs_t fr ; + get_fault_regs(&fr) ; + *contents = fr.isr ; + return 0 ; + } + + if (strcmp(regname, "ksp") == 0) { + *contents = (unsigned long) (regs + 1); + return 0; + } + +#if 0 + /* XXX need to verify this */ + if (regname[0] == '%') { + /* User registers: %%e[a-c]x, etc */ + regname++; + regs = (struct pt_regs *) + (current->thread.ksp - sizeof(struct pt_regs)); + } +#endif + + for (i=0; i + * + * Parameters: + * regname Pointer to string naming register + * regs Pointer to structure containing registers. + * contents Unsigned long containing new register contents + * Outputs: + * Returns: + * 0 Success + * KDB_BADREG Invalid register name + * Locking: + * None. + * Remarks: + */ + +int +kdba_setregcontents(const char *regname, + struct pt_regs *regs, + unsigned long contents) +{ + int i; + + if (regname[0] == '%') { + regname++; + regs = (struct pt_regs *) + (current->thread.ksp - sizeof(struct pt_regs)); + } + + for (i=0; ithread.ksp - sizeof(struct pt_regs)); + } + + if (type == NULL) { + for (i=0; icr_iip + ia64_psr((struct pt_regs *)ef)->ri; +} + +int +kdba_setpc(kdb_eframe_t ef, kdb_machreg_t newpc) +{ + ((struct pt_regs *)ef)->cr_iip = newpc & ~0xf; + ia64_psr((struct pt_regs *)ef)->ri = newpc & 0x3; + return 0; +} + +void +kdba_disableint(kdb_intstate_t *state) +{ + int *fp = (int *)state; + int flags; + + __save_flags(flags); + __cli(); + + *fp = flags; +} + +void +kdba_restoreint(kdb_intstate_t *state) +{ + int flags = *(int *)state; + __restore_flags(flags); +} + +void +kdba_setsinglestep(struct pt_regs *regs) +{ + ia64_psr(regs)->ss = 1; +#if 0 + regs->eflags |= EF_TF; +#endif +} + +int +kdb_getcurrentframe(struct pt_regs *regs) +{ +#if 0 + regs->xcs = 0; +#if defined(CONFIG_KDB_FRAMEPTR) + asm volatile("movl %%ebp,%0":"=m" (*(int *)®s->ebp)); +#endif + asm volatile("movl %%esp,%0":"=m" (*(int *)®s->esp)); +#endif + return 0; +} + +#if 0 + +int +kdb_setjmp(kdb_jmp_buf *jb) +{ +#if defined(CONFIG_KDB_FRAMEPTR) + __asm__ ("movl 8(%esp), %eax\n\t" + "movl %ebx, 0(%eax)\n\t" + "movl %esi, 4(%eax)\n\t" + "movl %edi, 8(%eax)\n\t" + "movl (%esp), %ecx\n\t" + "movl %ecx, 12(%eax)\n\t" + "leal 8(%esp), %ecx\n\t" + "movl %ecx, 16(%eax)\n\t" + "movl 4(%esp), %ecx\n\t" + "movl %ecx, 20(%eax)\n\t"); +#else /* CONFIG_KDB_FRAMEPTR */ + __asm__ ("movl 4(%esp), %eax\n\t" + "movl %ebx, 0(%eax)\n\t" + "movl %esi, 4(%eax)\n\t" + "movl %edi, 8(%eax)\n\t" + "movl %ebp, 12(%eax)\n\t" + "leal 4(%esp), %ecx\n\t" + "movl %ecx, 16(%eax)\n\t" + "movl 0(%esp), %ecx\n\t" + "movl %ecx, 20(%eax)\n\t"); +#endif /* CONFIG_KDB_FRAMEPTR */ + return 0; +} + +void +kdb_longjmp(kdb_jmp_buf *jb, int reason) +{ +#if defined(CONFIG_KDB_FRAMEPTR) + __asm__("movl 8(%esp), %ecx\n\t" + "movl 12(%esp), %eax\n\t" + "movl 20(%ecx), %edx\n\t" + "movl 0(%ecx), %ebx\n\t" + "movl 4(%ecx), %esi\n\t" + "movl 8(%ecx), %edi\n\t" + "movl 12(%ecx), %ebp\n\t" + "movl 16(%ecx), %esp\n\t" + "jmp *%edx\n"); +#else /* CONFIG_KDB_FRAMEPTR */ + __asm__("movl 4(%esp), %ecx\n\t" + "movl 8(%esp), %eax\n\t" + "movl 20(%ecx), %edx\n\t" + "movl 0(%ecx), %ebx\n\t" + "movl 4(%ecx), %esi\n\t" + "movl 8(%ecx), %edi\n\t" + "movl 12(%ecx), %ebp\n\t" + "movl 16(%ecx), %esp\n\t" + "jmp *%edx\n"); +#endif /* CONFIG_KDB_FRAMEPTR */ +} + + +/* + * kdba_enablemce + * + * This function is called once on each CPU to enable machine + * check exception handling. + * + * Inputs: + * None. + * Outputs: + * None. + * Returns: + * None. + * Locking: + * None. + * Remarks: + * + */ + +void +kdba_enablemce(void) +{ + /* + * Enable Machine Check Exceptions + */ + u32 i, lv, hv, count=0; + u32 eax,ebx,ecx,edx; + + cpuid(1, &eax, &ebx, &ecx, &edx); + if (edx & X86_FEATURE_MCE) { + if (edx & X86_FEATURE_MCA) { + rdmsr(MCG_CAP, lv, hv); + count = lv&0xff; + if (lv & 0x100) { + hv = lv = 0xffffffff; + wrmsr(MCG_CTL, lv, hv); + } + for(i=1; i (unsigned long)high_memory) { + extern int kdb_vmlist_check(unsigned long, unsigned long); + + if (!kdb_vmlist_check(addr, addr+width)) { + /* + * Would appear to be an illegal kernel address; + * Print a message once, and don't print again until + * a legal address is used. + */ + if ((kdb_flags & KDB_FLAG_SUPRESS) == 0) { + printk("kdb: Bad kernel address 0x%lx\n", addr); + kdb_flags |= KDB_FLAG_SUPRESS; + } + return 0L; + } + } + + /* + * A good address. Reset error flag. + */ + kdb_flags &= ~KDB_FLAG_SUPRESS; + + switch (width) { + case 8: + { unsigned long *lp; + + lp = (unsigned long *)(addr); + return *lp; + } + case 4: + { unsigned int *ip; + + ip = (unsigned int *)(addr); + return *ip; + } + case 2: + { unsigned short *sp; + + sp = (unsigned short *)(addr); + return *sp; + } + case 1: + { unsigned char *cp; + + cp = (unsigned char *)(addr); + return *cp; + } + } + + printk("kdbgetword: Bad width\n"); + return 0L; +} + +/* + * kdba_putword + * + * Architecture specific function to access kernel virtual + * address space. + * + * Parameters: + * None. + * Returns: + * None. + * Locking: + * None. + * Remarks: + * None. + */ + +unsigned long +kdba_putword(unsigned long addr, size_t size, unsigned long contents) +{ + /* + * This function checks the address for validity. Any address + * in the range PAGE_OFFSET to high_memory is legal, any address + * which maps to a vmalloc region is legal, and any address which + * is a user address, we use get_user() to verify validity. + */ + + if (addr < PAGE_OFFSET) { + /* + * Usermode address. + */ + unsigned long diag; + + switch (size) { + case 8: + { unsigned long *lp; + + lp = (unsigned long *) addr; + diag = put_user(contents, lp); + break; + } + case 4: + { unsigned int *ip; + + ip = (unsigned int *) addr; + diag = put_user(contents, ip); + break; + } + case 2: + { unsigned short *sp; + + sp = (unsigned short *) addr; + diag = put_user(contents, sp); + break; + } + case 1: + { unsigned char *cp; + + cp = (unsigned char *) addr; + diag = put_user(contents, cp); + break; + } + default: + printk("kdba_putword: Bad width\n"); + return 0; + } + + if (diag) { + if ((kdb_flags & KDB_FLAG_SUPRESS) == 0) { + printk("kdb: Bad user address 0x%lx\n", addr); + kdb_flags |= KDB_FLAG_SUPRESS; + } + return 0; + } + kdb_flags &= ~KDB_FLAG_SUPRESS; + return 0; + } + + if (addr > (unsigned long)high_memory) { + extern int kdb_vmlist_check(unsigned long, unsigned long); + + if (!kdb_vmlist_check(addr, addr+size)) { + /* + * Would appear to be an illegal kernel address; + * Print a message once, and don't print again until + * a legal address is used. + */ + if ((kdb_flags & KDB_FLAG_SUPRESS) == 0) { + printk("kdb: Bad kernel address 0x%lx\n", addr); + kdb_flags |= KDB_FLAG_SUPRESS; + } + return 0L; + } + } + + /* + * A good address. Reset error flag. + */ + kdb_flags &= ~KDB_FLAG_SUPRESS; + + switch (size) { + case 8: + { unsigned long *lp; + + lp = (unsigned long *)(addr); + *lp = contents; + return 0; + } + case 4: + { unsigned int *ip; + + ip = (unsigned int *)(addr); + *ip = contents; + return 0; + } + case 2: + { unsigned short *sp; + + sp = (unsigned short *)(addr); + *sp = (unsigned short) contents; + return 0; + } + case 1: + { unsigned char *cp; + + cp = (unsigned char *)(addr); + *cp = (unsigned char) contents; + return 0; + } + } + + printk("kdba_putword: Bad width\n"); + return 0; +} + +/* + * kdba_callback_die + * + * Callback function for kernel 'die' function. + * + * Parameters: + * regs Register contents at time of trap + * error_code Trap-specific error code value + * trapno Trap number + * vp Pointer to die message + * Returns: + * Returns 1 if fault handled by kdb. + * Locking: + * None. + * Remarks: + * + */ +int +kdba_callback_die(struct pt_regs *regs, int error_code, long trapno, void *vp) +{ + /* + * Save a pointer to the message provided to 'die()'. + */ + kdb_diemsg = (char *)vp; + + return kdb(KDB_REASON_PANIC, error_code, (kdb_eframe_t) regs); +} + +/* + * kdba_callback_bp + * + * Callback function for kernel breakpoint trap. + * + * Parameters: + * regs Register contents at time of trap + * error_code Trap-specific error code value + * trapno Trap number + * vp Not Used. + * Returns: + * Returns 1 if fault handled by kdb. + * Locking: + * None. + * Remarks: + * + */ + +int +kdba_callback_bp(struct pt_regs *regs, int error_code, long trapno, void *vp) +{ + int diag; + +#if defined(KDBDEBUG) + printk("cb_bp: e_c = %d tn = %d regs = 0x%p\n", error_code, + trapno, regs); +#endif + diag = kdb(KDB_REASON_BREAK, error_code, (kdb_eframe_t) regs); +#if defined(KDBDEBUG) + printk("cb_bp: e_c = %d tn = %d regs = 0x%p diag = %d\n", error_code, + trapno, regs, diag); +#endif + return diag; +} + +/* + * kdba_callback_debug + * + * Callback function for kernel debug register trap. + * + * Parameters: + * regs Register contents at time of trap + * error_code Trap-specific error code value + * trapno Trap number + * vp Not used. + * Returns: + * Returns 1 if fault handled by kdb. + * Locking: + * None. + * Remarks: + * + */ + +int +kdba_callback_debug(struct pt_regs *regs, int error_code, long trapno, void *vp) +{ + return kdb(KDB_REASON_DEBUG, error_code, (kdb_eframe_t) regs); +} + +/* + * kdba_init + * + * Architecture specific initialization. + * + * Parameters: + * None. + * Returns: + * None. + * Locking: + * None. + * Remarks: + * None. + */ + +void +kdba_init(void) +{ +#if 0 + kdba_enablelbr(); +#endif + + kdb_register("irr", kdb_ia64_sir, "", "Show interrupt registers", 0); + kdb_register("itm", kdb_ia64_itm, "", "Set new ITM value", 0); + + return; +} + +unsigned long +show_cur_stack_frame(struct pt_regs *regs, int regno, unsigned long *contents) +{ + long sof = regs->cr_ifs & ((1<<7)-1) ; /* size of frame */ + unsigned long i ; + int j; + struct switch_stack *prs_regs = getprsregs(regs) ; + unsigned long *sofptr = (prs_regs? ia64_rse_skip_regs( + (unsigned long *)prs_regs->ar_bspstore, -sof) : NULL) ; + + if (!sofptr) { + printk("Unable to display Current Stack Frame\n") ; + return 0 ; + } + + if (regno < 0) + return 0 ; + + for (i=sof, j=0;i;i--,j++) { + /* remember to skip the nat collection dword */ + if ((((unsigned long)sofptr>>3) & (((1<<6)-1))) + == ((1<<6)-1)) + sofptr++ ; + + /* return the value in the reg if regno is non zero */ + + if (regno) { + if ((j+1) == regno) { + if (contents) + *contents = *sofptr ; + return -1; + } + sofptr++ ; + } else { + printk(" r%d: %016lx ", 32+j, *sofptr++) ; + if (!((j+1)%3)) printk("\n") ; + } + } + + if (regno) { + if (!i) /* bogus rse number */ + return 0 ; + } else + printk("\n") ; + + return 0 ; +} diff -urN test4.official/arch/ia64/kdb/minbfd.h test4.official.kdb/arch/ia64/kdb/minbfd.h --- test4.official/arch/ia64/kdb/minbfd.h Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/arch/ia64/kdb/minbfd.h Fri Aug 11 11:25:45 2000 @@ -0,0 +1,334 @@ +/* + * This file contains a minimal subset of the bfd.h header file. + * It is meant ONLY for the disassembler of KDB for IA-64. + * + * Contributed by Stephane Eranian + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ +#ifndef __MINBFD_H__ +#define __MINBFD_H__ + +typedef unsigned long bfd_vma; + +#define PARAMS(paramlist) paramlist +#define PTR void * +#define CONST const + +typedef unsigned long symvalue; +typedef unsigned int flagword; /* 32 bits of flags */ +typedef unsigned char bfd_byte; + +typedef struct _bfd { + void *noname; +} bfd; + +#define BFD_HOST_U_64_BIT unsigned long +#define BFD_HOST_64_BIT long + +enum bfd_flavour { + bfd_target_unknown_flavour, + bfd_target_aout_flavour, + bfd_target_coff_flavour, + bfd_target_ecoff_flavour, + bfd_target_elf_flavour, + bfd_target_ieee_flavour, + bfd_target_nlm_flavour, + bfd_target_oasys_flavour, + bfd_target_tekhex_flavour, + bfd_target_srec_flavour, + bfd_target_ihex_flavour, + bfd_target_som_flavour, + bfd_target_os9k_flavour, + bfd_target_versados_flavour, + bfd_target_msdos_flavour, + bfd_target_ovax_flavour, + bfd_target_evax_flavour +}; + +enum bfd_endian { BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN }; + +enum bfd_architecture +{ + bfd_arch_unknown, /* File arch not known */ + bfd_arch_obscure, /* Arch known, not one of these */ + bfd_arch_m68k, /* Motorola 68xxx */ +#define bfd_mach_m68000 1 +#define bfd_mach_m68008 2 +#define bfd_mach_m68010 3 +#define bfd_mach_m68020 4 +#define bfd_mach_m68030 5 +#define bfd_mach_m68040 6 +#define bfd_mach_m68060 7 +#define bfd_mach_cpu32 8 + bfd_arch_vax, /* DEC Vax */ + bfd_arch_i960, /* Intel 960 */ + /* The order of the following is important. + lower number indicates a machine type that + only accepts a subset of the instructions + available to machines with higher numbers. + The exception is the "ca", which is + incompatible with all other machines except + "core". */ + +#define bfd_mach_i960_core 1 +#define bfd_mach_i960_ka_sa 2 +#define bfd_mach_i960_kb_sb 3 +#define bfd_mach_i960_mc 4 +#define bfd_mach_i960_xa 5 +#define bfd_mach_i960_ca 6 +#define bfd_mach_i960_jx 7 +#define bfd_mach_i960_hx 8 + + bfd_arch_a29k, /* AMD 29000 */ + bfd_arch_sparc, /* SPARC */ +#define bfd_mach_sparc 1 + /* The difference between v8plus and v9 is that v9 is a true 64 bit env. */ +#define bfd_mach_sparc_sparclet 2 +#define bfd_mach_sparc_sparclite 3 +#define bfd_mach_sparc_v8plus 4 +#define bfd_mach_sparc_v8plusa 5 /* with ultrasparc add'ns */ +#define bfd_mach_sparc_sparclite_le 6 +#define bfd_mach_sparc_v9 7 +#define bfd_mach_sparc_v9a 8 /* with ultrasparc add'ns */ + /* Nonzero if MACH has the v9 instruction set. */ +#define bfd_mach_sparc_v9_p(mach) \ + ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9a) + bfd_arch_mips, /* MIPS Rxxxx */ +#define bfd_mach_mips3000 3000 +#define bfd_mach_mips3900 3900 +#define bfd_mach_mips4000 4000 +#define bfd_mach_mips4010 4010 +#define bfd_mach_mips4100 4100 +#define bfd_mach_mips4111 4111 +#define bfd_mach_mips4300 4300 +#define bfd_mach_mips4400 4400 +#define bfd_mach_mips4600 4600 +#define bfd_mach_mips4650 4650 +#define bfd_mach_mips5000 5000 +#define bfd_mach_mips5400 5400 +#define bfd_mach_mips6000 6000 +#define bfd_mach_mips8000 8000 +#define bfd_mach_mips10000 10000 +#define bfd_mach_mips16 16 + bfd_arch_i386, /* Intel 386 */ +#define bfd_mach_i386_i386 0 +#define bfd_mach_i386_i8086 1 +#define bfd_mach_i386_i386_intel_syntax 2 + bfd_arch_we32k, /* AT&T WE32xxx */ + bfd_arch_tahoe, /* CCI/Harris Tahoe */ + bfd_arch_i860, /* Intel 860 */ + bfd_arch_romp, /* IBM ROMP PC/RT */ + bfd_arch_alliant, /* Alliant */ + bfd_arch_convex, /* Convex */ + bfd_arch_m88k, /* Motorola 88xxx */ + bfd_arch_pyramid, /* Pyramid Technology */ + bfd_arch_h8300, /* Hitachi H8/300 */ +#define bfd_mach_h8300 1 +#define bfd_mach_h8300h 2 +#define bfd_mach_h8300s 3 + bfd_arch_powerpc, /* PowerPC */ + bfd_arch_rs6000, /* IBM RS/6000 */ + bfd_arch_hppa, /* HP PA RISC */ + bfd_arch_d10v, /* Mitsubishi D10V */ +#define bfd_mach_d10v 0 +#define bfd_mach_d10v_ts2 2 +#define bfd_mach_d10v_ts3 3 + bfd_arch_d30v, /* Mitsubishi D30V */ + bfd_arch_z8k, /* Zilog Z8000 */ +#define bfd_mach_z8001 1 +#define bfd_mach_z8002 2 + bfd_arch_h8500, /* Hitachi H8/500 */ + bfd_arch_sh, /* Hitachi SH */ +#define bfd_mach_sh 0 +#define bfd_mach_sh3 0x30 +#define bfd_mach_sh3e 0x3e + bfd_arch_alpha, /* Dec Alpha */ +#define bfd_mach_alpha_ev4 0x10 +#define bfd_mach_alpha_ev5 0x20 +#define bfd_mach_alpha_ev6 0x30 + bfd_arch_arm, /* Advanced Risc Machines ARM */ +#define bfd_mach_arm_2 1 +#define bfd_mach_arm_2a 2 +#define bfd_mach_arm_3 3 +#define bfd_mach_arm_3M 4 +#define bfd_mach_arm_4 5 +#define bfd_mach_arm_4T 6 +#define bfd_mach_arm_5 7 +#define bfd_mach_arm_5T 8 + bfd_arch_ns32k, /* National Semiconductors ns32000 */ + bfd_arch_w65, /* WDC 65816 */ + bfd_arch_tic30, /* Texas Instruments TMS320C30 */ + bfd_arch_tic54x, /* Texas Instruments TMS320C54X */ + bfd_arch_tic80, /* TI TMS320c80 (MVP) */ + bfd_arch_v850, /* NEC V850 */ +#define bfd_mach_v850 0 +#define bfd_mach_v850e 'E' +#define bfd_mach_v850ea 'A' + bfd_arch_arc, /* Argonaut RISC Core */ +#define bfd_mach_arc_base 0 + bfd_arch_m32r, /* Mitsubishi M32R/D */ +#define bfd_mach_m32r 0 /* backwards compatibility */ +#define bfd_mach_m32rx 'x' + bfd_arch_mn10200, /* Matsushita MN10200 */ + bfd_arch_mn10300, /* Matsushita MN10300 */ +#define bfd_mach_mn10300 300 +#define bfd_mach_am33 330 + bfd_arch_fr30, +#define bfd_mach_fr30 0x46523330 + bfd_arch_mcore, + bfd_arch_ia64, /* HP/Intel ia64 */ + bfd_arch_last + }; + + +typedef struct symbol_cache_entry +{ + /* A pointer to the BFD which owns the symbol. This information + is necessary so that a back end can work out what additional + information (invisible to the application writer) is carried + with the symbol. + + This field is *almost* redundant, since you can use section->owner + instead, except that some symbols point to the global sections + bfd_{abs,com,und}_section. This could be fixed by making + these globals be per-bfd (or per-target-flavor). FIXME. */ + + struct _bfd *the_bfd; /* Use bfd_asymbol_bfd(sym) to access this field. */ + + /* The text of the symbol. The name is left alone, and not copied; the + application may not alter it. */ + CONST char *name; + + /* The value of the symbol. This really should be a union of a + numeric value with a pointer, since some flags indicate that + a pointer to another symbol is stored here. */ + symvalue value; + + /* Attributes of a symbol: */ + +#define BSF_NO_FLAGS 0x00 + + /* The symbol has local scope; <> in <>. The value + is the offset into the section of the data. */ +#define BSF_LOCAL 0x01 + + /* The symbol has global scope; initialized data in <>. The + value is the offset into the section of the data. */ +#define BSF_GLOBAL 0x02 + + /* The symbol has global scope and is exported. The value is + the offset into the section of the data. */ +#define BSF_EXPORT BSF_GLOBAL /* no real difference */ + + /* A normal C symbol would be one of: + <>, <>, <> or + <> */ + + /* The symbol is a debugging record. The value has an arbitary + meaning. */ +#define BSF_DEBUGGING 0x08 + + /* The symbol denotes a function entry point. Used in ELF, + perhaps others someday. */ +#define BSF_FUNCTION 0x10 + + /* Used by the linker. */ +#define BSF_KEEP 0x20 +#define BSF_KEEP_G 0x40 + + /* A weak global symbol, overridable without warnings by + a regular global symbol of the same name. */ +#define BSF_WEAK 0x80 + + /* This symbol was created to point to a section, e.g. ELF's + STT_SECTION symbols. */ +#define BSF_SECTION_SYM 0x100 + + /* The symbol used to be a common symbol, but now it is + allocated. */ +#define BSF_OLD_COMMON 0x200 + + /* The default value for common data. */ +#define BFD_FORT_COMM_DEFAULT_VALUE 0 + + /* In some files the type of a symbol sometimes alters its + location in an output file - ie in coff a <> symbol + which is also <> symbol appears where it was + declared and not at the end of a section. This bit is set + by the target BFD part to convey this information. */ + +#define BSF_NOT_AT_END 0x400 + + /* Signal that the symbol is the label of constructor section. */ +#define BSF_CONSTRUCTOR 0x800 + + /* Signal that the symbol is a warning symbol. The name is a + warning. The name of the next symbol is the one to warn about; + if a reference is made to a symbol with the same name as the next + symbol, a warning is issued by the linker. */ +#define BSF_WARNING 0x1000 + + /* Signal that the symbol is indirect. This symbol is an indirect + pointer to the symbol with the same name as the next symbol. */ +#define BSF_INDIRECT 0x2000 + + /* BSF_FILE marks symbols that contain a file name. This is used + for ELF STT_FILE symbols. */ +#define BSF_FILE 0x4000 + + /* Symbol is from dynamic linking information. */ +#define BSF_DYNAMIC 0x8000 + + /* The symbol denotes a data object. Used in ELF, and perhaps + others someday. */ +#define BSF_OBJECT 0x10000 + + flagword flags; + + /* A pointer to the section to which this symbol is + relative. This will always be non NULL, there are special + sections for undefined and absolute symbols. */ + struct sec *section; + + /* Back end special data. */ + union + { + PTR p; + bfd_vma i; + } udata; + +} asymbol; + +/* imported from bfd/libbfd.c */ +extern inline bfd_vma +bfd_getl64 (const bfd_byte *addr) +{ + bfd_vma low, high; + high= (((((((addr[7] << 8) | + addr[6]) << 8) | + addr[5]) << 8) | + addr[4])); + + low = ((((((((bfd_vma)addr[3] << 8) | + addr[2]) << 8) | + addr[1]) << 8) | + addr[0]) ); + + return high << 32 | low; + +} + +#endif /* __MINBFD_H__ */ diff -urN test4.official/arch/ia64/kernel/entry.S test4.official.kdb/arch/ia64/kernel/entry.S --- test4.official/arch/ia64/kernel/entry.S Fri Aug 11 17:32:39 2000 +++ test4.official.kdb/arch/ia64/kernel/entry.S Fri Aug 11 11:25:45 2000 @@ -1003,6 +1003,71 @@ #endif +#ifdef CONFIG_KDB + // + // This gets called from ivt.S with: + // SAVE MIN with cover done + // SAVE REST done + // no parameters + // r15 has return value = ia64_leave_kernel + // +GLOBAL_ENTRY(ia64_invoke_kdb) + UNW(.prologue) + alloc r16=ar.pfs,0,0,4,0 + DO_SAVE_SWITCH_STACK + UNW(.body) + mov out0=3 // kdb entry reason + mov out1=0 // err number + adds out2=IA64_SWITCH_STACK_SIZE+16,sp // pt_regs + add out3=16,sp // switch_stack + br.call.sptk.few rp=kdb +.retkdb1: + DO_LOAD_SWITCH_STACK( ) + br.ret.sptk.many rp +END(ia64_invoke_kdb) + + // + // When KDB is compiled in, we intercept each fault and give + // kdb a chance to run before calling the normal fault handler. + // +GLOBAL_ENTRY(ia64_invoke_kdb_fault_handler) + UNW(.prologue ASM_UNW_PRLG_RP, ASM_UNW_PRLG_GRSAVE(5)) + alloc r16=ar.pfs,5,1,5,0 + mov loc0=rp // save this + UNW(.body) + UNW(.label_state 1) + UNW(.prologue) + DO_SAVE_SWITCH_STACK + UNW(.body) + mov out0=in0 // vector number + mov out1=in1 // cr.isr + mov out2=in2 // cr.ifa + mov out3=in3 // cr.iim + mov out4=in4 // cr.itir + br.call.sptk.few rp=ia64_kdb_fault_handler +.ret16: + DO_LOAD_SWITCH_STACK( ) + UNW(.body) + UNW(.copy_state 1) + cmp.ne p6,p0=r8,r0 // did ia64_kdb_fault_handler return 0? + mov rp=loc0 +(p6) br.ret.spnt.many rp // no, we're done + ;; // avoid WAW on rp + mov out0=in0 // vector number + mov out1=in1 // cr.isr + mov out2=in2 // cr.ifa + mov out3=in3 // cr.iim + mov out4=in4 // cr.itir + mov in0=ar.pfs // preserve ar.pfs returned by load_switch_stack + br.call.sptk.few rp=ia64_fault // yup -> we need to invoke normal fault handler now +.retkdb2: + mov ar.pfs=in0 + mov rp=loc0 + br.ret.sptk.many rp +END(ia64_invoke_kdb_fault_handler) + +#endif /* CONFIG_KDB */ + .rodata .align 8 .globl sys_call_table diff -urN test4.official/arch/ia64/kernel/ivt.S test4.official.kdb/arch/ia64/kernel/ivt.S --- test4.official/arch/ia64/kernel/ivt.S Fri Aug 11 17:32:39 2000 +++ test4.official.kdb/arch/ia64/kernel/ivt.S Fri Aug 11 11:25:45 2000 @@ -792,6 +792,13 @@ FAULT(17) non_syscall: + +#ifdef CONFIG_KDB + mov r17=__IA64_BREAK_KDB + ;; + cmp.eq p8,p0=r16,r17 // is this a kernel breakpoint? +#endif + SAVE_MIN_WITH_COVER // There is no particular reason for this code to be here, other than that @@ -817,6 +824,9 @@ SAVE_REST mov rp=r15 ;; +#ifdef CONFIG_KDB +(p8) br.call.sptk.few b6=ia64_invoke_kdb +#endif br.call.sptk.few b6=ia64_bad_break // avoid WAW on CFM and ignore return addr .align 1024 @@ -906,7 +916,11 @@ movl r14=ia64_leave_kernel ;; mov rp=r14 +#ifdef CONFIG_KDB + br.call.sptk.few b6=ia64_invoke_kdb_fault_handler +#else br.call.sptk.few b6=ia64_fault +#endif // // --- End of long entries, Beginning of short entries // diff -urN test4.official/arch/ia64/kernel/smp.c test4.official.kdb/arch/ia64/kernel/smp.c --- test4.official/arch/ia64/kernel/smp.c Fri Aug 11 17:32:39 2000 +++ test4.official.kdb/arch/ia64/kernel/smp.c Fri Aug 11 11:25:45 2000 @@ -28,6 +28,14 @@ #include #include +#ifdef CONFIG_KDB +#include +void smp_kdb_interrupt (struct pt_regs* regs); +void kdb_global(int cpuid); +extern unsigned long smp_kdb_wait; +extern int kdb_new_cpu; +#endif + #include #include #include @@ -71,6 +79,10 @@ }; static volatile struct smp_call_struct *smp_call_function_data; +#ifdef CONFIG_KDB +unsigned long smp_kdb_wait = 0; /* Bitmask of waiters */ +#endif + #ifdef CONFIG_ITANIUM_A1_SPECIFIC extern spinlock_t ivr_read_lock; #endif @@ -81,6 +93,7 @@ #ifndef CONFIG_ITANIUM_PTCG # define IPI_FLUSH_TLB 3 #endif /*!CONFIG_ITANIUM_PTCG */ +#define IPI_KDB_INTERRUPT 4 /* * Setup routine for controlling SMP activation @@ -250,6 +263,12 @@ } #endif /* !CONFIG_ITANIUM_PTCG */ +#ifdef CONFIG_KDB + case IPI_KDB_INTERRUPT: + smp_kdb_interrupt(regs); + break; +#endif + default: printk(KERN_CRIT "Unknown IPI on CPU %d: %lu\n", this_cpu, which); break; @@ -799,3 +818,37 @@ } } + +#ifdef CONFIG_KDB +void +smp_kdb_stop (int all, struct pt_regs* regs) +{ + if (all) { + printk ("Sending IPI to all on CPU %i\n", smp_processor_id()); + smp_kdb_wait = ~0UL; + clear_bit(smp_processor_id(), &smp_kdb_wait); + send_IPI_allbutself(IPI_KDB_INTERRUPT); + } else { + printk("Sending IPI to self on CPU %i\n", smp_processor_id()); + set_bit(smp_processor_id(), &smp_kdb_wait); + clear_bit(__cpu_logical_map[kdb_new_cpu], &smp_kdb_wait); + smp_kdb_interrupt(regs); + } +} + +void +smp_kdb_interrupt (struct pt_regs* regs) +{ + printk("kdb: IPI on CPU %i with mask 0x%016lx\n", smp_processor_id (), smp_kdb_wait); + + /* All CPUs spin here forever */ + while (test_bit(smp_processor_id(), &smp_kdb_wait)); + + /* Enter KDB on CPU selected by KDB on the last CPU */ + if (__cpu_logical_map[kdb_new_cpu] == smp_processor_id()) { + kdb(KDB_REASON_SWITCH, 0, regs); + } +} + +#endif + diff -urN test4.official/arch/ia64/kernel/traps.c test4.official.kdb/arch/ia64/kernel/traps.c --- test4.official/arch/ia64/kernel/traps.c Fri Aug 11 17:32:39 2000 +++ test4.official.kdb/arch/ia64/kernel/traps.c Fri Aug 11 11:25:45 2000 @@ -36,6 +36,10 @@ #include #include +#ifdef CONFIG_KDB +#include +#endif + #include #include #include @@ -88,6 +92,13 @@ } printk("%s[%d]: %s %ld\n", current->comm, current->pid, str, err); + +#ifdef CONFIG_KDB + while (1) { + kdb(KDB_REASON_PANIC, 0, regs); + printk("Cant go anywhere from Panic!\n"); + } +#endif show_regs(regs); diff -urN test4.official/arch/ia64/vmlinux.lds.S test4.official.kdb/arch/ia64/vmlinux.lds.S --- test4.official/arch/ia64/vmlinux.lds.S Fri Aug 11 17:32:39 2000 +++ test4.official.kdb/arch/ia64/vmlinux.lds.S Fri Aug 11 11:25:45 2000 @@ -107,6 +107,21 @@ .data.cacheline_aligned : AT(ADDR(.data.cacheline_aligned) - PAGE_OFFSET) { *(.data.cacheline_aligned) } +#if defined(CONFIG_KDB) + /* Kernel symbols and strings for kdb */ +# define KDB_MEAN_SYMBOL_SIZE 48 +# define KDB_SPACE (CONFIG_KDB_STBSIZE * KDB_MEAN_SYMBOL_SIZE) + . = ALIGN(8); + _skdb = .; + .kdb : AT(ADDR(.kdb) - PAGE_OFFSET) + { + *(kdbsymtab) + *(kdbstrings) + } + _ekdb = .; + . = _skdb + KDB_SPACE; +#endif + /* Kernel symbol names for modules: */ .kstrtab : AT(ADDR(.kstrtab) - PAGE_OFFSET) { *(.kstrtab) } diff -urN test4.official/drivers/char/keyboard.c test4.official.kdb/drivers/char/keyboard.c --- test4.official/drivers/char/keyboard.c Mon Feb 14 15:31:14 2000 +++ test4.official.kdb/drivers/char/keyboard.c Fri Aug 11 11:25:45 2000 @@ -42,6 +42,7 @@ #include #include #include +#include #define SIZE(x) (sizeof(x)/sizeof((x)[0])) @@ -249,6 +250,13 @@ up_flag = kbd_unexpected_up(keycode); } else rep = test_and_set_bit(keycode, key_down); + +#if defined(CONFIG_KDB) + if (!up_flag && (keycode == E1_PAUSE)) { + kdb_source = 0; /* coming from keyboard */ + KDB_ENTER() ; + } +#endif /* CONFIG_KDB */ #ifdef CONFIG_MAGIC_SYSRQ /* Handle the SysRq Hack */ if (keycode == SYSRQ_KEY) { diff -urN test4.official/drivers/char/serial.c test4.official.kdb/drivers/char/serial.c --- test4.official/drivers/char/serial.c Sun Jul 9 22:21:41 2000 +++ test4.official.kdb/drivers/char/serial.c Fri Aug 11 11:25:45 2000 @@ -203,6 +203,19 @@ #include #endif +#if defined(CONFIG_KDB) +#include +/* + * kdb_serial_line records the serial line number of the + * first serial console. kdb_info will be set upon receipt + * of the first ^A (which cannot happen until the port is + * opened and the interrupt handler attached). To enter + * kdb before this on a serial console-only system, you must + * use the 'kdb' flag to lilo and set the appropriate breakpoints. + */ + +static int kdb_serial_line = -1; +#endif /* CONFIG_KDB */ /* * All of the compatibilty code so we can compile serial.c against * older kernels is hidden in serial_compat.h @@ -554,6 +567,13 @@ icount = &info->state->icount; do { ch = serial_inp(info, UART_RX); +#if defined(CONFIG_KDB) + if ((info->line == kdb_serial_line) && (ch == 1)) /* CNTRL-A */ { + kdb_source = 1; /* coming from serial */ + KDB_ENTER(); + break; + } +#endif if (tty->flip.count >= TTY_FLIPBUF_SIZE) goto ignore_char; *tty->flip.char_buf_ptr = ch; @@ -5554,6 +5574,17 @@ if (serial_in(info, UART_LSR) == 0xff) return -1; +#ifdef CONFIG_KDB + /* + * Remember the line number of the first serial + * console. We'll make this the kdb serial console too. + */ + if (kdb_serial_line == -1) { + kdb_serial_line = info->line; + kdb_port = info->port; + } +#endif /* CONFIG_KDB */ + return 0; } diff -urN test4.official/drivers/char/simserial.c test4.official.kdb/drivers/char/simserial.c --- test4.official/drivers/char/simserial.c Fri Aug 11 17:32:39 2000 +++ test4.official.kdb/drivers/char/simserial.c Fri Aug 11 11:25:45 2000 @@ -154,6 +154,13 @@ } else if ( seen_esc == 2 ) { if ( ch == 'P' ) show_state(); /* F1 key */ if ( ch == 'Q' ) show_buffers(); /* F2 key */ +#ifdef CONFIG_KDB + if ( ch == 'S' ) { + kdb_source = 1; /* coming from serial */ + KDB_ENTER(); /* F4 key */ + } +#endif + seen_esc = 0; continue; } diff -urN test4.official/include/asm-ia64/kdb.h test4.official.kdb/include/asm-ia64/kdb.h --- test4.official/include/asm-ia64/kdb.h Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/include/asm-ia64/kdb.h Fri Aug 11 11:25:45 2000 @@ -0,0 +1,47 @@ +/* + * Minimalist Kernel Debugger + * + * Copyright (C) 1999 Silicon Graphics, Inc. + * Copyright (C) Scott Lurndal (slurn@engr.sgi.com) + * Copyright (C) Scott Foehner (sfoehner@engr.sgi.com) + * Copyright (C) Srinivasa Thirumalachar (sprasad@engr.sgi.com) + * + * See the file LIA-COPYRIGHT for additional information. + * + * Written March 1999 by Scott Lurndal at Silicon Graphics, Inc. + * + * Modifications from: + * Richard Bass 1999/07/20 + * Many bug fixes and enhancements. + * Scott Foehner + * Port to ia64 + * Scott Lurndal 1999/12/12 + * v1.0 restructuring. + */ +#if !defined(_ASM_KDB_H) +#define _ASM_KDB_H + +/* XXX - Hack */ +typedef unsigned long bfd_vma; + + /* + * KDB_ENTER() is a macro which causes entry into the kernel + * debugger from any point in the kernel code stream. If it + * is intended to be used from interrupt level, it must use + * a non-maskable entry method. + */ +#define KDB_ENTER() asm("\tbreak 0x80100\n") + + /* + * Define the exception frame for this architeture + */ +struct pt_regs; +struct switch_stack; +typedef struct pt_regs *kdb_eframe_t; + + /* + * Define SMP architecture state + */ +extern volatile unsigned long smp_kdb_wait; + +#endif /* ASM_KDB_H */ diff -urN test4.official/include/asm-ia64/kdbprivate.h test4.official.kdb/include/asm-ia64/kdbprivate.h --- test4.official/include/asm-ia64/kdbprivate.h Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/include/asm-ia64/kdbprivate.h Fri Aug 11 11:25:45 2000 @@ -0,0 +1,260 @@ +/* + * Minimalist Kernel Debugger + * + * Copyright (C) 1999 Silicon Graphics, Inc. + * Copyright (C) Scott Lurndal (slurn@engr.sgi.com) + * Copyright (C) Scott Foehner (sfoehner@engr.sgi.com) + * Copyright (C) Srinivasa Thirumalachar (sprasad@engr.sgi.com) + * + * See the file LIA-COPYRIGHT for additional information. + * + * Written March 1999 by Scott Lurndal at Silicon Graphics, Inc. + * + * Modifications from: + * Richard Bass 1999/07/20 + * Many bug fixes and enhancements. + * Scott Foehner + * Port to ia64 + * Scott Lurndal 1999/12/12 + * v1.0 restructuring. + */ +#if !defined(_ASM_KDBPRIVATE_H) +#define _ASM_KDBPRIVATE_H + +/* Definition of an machine instruction. + * Takes care of VLIW processors like Itanium + */ + +typedef union kdb_machinst { + unsigned long longinst[2] ; + unsigned char byteinst ; +} kdb_machinst_t ; + +#define bp_prevbyte bp_inst.byteinst +#define bp_longinst bp_inst.longinst + +typedef unsigned long kdb_machreg_t; + + /* + * KDB_MAXBPT describes the total number of breakpoints + * supported by this architecure. + */ +#define KDB_MAXBPT 16 + /* + * KDB_MAXHARDBPT describes the total number of hardware + * breakpoint registers that exist. + */ +#define KDB_MAXHARDBPT 4 + /* + * Provide space for KDB_MAX_COMMANDS commands. + */ +#define KDB_MAX_COMMANDS 100 + + /* + * Platform specific environment entries + */ +#define KDB_PLATFORM_ENV "IDMODE=ia64", "BYTESPERWORD=4" + + /* + * Support for ia32 debug registers + */ +typedef struct _kdbhard_bp { + kdb_machreg_t bph_reg; /* Register this breakpoint uses */ + + unsigned int bph_free:1; /* Register available for use */ + unsigned int bph_data:1; /* Data Access breakpoint */ + + unsigned int bph_write:1; /* Write Data breakpoint */ + unsigned int bph_mode:2; /* 0=inst, 1=write, 2=io, 3=read */ + unsigned int bph_length:2; /* 0=1, 1=2, 2=BAD, 3=4 (bytes) */ +} kdbhard_bp_t; + +extern kdbhard_bp_t kdb_hardbreaks[/* KDB_MAXHARDBPT */]; + +#define getprsregs(regs) ((struct switch_stack *)regs -1) + +#define BITMASK(bp,value) (value << bp) + +/* bkpt support using break inst instead of IBP reg */ + +/* + * Define certain specific instructions + */ +#define BREAK_INSTR (0x00000080100L << 11) +#define INST_SLOT0_MASK (0x1ffffffffffL << 5) + +#if 0 +#define MAX_BREAKPOINTS 40 +#define PSR_SS 40 +#endif + +/** + * IA-64 instruction format structures + */ +typedef union bundle { + struct { + long low8; + long high8; + } lform; + struct { + int low_low4; + int low_high4; + long high8; + } iform; +} bundle_t; + +#define BKPTMODE_DATAR 3 +#define BKPTMODE_IO 2 +#define BKPTMODE_DATAW 1 +#define BKPTMODE_INST 0 + +/* Some of the fault registers needed by kdb but not passed with + * regs or switch stack. + */ +typedef struct fault_regs { + unsigned long isr ; + unsigned long ifa ; + unsigned long iim ; + unsigned long itir ; +} fault_regs_t ; + +/* + * State of kdb + */ + +typedef struct kdb_state { + int cmd_given ; + int reason_for_entry ; + int bkpt_handling_state ; + int kdb_action ; +} kdb_state_t ; + +#define BKPTSTATE_NOT_HANDLED 0 +#define BKPTSTATE_HANDLED 1 + +#define CMDGIVEN_UNKNOWN 0 +#define CMDGIVEN_SSTEP 1 +#define CMDGIVEN_GO 2 + +#define ENTRYREASON_GO 0 +#define ENTRYREASON_SSTEP 1 + +#define ACTION_UNKNOWN 0 +#define ACTION_NOBPINSTALL 1 +#define ACTION_NOPROMPT 2 + +#if 0 + +#define IA32_BREAKPOINT_INSTRUCTION 0xcc + +#define DR6_BT 0x00008000 +#define DR6_BS 0x00004000 +#define DR6_BD 0x00002000 + +#define DR6_B3 0x00000008 +#define DR6_B2 0x00000004 +#define DR6_B1 0x00000002 +#define DR6_B0 0x00000001 + +#define DR7_RW_VAL(dr, drnum) \ + (((dr) >> (16 + (4 * (drnum)))) & 0x3) + +#define DR7_RW_SET(dr, drnum, rw) \ + do { \ + (dr) &= ~(0x3 << (16 + (4 * (drnum)))); \ + (dr) |= (((rw) & 0x3) << (16 + (4 * (drnum)))); \ + } while (0) + +#define DR7_RW0(dr) DR7_RW_VAL(dr, 0) +#define DR7_RW0SET(dr,rw) DR7_RW_SET(dr, 0, rw) +#define DR7_RW1(dr) DR7_RW_VAL(dr, 1) +#define DR7_RW1SET(dr,rw) DR7_RW_SET(dr, 1, rw) +#define DR7_RW2(dr) DR7_RW_VAL(dr, 2) +#define DR7_RW2SET(dr,rw) DR7_RW_SET(dr, 2, rw) +#define DR7_RW3(dr) DR7_RW_VAL(dr, 3) +#define DR7_RW3SET(dr,rw) DR7_RW_SET(dr, 3, rw) + + +#define DR7_LEN_VAL(dr, drnum) \ + (((dr) >> (18 + (4 * (drnum)))) & 0x3) + +#define DR7_LEN_SET(dr, drnum, rw) \ + do { \ + (dr) &= ~(0x3 << (18 + (4 * (drnum)))); \ + (dr) |= (((rw) & 0x3) << (18 + (4 * (drnum)))); \ + } while (0) +#define DR7_LEN0(dr) DR7_LEN_VAL(dr, 0) +#define DR7_LEN0SET(dr,len) DR7_LEN_SET(dr, 0, len) +#define DR7_LEN1(dr) DR7_LEN_VAL(dr, 1) +#define DR7_LEN1SET(dr,len) DR7_LEN_SET(dr, 1, len) +#define DR7_LEN2(dr) DR7_LEN_VAL(dr, 2) +#define DR7_LEN2SET(dr,len) DR7_LEN_SET(dr, 2, len) +#define DR7_LEN3(dr) DR7_LEN_VAL(dr, 3) +#define DR7_LEN3SET(dr,len) DR7_LEN_SET(dr, 3, len) + +#define DR7_G0(dr) (((dr)>>1)&0x1) +#define DR7_G0SET(dr) ((dr) |= 0x2) +#define DR7_G0CLR(dr) ((dr) &= ~0x2) +#define DR7_G1(dr) (((dr)>>3)&0x1) +#define DR7_G1SET(dr) ((dr) |= 0x8) +#define DR7_G1CLR(dr) ((dr) &= ~0x8) +#define DR7_G2(dr) (((dr)>>5)&0x1) +#define DR7_G2SET(dr) ((dr) |= 0x20) +#define DR7_G2CLR(dr) ((dr) &= ~0x20) +#define DR7_G3(dr) (((dr)>>7)&0x1) +#define DR7_G3SET(dr) ((dr) |= 0x80) +#define DR7_G3CLR(dr) ((dr) &= ~0x80) + +#define DR7_L0(dr) (((dr))&0x1) +#define DR7_L0SET(dr) ((dr) |= 0x1) +#define DR7_L0CLR(dr) ((dr) &= ~0x1) +#define DR7_L1(dr) (((dr)>>2)&0x1) +#define DR7_L1SET(dr) ((dr) |= 0x4) +#define DR7_L1CLR(dr) ((dr) &= ~0x4) +#define DR7_L2(dr) (((dr)>>4)&0x1) +#define DR7_L2SET(dr) ((dr) |= 0x10) +#define DR7_L2CLR(dr) ((dr) &= ~0x10) +#define DR7_L3(dr) (((dr)>>6)&0x1) +#define DR7_L3SET(dr) ((dr) |= 0x40) +#define DR7_L3CLR(dr) ((dr) &= ~0x40) + +#define DR7_GD 0x00002000 /* General Detect Enable */ +#define DR7_GE 0x00000200 /* Global exact */ +#define DR7_LE 0x00000100 /* Local exact */ + +extern kdb_machreg_t kdb_getdr6(void); +extern void kdb_putdr6(kdb_machreg_t); + +extern kdb_machreg_t kdb_getdr7(void); +extern void kdb_putdr7(kdb_machreg_t); + +extern kdb_machreg_t kdb_getdr(int); +extern void kdb_putdr(int, kdb_machreg_t); + +extern kdb_machreg_t kdb_getcr(int); + +#endif + +/* + * Support for setjmp/longjmp + */ +#define JB_BX 0 +#define JB_SI 1 +#define JB_DI 2 +#define JB_BP 3 +#define JB_SP 4 +#define JB_PC 5 + +typedef struct __kdb_jmp_buf { + unsigned long regs[6]; +} kdb_jmp_buf; + +extern int kdb_setjmp(kdb_jmp_buf *); +extern void kdb_longjmp(kdb_jmp_buf *, int); + +extern kdb_jmp_buf kdbjmpbuf[]; + +extern void kdba_show_intregs(void); +extern unsigned long show_cur_stack_frame(struct pt_regs *regs, int regno, unsigned long *contents); + +#endif /* !_ASM_KDBPRIVATE_H */ diff -urN test4.official/include/asm-ia64/keyboard.h test4.official.kdb/include/asm-ia64/keyboard.h --- test4.official/include/asm-ia64/keyboard.h Fri Apr 21 16:38:40 2000 +++ test4.official.kdb/include/asm-ia64/keyboard.h Fri Aug 11 11:25:45 2000 @@ -38,6 +38,7 @@ #define INIT_KBD #define SYSRQ_KEY 0x54 +#define E1_PAUSE 119 /* PAUSE key */ /* resource allocation */ #define kbd_request_region() diff -urN test4.official/include/asm-ia64/smp.h test4.official.kdb/include/asm-ia64/smp.h --- test4.official/include/asm-ia64/smp.h Fri Aug 11 17:32:39 2000 +++ test4.official.kdb/include/asm-ia64/smp.h Fri Aug 11 11:25:45 2000 @@ -42,6 +42,10 @@ #define cpu_number_map(i) __cpu_number_map[i] #define cpu_logical_map(i) __cpu_logical_map[i] +#if defined(CONFIG_KDB) +extern volatile unsigned long smp_kdb_wait; +#endif /* CONFIG_KDB */ + extern unsigned long ap_wakeup_vector; /* diff -urN test4.official/include/linux/kdb.h test4.official.kdb/include/linux/kdb.h --- test4.official/include/linux/kdb.h Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/include/linux/kdb.h Fri Aug 11 11:25:45 2000 @@ -0,0 +1,177 @@ +/* + * Minimalist Kernel Debugger + * + * Copyright (C) 1999 Silicon Graphics, Inc. + * Copyright (C) Scott Lurndal (slurn@engr.sgi.com) + * Copyright (C) Scott Foehner (sfoehner@engr.sgi.com) + * Copyright (C) Srinivasa Thirumalachar (sprasad@engr.sgi.com) + * Copyright (C) 2000 Stephane Eranian + * + * See the file LIA-COPYRIGHT for additional information. + * + * Written March 1999 by Scott Lurndal at Silicon Graphics, Inc. + * + * Modifications from: + * Richard Bass 1999/07/20 + * Many bug fixes and enhancements. + * Scott Foehner + * Port to ia64 + * Scott Lurndal 1999/12/12 + * v1.0 restructuring. + * Stephane Eranian 2000/06/05 + * move to v1.2 + */ + + +#if !defined(__KDB_H) +#define __KDB_H + +#include + +#define KDB_MAJOR_VERSION 1 +#define KDB_MINOR_VERSION 2 + + /* + * kdb_active is initialized to zero, and is set + * to KDB_REASON_xxx whenever the kernel debugger is entered. + */ +extern volatile int kdb_active; + + /* + * kdb_port is initialized to zero, and is set to the I/O port + * address of the serial port when the console is setup in + * serial_console_setup. + */ +extern int kdb_port; +extern int kdb_source; /* indicate whether serial(1) or default(0) input source */ + + /* + * kdb_new_cpu is used in the cpu switching code to select the + * next processor to run. + */ +extern volatile int kdb_new_cpu; + + /* + * KDB_FLAG_EARLYKDB is set when the 'kdb' option is specified + * as a boot parameter (e.g. via lilo). It indicates that the + * kernel debugger should be entered as soon as practical. + */ +#define KDB_FLAG_EARLYKDB 0x00000001 + /* + * KDB_FLAG_SSB is set when the 'ssb' command is in progress. It + * indicates to the debug fault trap code that a trace fault + * (single step) should be continued rather than the debugger + * be entered. + */ +#define KDB_FLAG_SSB 0x00000002 + /* + * KDB_FLAG_SUPRESS is set when an error message is printed + * by a helper function such as kdba_getword. No further error messages + * will be printed until this flag is reset. Used to prevent + * an illegal address from causing voluminous error messages. + */ +#define KDB_FLAG_SUPRESS 0x00000004 + /* + * KDB_FLAG_FAULT is set when handling a debug register instruction + * fault. The backtrace code needs to know. + */ +#define KDB_FLAG_FAULT 0x00000008 + /* + * KDB_FLAG_SS is set when the kernel debugger is using the + * processor trap flag to single-step a processor. If a single + * step trap occurs and the processor was not executing in kernel + * mode when the SS trap occurred and this flag is clear, + * the SS trap will be ignored by KDB and the kernel will be + * allowed to deal with it as necessary (e.g. for ptrace). + */ +#define KDB_FLAG_SS 0x00000010 + /* KDB_FLAG_SSBPT is set when the kernel debugger must single step + * a task in order to re-establish an instruction breakpoint which + * uses the instruction replacement mechanism. + */ +#define KDB_FLAG_SSBPT 0x00000020 + + +extern volatile int kdb_flags; + + /* + * External entry point for the kernel debugger. The pt_regs + * at the time of entry are supplied along with the reason for + * entry to the kernel debugger. + */ + +typedef enum { + KDB_REASON_ENTER, /* Call kdb() directly - regs invalid */ + KDB_REASON_FAULT, /* Kernel fault - regs valid */ + KDB_REASON_BREAK, /* Breakpoint inst. - regs valid */ + KDB_REASON_DEBUG, /* Debug Fault - regs valid */ + KDB_REASON_PANIC, /* Kernel Panic - regs valid */ + KDB_REASON_SWITCH, /* CPU switch - regs valid*/ + KDB_REASON_INT, /* KDB_ENTER trap - regs valid */ + KDB_REASON_KEYBOARD, /* Keyboard entry - regs valid */ + KDB_REASON_NMI, /* Non-maskable interrupt; regs valid */ + KDB_REASON_FLTDBG /* See below comment */ +} kdb_reason_t; + +/* KDB_REASON_FLTDBG: + * In some archs, we want to handle fault as debug itself but still + * be able to know that we came into kdb() from a fault handler rather + * than a break handler or keyboard. Since the actual FAULT handling + * may be diferent other wise, this code means that we came in from + * the fault handler, but treat it like DEBUG. + */ + + +extern int kdb(kdb_reason_t reason, int error_code, kdb_eframe_t); + +typedef int (*kdb_func_t)(int, const char **, const char **, kdb_eframe_t); + /* + * Exported Symbols for kernel loadable modules to use. + */ +extern int kdb_register(char *, kdb_func_t, char *, char *, short); +extern int kdb_unregister(char *); + +extern unsigned long kdba_getword(unsigned long, size_t); +extern unsigned long kdba_putword(unsigned long, size_t, unsigned long); + +extern int kdbgetularg(const char *, unsigned long *); +extern char *kdbgetenv(const char *); +extern int kdbgetintenv(const char *, int *); +extern int kdbgetaddrarg(int, const char**, int*, unsigned long *, + long *, char **, kdb_eframe_t); +extern unsigned long kdbgetsymval(const char *); +extern char * kdbnearsym(unsigned long); +extern int kdb_printf(const char *,...); +extern void kdb_init(void); + +#if defined(__SMP__) + /* + * Kernel debugger non-maskable IPI handler. + */ +extern int kdb_ipi(kdb_eframe_t, void (*ack_interrupt)(void)); +#if 0 +extern void smp_kdb_stop(int all); +#endif +#endif + + /* + * Interface from module loader to kernel debugger + * symbol table. + */ +extern int kdbaddmodsym(char *, unsigned long); +extern int kdbdelmodsym(const char *); + + /* + * Interface from general kernel to enable any hardware + * error reporting mechanisms. Such as the Intel Machine + * Check Architecture, for example. + */ +extern void kdb_enablehwfault(void); + + /* + * Interface from kernel trap handling code to kernel debugger. + */ +extern int kdba_callback_die(struct pt_regs *, int, long, void*); +extern int kdba_callback_bp(struct pt_regs *, int, long, void*); +extern int kdba_callback_debug(struct pt_regs *, int, long, void *); +#endif /* __KDB_H */ diff -urN test4.official/include/linux/kdbprivate.h test4.official.kdb/include/linux/kdbprivate.h --- test4.official/include/linux/kdbprivate.h Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/include/linux/kdbprivate.h Fri Aug 11 11:25:45 2000 @@ -0,0 +1,304 @@ +/* + * Minimalist Kernel Debugger + * + * Copyright (C) 1999 Silicon Graphics, Inc. + * Copyright (C) Scott Lurndal (slurn@engr.sgi.com) + * Copyright (C) Scott Foehner (sfoehner@engr.sgi.com) + * Copyright (C) Srinivasa Thirumalachar (sprasad@engr.sgi.com) + * + * See the file LIA-COPYRIGHT for additional information. + * + * Written March 1999 by Scott Lurndal at Silicon Graphics, Inc. + * + * Modifications from: + * Richard Bass 1999/07/20 + * Many bug fixes and enhancements. + * Scott Foehner + * Port to ia64 + * Scott Lurndal 1999/12/12 + * v1.0 restructuring. + */ +#if !defined(_KDBPRIVATE_H) +#define _KDBPRIVATE_H + +#include + +/* + * Kernel Debugger Error codes + */ + +#define KDB_NOTFOUND -1 +#define KDB_GO -2 +#define KDB_ARGCOUNT -3 +#define KDB_BADWIDTH -4 +#define KDB_BADRADIX -5 +#define KDB_NOTENV -6 +#define KDB_NOENVVALUE -7 +#define KDB_NOTIMP -8 +#define KDB_ENVFULL -9 +#define KDB_ENVBUFFULL -10 +#define KDB_TOOMANYBPT -11 +#define KDB_TOOMANYDBREGS -12 +#define KDB_DUPBPT -13 +#define KDB_BPTNOTFOUND -14 +#define KDB_BADMODE -15 +#define KDB_BADINT -16 +#define KDB_INVADDRFMT -17 +#define KDB_BADREG -18 +#define KDB_CPUSWITCH -19 +#define KDB_BADCPUNUM -20 +#define KDB_BADLENGTH -21 +#define KDB_NOBP -22 + + /* + * kdb_nextline + * + * Contains the current line number on the screen. Used + * to handle the built-in pager (LINES env variable) + */ +extern int kdb_nextline; + + /* + * kdb_diemsg + * + * Contains a pointer to the last string supplied to the + * kernel 'die' panic function. + */ +extern char *kdb_diemsg; + +#if 0 /* XXX - Use old breakpoint code for IA64 for now */ + + /* + * Breakpoint state + * + * Each active and inactive breakpoint is represented by + * an instance of the following data structure. + */ + +typedef struct _kdb_bp { + bfd_vma bp_addr; /* Address breakpoint is present at */ + kdb_machinst_t bp_inst; /* Replaced instruction */ + + unsigned int bp_free:1; /* This entry is available */ + + unsigned int bp_enabled:1; /* Breakpoint is active in register */ + unsigned int bp_global:1; /* Global to all processors */ + + unsigned int bp_hardtype:1; /* Uses hardware register */ + unsigned int bp_forcehw:1; /* Force hardware register */ + unsigned int bp_instvalid:1; /* 0=bp_inst invalid, 1=bp_inst valid */ + unsigned int bp_installed:1; /* Breakpoint is installed */ + unsigned int bp_delay:1; /* Do delayed bp handling */ + unsigned int bp_delayed:1; /* Delayed breakpoint */ + + int bp_cpu; /* Cpu # (if bp_global == 0) */ + kdbhard_bp_t bp_template; /* Hardware breakpoint template */ + kdbhard_bp_t *bp_hard; /* Hardware breakpoint structure */ +} kdb_bp_t; + + /* + * Breakpoint handling subsystem global variables + */ +extern kdb_bp_t kdb_breakpoints[/* KDB_MAXBPT */]; + + /* + * Breakpoint architecture dependent functions. Must be provided + * in some form for all architectures. + */ +extern void kdba_initbp(void); +extern void kdba_printbp(kdb_bp_t *); +extern void kdba_printbpreg(kdbhard_bp_t *); +extern kdbhard_bp_t *kdba_allocbp(kdbhard_bp_t *, int *); +extern void kdba_freebp(kdbhard_bp_t *); +extern int kdba_parsebp(int, const char**, int *, kdb_bp_t*); +extern char *kdba_bptype(kdbhard_bp_t *); +extern void kdba_setsinglestep(kdb_eframe_t); + +#endif + + /* XXX - Old kdb_bp_t definition */ + +typedef struct _kdb_bp { + bfd_vma bp_addr; /* Address breakpoint is present at */ + kdb_machinst_t bp_inst ; /* inst which was replaced */ + + unsigned int bp_regtype:1; /* Uses a debug register (0-4) */ + unsigned int bp_enabled:1; /* Breakpoint is active in register */ + unsigned int bp_global:1; /* Global to all processors */ + unsigned int bp_free:1; /* This entry is available */ + unsigned int bp_data:1; /* Data breakpoint */ + unsigned int bp_write:1; /* Write data breakpoint */ + unsigned int bp_mode:2; /* 0=inst, 1=write, 2=io, 3=read */ + unsigned int bp_length:2; /* 0=1 byte, 1=2 bytes, 2=BAD, 3=4 */ + unsigned int bp_instvalid:1; /* 0=bp_inst garbage, 1=valid */ + + int bp_reg; /* Register that this breakpoint uses */ + int bp_cpu; /* Cpu # (if bp_global == 0) */ +} kdb_bp_t; + +extern int kdbinstalldbreg(kdb_bp_t *); +extern void kdbremovedbreg(kdb_bp_t *); +extern int kdb_allocdbreg(kdb_bp_t *); +extern void kdb_freedbreg(kdb_bp_t *); +extern void kdb_initdbregs(void); +extern void kdb_setsinglestep(struct pt_regs *); + + + + /* + * KDB-only global function prototypes. + */ +extern void kdb_id1(unsigned long); +extern void kdb_id_init(void); + + /* + * Architecture dependent function to enable any + * processor machine check exception handling modes. + */ +extern void kdba_enablemce(void); + +extern void kdba_enablelbr(void); +extern void kdba_printlbr(void); + +extern int kdba_ipi(kdb_eframe_t, void (*)(void)); + + /* + * Initialization functions. + */ +extern void kdba_init(void); +extern void kdb_io_init(void); + + /* + * Architecture specific function to read a string. + */ +extern char * kdba_read(char *, size_t); + + /* + * Architecture specific Stack Traceback functions. + */ +struct task_struct; + +extern int kdba_bt_stack(struct pt_regs *, unsigned long *, + int, struct task_struct *); +extern int kdba_bt_process(struct task_struct *, int); + + /* + * Architecture specific disassembler support routines + */ +extern void kdba_id1(unsigned long); +extern int kdba_id(int argc, const char **argv, const char **envp, kdb_eframe_t regs); + + /* + * Symbol table format + */ + +typedef struct __symtab { + char *name; + unsigned long value; + } __ksymtab_t; + +extern __ksymtab_t __kdbsymtab[]; +extern int __kdbsymtabsize; +extern int __kdbmaxsymtabsize; + + /* + * KDB Command Table + */ + +typedef struct _kdbtab { + char *cmd_name; /* Command name */ + kdb_func_t cmd_func; /* Function to execute command */ + char *cmd_usage; /* Usage String for this command */ + char *cmd_help; /* Help message for this command */ + short cmd_flags; /* Parsing flags */ + short cmd_minlen; /* Minimum legal # command chars required */ +} kdbtab_t; + + /* + * External command function declarations + */ + +extern int kdb_id(int, const char **, const char **, kdb_eframe_t); +extern int kdb_bp(int, const char **, const char **, kdb_eframe_t); +extern int kdb_bc(int, const char **, const char **, kdb_eframe_t); +extern int kdb_bt(int, const char **, const char **, kdb_eframe_t); +extern int kdb_ss(int, const char **, const char **, kdb_eframe_t); + + /* + * External utility function declarations + */ +extern char* kdb_getstr(char *, size_t, char *); + + /* + * Register contents manipulation + */ +extern int kdba_getregcontents(const char *, kdb_eframe_t, unsigned long *); +extern int kdba_setregcontents(const char *, kdb_eframe_t, unsigned long); +extern int kdba_dumpregs(struct pt_regs *, const char *, const char *); +extern int kdba_setpc(kdb_eframe_t, kdb_machreg_t); +extern kdb_machreg_t kdba_getpc(kdb_eframe_t); + + /* + * Debug register handling. + */ +extern void kdba_installdbreg(kdb_bp_t*); +extern void kdba_removedbreg(kdb_bp_t*); + + /* + * Breakpoint handling - External interfaces + */ +extern void kdb_initbptab(void); +#if 0 /* XXX - replacing with old definition */ +extern void kdb_bp_install(kdb_eframe_t); +#endif +extern void kdb_bp_install(void); + +extern void kdb_bp_remove(void); + + /* + * Breakpoint handling - Internal to kdb_bp.c/kdba_bp.c + */ +extern void kdba_installbp(kdb_eframe_t ef, kdb_bp_t *); +extern void kdba_removebp(kdb_bp_t *); + + +typedef enum { + KDB_DB_BPT, /* Breakpoint */ + KDB_DB_SS, /* Single-step trap */ + KDB_DB_SSB, /* Single step to branch */ + KDB_DB_NOBPT /* Spurious breakpoint */ +} kdb_dbtrap_t; + +extern int kdb_db_trap(struct pt_regs *, int reason); /* DEBUG trap/fault handler */ +extern kdb_dbtrap_t kdb_bp_trap(kdb_eframe_t); /* Breakpoint trap/fault hdlr */ + + /* + * Interrupt Handling + */ +typedef int kdb_intstate_t; + +extern void kdba_disableint(kdb_intstate_t *); +extern void kdba_restoreint(kdb_intstate_t *); + + /* + * Architecture Dependent Disassembler interfaces + */ +struct disassemble_info; + +extern void kdba_printaddress(kdb_machreg_t, + struct disassemble_info *, int); +extern kdb_machreg_t kdba_id_printinsn(kdb_machreg_t, + struct disassemble_info*); +extern int kdba_id_parsemode(const char *, + struct disassemble_info*); +extern void kdba_id_init(struct disassemble_info *); + + /* + * Miscellaneous functions + */ +extern int kdb_getcurrentframe(kdb_eframe_t); +extern void kdb_resetkeyboard(void); + + +#endif /* !_KDBPRIVATE_H */ + diff -urN test4.official/include/linux/smp.h test4.official.kdb/include/linux/smp.h --- test4.official/include/linux/smp.h Wed Jul 12 22:01:34 2000 +++ test4.official.kdb/include/linux/smp.h Fri Aug 11 11:25:45 2000 @@ -56,6 +56,10 @@ extern int smp_num_cpus; +#if defined(CONFIG_KDB) +extern volatile unsigned long smp_kdb_wait; +extern void smp_kdb_stop(int, struct pt_regs *); +#endif /* CONFIG_KDB */ extern volatile unsigned long smp_msg_data; extern volatile int smp_src_cpu; extern volatile int smp_msg_id; diff -urN test4.official/init/main.c test4.official.kdb/init/main.c --- test4.official/init/main.c Fri Aug 11 17:32:39 2000 +++ test4.official.kdb/init/main.c Fri Aug 11 11:25:45 2000 @@ -67,6 +67,10 @@ #include #endif +#if defined(CONFIG_KDB) +#include +#endif + /* * Versions of gcc older than that listed below may actually compile * and link okay, but the end product can have subtle run time bugs. @@ -440,6 +444,13 @@ } if (next != NULL) *next++ = 0; +#if defined(CONFIG_KDB) + if (!strcmp(line, "kdb")) { + kdb_flags |= KDB_FLAG_EARLYKDB; + continue; + } +#endif + if (!strncmp(line,"init=",5)) { line += 5; execute_command = line; @@ -556,6 +567,10 @@ } #endif mem_init(); +#if defined(CONFIG_KDB) + kdb_init(); +#endif + kmem_cache_sizes_init(); #ifdef CONFIG_PERFMON perfmon_init(); @@ -587,6 +602,12 @@ #endif check_bugs(); printk("POSIX conformance testing by UNIFIX\n"); +#if defined(CONFIG_KDB) + if (kdb_flags & KDB_FLAG_EARLYKDB) { + KDB_ENTER(); + } +#endif + /* * We count on the initial thread going ok * Like idlers init is an unlocked kernel thread, which will @@ -610,6 +631,11 @@ (void) open("/dev/console",O_RDWR,0); (void) dup(0); (void) dup(0); +#if defined(CONFIG_KDB) + if (kdb_flags & KDB_FLAG_EARLYKDB) { + KDB_ENTER(); + } +#endif return execve(shell, argv, envp_init); } diff -urN test4.official/kdb/Makefile test4.official.kdb/kdb/Makefile --- test4.official/kdb/Makefile Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/kdb/Makefile Fri Aug 11 11:25:45 2000 @@ -0,0 +1,5 @@ +O_TARGET := kdb.o +O_OBJS = kdbmain.o kdb_bt.o kdb_bp.o kdb_io.o kdbsupport.o + +include $(TOPDIR)/Rules.make + diff -urN test4.official/kdb/kdb_bp.c test4.official.kdb/kdb/kdb_bp.c --- test4.official/kdb/kdb_bp.c Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/kdb/kdb_bp.c Fri Aug 11 11:25:45 2000 @@ -0,0 +1,570 @@ +/* + * Minimalist Kernel Debugger + * + * Copyright (C) 1999 Silicon Graphics, Inc. + * Copyright (C) Scott Lurndal (slurn@engr.sgi.com) + * Copyright (C) Scott Foehner (sfoehner@engr.sgi.com) + * Copyright (C) Srinivasa Thirumalachar (sprasad@engr.sgi.com) + * + * Written March 1999 by Scott Lurndal at Silicon Graphics, Inc. + * + * Modifications from: + * Richard Bass 1999/07/20 + * Many bug fixes and enhancements. + * Scott Foehner + * Port to ia64 + */ + +#include +#include +#include +#include +#if defined(__SMP__) +#include +#include +#endif +#include + +extern kdb_state_t kdb_state ; + +/* + * Table of breakpoints + */ +kdb_bp_t breakpoints[KDB_MAXBPT]; + +char *rwtypes[] = {"Instruction", "Data Write", "I/O", "Data Access"}; + +/* + * kdb_bp_install + * + * Install breakpoints prior to returning from the kernel debugger. + * This allows the breakpoints to be set upon functions that are + * used internally by kdb, such as printk(). + * + * Parameters: + * None. + * Outputs: + * None. + * Returns: + * None. + * Locking: + * None. + * Remarks: + */ + +void +kdb_bp_install(void) +{ + int i; + + for(i=0; ibp_mode]); + + kdb_printf("BP #%d at 0x%lx ", + i, bp->bp_addr); + symname = kdbnearsym(bp->bp_addr); + if (symname){ + kdb_printf("(%s", symname); + + offset = bp->bp_addr - kdbgetsymval(symname); + if (offset) { + if (offset > 0) + kdb_printf("+0x%lx", offset); + else + kdb_printf("-0x%lx", offset); + } + kdb_printf(") "); + } + + if (bp->bp_enabled) { + kdb_printf("\n is enabled in dr%d", bp->bp_reg); + if (bp->bp_global) + kdb_printf(" globally"); + else + kdb_printf(" on cpu %d", bp->bp_cpu); + + if (bp->bp_mode != 0) { + kdb_printf(" for %d bytes", bp->bp_length + 1); + } + } else { + kdb_printf("\n is disabled"); + } + + kdb_printf("\n"); +} + +void +kdb_setsinglestep(struct pt_regs *regs) +{ + kdba_setsinglestep(regs); +} + +/* + * kdb_bp + * + * Handle the bp, and bpa commands. + * + * [bp|bpa] [DATAR|DATAW|IO [length]] + * + * Parameters: + * argc Count of arguments in argv + * argv Space delimited command line arguments + * envp Environment value + * regs Exception frame at entry to kernel debugger + * Outputs: + * None. + * Returns: + * Zero for success, a kdb diagnostic if failure. + * Locking: + * None. + * Remarks: + */ + +int +kdb_bp(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + int i; + kdb_bp_t *bp; + int diag; + int free, same; + kdb_machreg_t addr; + char *symname = NULL; + long offset = 0ul; + int nextarg; + unsigned long mode, length; +#if defined(__SMP__) + int global; +#endif + + if (argc == 0) { + /* + * Display breakpoint table + */ + for(i=0,bp=breakpoints; ibp_free) continue; + + kdb_printbp(bp, i); + } + + return 0; + } + +#if defined(__SMP__) + global = (strcmp(argv[0], "bpa") == 0); +#endif + + nextarg = 1; + diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, &symname, regs); + if (diag) + return diag; + + mode = BKPTMODE_INST; /* Default to instruction breakpoint */ + length = 0; /* Length must be zero for insn bp */ + if ((argc + 1) != nextarg) { + if (strnicmp(argv[nextarg], "datar", sizeof("datar")) == 0) { + mode = BKPTMODE_DATAR; + } else if (strnicmp(argv[nextarg], "dataw", sizeof("dataw")) == 0) { + mode = BKPTMODE_DATAW; + } else if (strnicmp(argv[nextarg], "io", sizeof("io")) == 0) { + mode = BKPTMODE_IO; + } else { + return KDB_ARGCOUNT; + } + + length = 3; /* Default to 4 byte */ + + nextarg++; + + if ((argc + 1) != nextarg) { + diag = kdbgetularg((char *)argv[nextarg], &length); + if (diag) + return diag; + + if ((length > 4) || (length == 3)) + return KDB_BADLENGTH; + + length--; /* Normalize for debug register */ + nextarg++; + } + + if ((argc + 1) != nextarg) + return KDB_ARGCOUNT; + } + + /* + * Allocate a new bp structure + */ + free = same = KDB_MAXBPT; + for(i=0; ibp_addr = addr; + bp->bp_mode = mode; + bp->bp_length = length; + + bp->bp_reg = kdb_allocdbreg(bp) ; + if (bp->bp_reg == -1) { + return KDB_TOOMANYDBREGS; + } + + bp->bp_free = 0; + bp->bp_enabled = 1; + bp->bp_instvalid = 0; + +#if defined(__SMP__) + if (global) + bp->bp_global = 1; + else + bp->bp_cpu = smp_processor_id(); +#endif + + kdb_printbp(bp, free); + + return 0; +} + +/* + * kdb_bc + * + * Handles the 'bc', 'be', and 'bd' commands + * + * [bd|bc|be] + * + * Parameters: + * argc Count of arguments in argv + * argv Space delimited command line arguments + * envp Environment value + * regs Exception frame at entry to kernel debugger + * Outputs: + * None. + * Returns: + * Zero for success, a kdb diagnostic for failure + * Locking: + * None. + * Remarks: + */ +#define KDBCMD_BC 0 +#define KDBCMD_BE 1 +#define KDBCMD_BD 2 + +int +kdb_bc(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + kdb_machreg_t addr; + kdb_bp_t *bp = 0; + int lowbp = KDB_MAXBPT; + int highbp = 0; + int done = 0; + int i; + int diag; + int cmd; /* KDBCMD_B? */ + + if (strcmp(argv[0], "be") == 0) { + cmd = KDBCMD_BE; + } else if (strcmp(argv[0], "bd") == 0) { + cmd = KDBCMD_BD; + } else + cmd = KDBCMD_BC; + + if (argc != 1) + return KDB_ARGCOUNT; + + if (strcmp(argv[1], "*") == 0) { + lowbp = 0; + highbp = KDB_MAXBPT; + } else { + diag = kdbgetularg(argv[1], &addr); + if (diag) + return diag; + + /* + * For addresses less than the maximum breakpoint number, + * assume that the breakpoint number is desired. + */ + if (addr < KDB_MAXBPT) { + bp = &breakpoints[addr]; + lowbp = highbp = addr; + highbp++; + } else { + for(i=0; ibp_free) + continue; + + done++; + + switch (cmd) { + case KDBCMD_BC: + kdbremovedbreg(bp); + kdb_freedbreg(bp); + kdb_printf("Breakpoint %d at 0x%lx in dr%d cleared\n", + i, bp->bp_addr, bp->bp_reg); + bp->bp_free = 1; + bp->bp_addr = 0; + bp->bp_instvalid = 0; + break; + case KDBCMD_BE: + { + int r; + + r = kdb_allocdbreg(bp); + if (r == -1) { + return KDB_TOOMANYDBREGS; + } + + bp->bp_reg = r; + bp->bp_enabled = 1; + kdb_printf("Breakpoint %d at 0x%lx in dr%d enabled\n", + i, bp->bp_addr, bp->bp_reg); + + break; + } + case KDBCMD_BD: + kdbremovedbreg(bp); + kdb_freedbreg(bp); + bp->bp_enabled = 0; + bp->bp_instvalid = 0; + kdb_printf("Breakpoint %d at 0x%lx in dr%d disabled\n", + i, bp->bp_addr, bp->bp_reg); + break; + } + } + + return (!done)?KDB_BPTNOTFOUND:0; +} + +/* + * kdb_initbptab + * + * Initialize the breakpoint table. + * + * Parameters: + * None. + * Outputs: + * None. + * Returns: + * None. + * Locking: + * None. + * Remarks: + */ + +void +kdb_initbptab(void) +{ + int i; + + /* + * First time initialization. + */ + for (i=0; i]", "Set/Display breakpoints", 0); + kdb_register("bl", kdb_bp, "[]", "Display breakpoints", 0); + kdb_register("bpa", kdb_bp, "[]", "Set/Display global breakpoints", 0); + kdb_register("bph", kdb_bp, "[]", "Set hardware breakpoint", 0); + kdb_register("bpha", kdb_bp, "[]", "Set global hardware breakpoint", 0); + kdb_register("bc", kdb_bc, "", "Clear Breakpoint", 0); + kdb_register("be", kdb_bc, "", "Enable Breakpoint", 0); + kdb_register("bd", kdb_bc, "", "Disable Breakpoint", 0); + + kdb_register("ss", kdb_ss, "[<#steps>]", "Single Step", 1); + kdb_register("ssb", kdb_ss, "", "Single step to branch/call", 0); + + kdb_initdbregs(); +} + +/* + * kdb_ss + * + * Process the 'ss' (Single Step) and 'ssb' (Single Step to Branch) + * commands. + * + * ss [] + * ssb + * + * Parameters: + * argc Argument count + * argv Argument vector + * envp Environment vector + * regs Registers at time of entry to kernel debugger + * Outputs: + * None. + * Returns: + * 0 for success, a kdb error if failure. + * Locking: + * None. + * Remarks: + * + * Set the trace flag in the EFLAGS register to trigger + * a debug trap after the next instruction. Print the + * current instruction. + * + * For 'ssb', set the trace flag in the debug trap handler + * after printing the current insn and return directly without + * invoking the kdb command processor, until a branch instruction + * is encountered or SSCOUNT lines are printed. + */ + +int +kdb_ss(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + int ssb = 0; + + ssb = (strcmp(argv[0], "ssb") == 0); + if ((ssb && (argc != 0)) + || (!ssb && (argc > 1))) { + return KDB_ARGCOUNT; + } + +#if 0 + /* + * Fetch provided count + */ + diag = kdbgetularg(argv[1], &sscount); + if (diag) + return diag; +#endif + +#if 0 + /* + * Print current insn + */ + kdb_id1(kdba_getpc(regs)); +#endif + + /* + * Set trace flag and go. + */ + kdb_setsinglestep(regs); + kdb_state.cmd_given = CMDGIVEN_SSTEP ; + + if (ssb) + kdb_flags |= KDB_FLAG_SSB; + + return KDB_GO; +} + diff -urN test4.official/kdb/kdb_bt.c test4.official.kdb/kdb/kdb_bt.c --- test4.official/kdb/kdb_bt.c Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/kdb/kdb_bt.c Fri Aug 11 11:25:45 2000 @@ -0,0 +1,136 @@ +/* + * Minimalist Kernel Debugger - Architecture independent stack traceback + * + * Copyright (C) 1999 Silicon Graphics, Inc. + * Copyright (C) Scott Lurndal (slurn@engr.sgi.com) + * Copyright (C) Scott Foehner (sfoehner@engr.sgi.com) + * Copyright (C) Srinivasa Thirumalachar (sprasad@engr.sgi.com) + * + * Written March 1999 by Scott Lurndal at Silicon Graphics, Inc. + * + * Modifications from: + * Richard Bass 1999/07/20 + * Many bug fixes and enhancements. + * Scott Foehner + * Port to ia64 + * Srinivasa Thirumalachar + * RSE support for ia64 + * Masahiro Adegawa 1999/12/01 + * 'sr' command, active flag in 'ps' + * Scott Lurndal 1999/12/12 + * Significantly restructure for linux2.3 + * + */ + +#include +#include +#include +#include +#include +#include +#include + + +/* + * kdb_bt + * + * This function implements the 'bt' command. Print a stack + * traceback. + * + * bt [] (addr-exp is for alternate stacks) + * btp (Kernel stack for ) + * + * address expression refers to a return address on the stack. It + * is expected to be preceeded by a frame pointer. + * + * Inputs: + * argc argument count + * argv argument vector + * envp environment vector + * ef registers at time kdb was entered. + * Outputs: + * None. + * Returns: + * zero for success, a kdb diagnostic if error + * Locking: + * none. + * Remarks: + * Doing this without a frame pointer is _hard_. some simple + * things are done here, but we usually don't find more than the + * first couple of frames yet. More coming in this area. + * + * mds comes in handy when examining the stack to do a manual + * traceback. + */ + +int +kdb_bt(int argc, const char **argv, const char **envp, kdb_eframe_t ef) +{ + +#if 0 + return kdba_bt(argc, argv, envp, ef); +#else + int diag; + int argcount = 5; + char buffer[80]; + int nextarg; + unsigned long addr; + long offset; + + /* + * Determine how many possible arguments to print. + */ + diag = kdbgetintenv("BTARGS", &argcount); + + if (strcmp(argv[0], "bta") == 0) { + struct task_struct *p; + + for_each_task(p) { + kdb_printf("Stack traceback for pid %d\n", p->pid); + + diag = kdba_bt_process(p, argcount); + + kdb_getstr(buffer, sizeof(buffer), + "Enter to end, to continue:"); + + if (buffer[0] == 'q') { + return 0; + } + } + } else if (strcmp(argv[0], "btp") == 0) { + struct task_struct *p; + int pid; + + if (argc < 1) + return KDB_ARGCOUNT; + + diag = kdbgetularg((char *)argv[1], (unsigned long*)&pid); + if (diag) + return diag; + + for_each_task(p) { + if (p->pid == pid) { + return kdba_bt_process(p, argcount); + } + } + + kdb_printf("No process with pid == %d found\n", pid); + return 0; + } else { + if (argc) { + nextarg = 1; + diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, + &offset, NULL, ef); + if (diag) + return diag; + + return kdba_bt_stack(ef, &addr, argcount, current); + } else { + return kdba_bt_stack(ef, NULL, argcount, current); + } + } + + /* NOTREACHED */ + return 0; +#endif +} diff -urN test4.official/kdb/kdb_io.c test4.official.kdb/kdb/kdb_io.c --- test4.official/kdb/kdb_io.c Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/kdb/kdb_io.c Fri Aug 11 11:25:45 2000 @@ -0,0 +1,243 @@ +/* + * Kernel Debugger Console I/O handler + * + * Copyright (C) 1999 Silicon Graphics, Inc. + * Copyright (C) Scott Lurndal (slurn@engr.sgi.com) + * Copyright (C) Scott Foehner (sfoehner@engr.sgi.com) + * Copyright (C) Srinivasa Thirumalachar (sprasad@engr.sgi.com) + * + * Written March 1999 by Scott Lurndal at Silicon Graphics, Inc. + * + * Modifications from: + * Chuck Fleckenstein 1999/07/20 + * Move kdb_info struct declaration to this file + * for cases where serial support is not compiled into + * the kernel. + * + * Masahiro Adegawa 1999/07/20 + * Handle some peculiarities of japanese 86/106 + * keyboards. + * + * marc@mucom.co.il 1999/07/20 + * Catch buffer overflow for serial input. + * + * Scott Foehner + * Port to ia64 + * + * Scott Lurndal 2000/01/03 + * Restructure for v1.0 + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +static struct console *kdbcons = NULL; + +/* + * kdb_read + * + * This function reads a string of characters, terminated by + * a newline, or by reaching the end of the supplied buffer, + * from the current kernel debugger console device. + * Parameters: + * buffer - Address of character buffer to receive input characters. + * bufsize - size, in bytes, of the character buffer + * Returns: + * Returns a pointer to the buffer containing the received + * character string. This string will be terminated by a + * newline character. + * Locking: + * No locks are required to be held upon entry to this + * function. It is not reentrant - it relies on the fact + * that while kdb is running on any one processor all other + * processors will be spinning at the kdb barrier. + * Remarks: + * + * Davidm asks, why doesn't kdb use the console abstraction; + * here are some reasons: + * - you cannot debug the console abstraction with kdb if + * kdb uses it. + * - you rely on the correct functioning of the abstraction + * in the presence of general system failures. + * - You must acquire the console spinlock thus restricting + * the usability - what if the kernel fails with the spinlock + * held - one still wishes to debug such situations. + * - How about debugging before the console(s) are registered? + * - None of the current consoles (sercons, vt_console_driver) + * have read functions defined. + * - The standard pc keyboard and terminal drivers are interrupt + * driven. We cannot enable interrupts while kdb is active, + * so the standard input functions cannot be used by kdb. + * + * An implementation could be improved by removing the need for + * lock acquisition - just keep a 'struct console *kdbconsole;' global + * variable which refers to the preferred kdb console. + * + * The bulk of this function is architecture dependent. + */ + +char * +kdb_read(char *buffer, size_t bufsize) +{ + return kdba_read(buffer, bufsize); +} + +/* + * kdb_getstr + * + * Print the prompt string and read a command from the + * input device. + * + * Parameters: + * buffer Address of buffer to receive command + * bufsize Size of buffer in bytes + * prompt Pointer to string to use as prompt string + * Returns: + * Pointer to command buffer. + * Locking: + * None. + * Remarks: + * None. + */ + +char * +kdb_getstr(char *buffer, size_t bufsize, char *prompt) +{ + kdb_printf("%s", prompt); + return kdb_read(buffer, bufsize); +} + +/* + * kdb_printf + * + * Print a string to the output device(s). + * + * Parameters: + * printf-like format and optional args. + * Returns: + * 0 + * Locking: + * None. + * Remarks: + * use 'kdbcons->write()' to avoid polluting 'log_buf' with + * kdb output. + */ + +int +kdb_printf(const char *fmt, ...) +{ + char buffer[256]; + va_list ap; + int diag; + int linecount; + struct console *c = console_drivers; + + diag = kdbgetintenv("LINES", &linecount); + if (diag) + linecount = 22; + + va_start(ap, fmt); + vsprintf(buffer, fmt, ap); + va_end(ap); + + /* + * Write to all consoles. + */ + while (c) { + c->write(c, buffer, strlen(buffer)); + c = c->next; + } +/* Can't handle "more" functionality until setjmp/longjmp are working */ +#if 0 + if (strchr(buffer, '\n') != NULL) { + kdb_nextline++; + } + + if (kdb_nextline == linecount) { + char buf1[16]; +#if defined(CONFIG_SMP) + char buf2[32]; +#endif + char *moreprompt; + + /* + * Pause until cr. + */ + moreprompt = kdbgetenv("MOREPROMPT"); + if (moreprompt == NULL) { + moreprompt = "more> "; + } + +#if defined(CONFIG_SMP) + if (strchr(moreprompt, '%')) { + sprintf(buf2, moreprompt, smp_processor_id()); + moreprompt = buf2; + } +#endif + + c = console_drivers; + while (c) { + c->write(c, moreprompt, strlen(moreprompt)); + c = c->next; + } + + kdb_read(buf1, sizeof(buf1)); + + kdb_nextline = 1; + + if ((buf1[0] == 'q') + || (buf1[0] == 'Q')) { + kdb_longjmp(&kdbjmpbuf[smp_processor_id()], 1); + } + } +#endif + return 0; +} + +/* + * kdb_io_init + * + * Initialize kernel debugger output environment. + * + * Parameters: + * None. + * Returns: + * None. + * Locking: + * None. + * Remarks: + * Select a console device. + */ + +void +kdb_io_init(void) +{ + /* + * Select a console. + */ + struct console *c = console_drivers; + + while (c) { + if ((c->flags & CON_CONSDEV)) { + kdbcons = c; + break; + } + c = c->next; + } + + if (kdbcons == NULL) { + long long i; + + printk("kdb: Initialization failed - no console\n"); + while (1) i++; + } + return; +} diff -urN test4.official/kdb/kdbmain.c test4.official.kdb/kdb/kdbmain.c --- test4.official/kdb/kdbmain.c Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/kdb/kdbmain.c Fri Aug 11 11:25:45 2000 @@ -0,0 +1,2060 @@ +/* + * Minimalist Kernel Debugger + * + * Copyright (C) 1999 Silicon Graphics, Inc. + * Copyright (C) Scott Lurndal (slurn@engr.sgi.com) + * Copyright (C) Scott Foehner (sfoehner@engr.sgi.com) + * Copyright (C) Srinivasa Thirumalachar (sprasad@engr.sgi.com) + * Copyright (C) 2000 Stephane Eranian + * + * Written March 1999 by Scott Lurndal at Silicon Graphics, Inc. + * + * Modifications from: + * Richard Bass 1999/07/20 + * Many bug fixes and enhancements. + * Scott Foehner + * Port to ia64 + * Srinivasa Thirumalachar + * RSE support for ia64 + * Masahiro Adegawa 1999/12/01 + * 'sr' command, active flag in 'ps' + * Scott Lurndal 1999/12/12 + * Significantly restructure for linux2.3 + * Stephane Eranian 2000/06/05 + * Enabled disassembler support. Added command history support. + * + */ + +#include +#include +#include +#include +#include +#include +#if defined(__SMP__) +#include +#endif +#include +#include + +#include + + /* + * Kernel debugger state flags + */ +volatile int kdb_flags = 0; + + /* XXX - kdb_state to be removed in future release */ +kdb_state_t kdb_state; + /* + * kdb_lock protects updates to kdb_active. Used to + * single thread processors through the kernel debugger. + */ +spinlock_t kdb_lock = SPIN_LOCK_UNLOCKED; +volatile int kdb_active = 0; + +int kdb_nextline = 1; +int kdb_new_cpu = -1; + + /* + * Must have a setjmp buffer per CPU. Switching cpus will + * cause the jump buffer to be setup for the new cpu, and + * subsequent switches (and pager aborts) will use the + * appropriate per-processor values. + */ +kdb_jmp_buf kdbjmpbuf[NR_CPUS]; + + /* + * kdb_commands describes the available commands. + */ +static kdbtab_t kdb_commands[KDB_MAX_COMMANDS]; + +typedef struct _kdbmsg { + int km_diag; /* kdb diagnostic */ + char *km_msg; /* Corresponding message text */ +} kdbmsg_t; + +#define KDBMSG(msgnum, text) \ + { KDB_##msgnum, text } + +static kdbmsg_t kdbmsgs[] = { + KDBMSG(NOTFOUND,"Command Not Found"), + KDBMSG(ARGCOUNT, "Improper argument count, see usage."), + KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2 or 4"), + KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"), + KDBMSG(NOTENV, "Cannot find environment variable"), + KDBMSG(NOENVVALUE, "Environment variable should have value"), + KDBMSG(NOTIMP, "Command not implemented"), + KDBMSG(ENVFULL, "Environment full"), + KDBMSG(ENVBUFFULL, "Environment buffer full"), + KDBMSG(TOOMANYBPT, "Too many breakpoints defined"), + KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"), + KDBMSG(DUPBPT, "Duplicate breakpoint address"), + KDBMSG(BPTNOTFOUND, "Breakpoint not found"), + KDBMSG(BADMODE, "IDMODE should be x86 or 8086"), + KDBMSG(BADINT, "Illegal numeric value"), + KDBMSG(INVADDRFMT, "Invalid symbolic address format"), + KDBMSG(BADREG, "Invalid register name"), + KDBMSG(BADCPUNUM, "Invalid cpu number"), + KDBMSG(BADLENGTH, "Invalid length field"), + KDBMSG(NOBP, "No Breakpoint exists"), +}; +#undef KDBMSG + +static const int __nkdb_err = sizeof(kdbmsgs) / sizeof(kdbmsg_t); + + +/* + * Initial environment. This is all kept static and local to + * this file. We don't want to rely on the memory allocation + * mechanisms in the kernel, so we use a very limited allocate-only + * heap for new and altered environment variables. The entire + * environment is limited to a fixed number of entries (add more + * to __env[] if required) and a fixed amount of heap (add more to + * KDB_ENVBUFSIZE if required). + */ + +static char *__env[] = { +#if defined(CONFIG_SMP) + "PROMPT=[%d]kdb> ", + "MOREPROMPT=[%d]more> ", +#else + "PROMPT=kdb> ", + "MOREPROMPT=more> ", +#endif + "RADIX=16", + "LINES=24", + "COLUMNS=80", + "MDCOUNT=8", /* lines of md output */ + "IDCOUNT=16", /* lines of id output */ + "BTARGS=5", /* 5 possible args in bt */ + "SSCOUNT=20", /* lines of ssb output */ + KDB_PLATFORM_ENV, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, + (char *)0, +}; + +static const int __nenv = (sizeof(__env) / sizeof(char *)); + +/* + * kdbgetenv + * + * This function will return the character string value of + * an environment variable. + * + * Parameters: + * match A character string representing an environment variable. + * Outputs: + * None. + * Returns: + * NULL No environment variable matches 'match' + * char* Pointer to string value of environment variable. + * Locking: + * No locking considerations required. + * Remarks: + */ +char * +kdbgetenv(const char *match) +{ + char **ep = __env; + int matchlen = strlen(match); + int i; + + for(i=0; i<__nenv; i++) { + char *e = *ep++; + + if (!e) continue; + + if ((strncmp(match, e, matchlen) == 0) + && ((e[matchlen] == '\0') + ||(e[matchlen] == '='))) { + char *cp = strchr(e, '='); + return (cp)?++cp:""; + } + } + return (char *)0; +} + +/* + * kdballocenv + * + * This function is used to allocate bytes for environment entries. + * + * Parameters: + * match A character string representing a numeric value + * Outputs: + * *value the unsigned long represntation of the env variable 'match' + * Returns: + * Zero on success, a kdb diagnostic on failure. + * Locking: + * No locking considerations required. Must be called with all + * processors halted. + * Remarks: + * We use a static environment buffer (envbuffer) to hold the values + * of dynamically generated environment variables (see kdb_set). Buffer + * space once allocated is never free'd, so over time, the amount of space + * (currently 512 bytes) will be exhausted if env variables are changed + * frequently. + */ +static char * +kdballocenv(size_t bytes) +{ +#define KDB_ENVBUFSIZE 512 + static char envbuffer[KDB_ENVBUFSIZE]; + static int envbufsize = 0; + char *ep = (char *)0; + + if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) { + ep = &envbuffer[envbufsize]; + envbufsize += bytes; + } + return ep; +} + +/* + * kdbgetulenv + * + * This function will return the value of an unsigned long-valued + * environment variable. + * + * Parameters: + * match A character string representing a numeric value + * Outputs: + * *value the unsigned long represntation of the env variable 'match' + * Returns: + * Zero on success, a kdb diagnostic on failure. + * Locking: + * No locking considerations required. + * Remarks: + */ + +int +kdbgetulenv(const char *match, unsigned long *value) +{ + char *ep; + + ep = kdbgetenv(match); + if (!ep) return KDB_NOTENV; + if (strlen(ep) == 0) return KDB_NOENVVALUE; + + *value = simple_strtoul(ep, 0, 0); + + return 0; +} + +/* + * kdbgetintenv + * + * This function will return the value of an integer-valued + * environment variable. + * + * Parameters: + * match A character string representing an integer-valued env variable + * Outputs: + * *value the integer representation of the environment variable 'match' + * Returns: + * Zero on success, a kdb diagnostic on failure. + * Locking: + * No locking considerations required. + * Remarks: + */ + +int +kdbgetintenv(const char *match, int *value) { + unsigned long val; + int diag; + + diag = kdbgetulenv(match, &val); + if (!diag) { + *value = (int) val; + } + return diag; +} + +/* + * kdbgetularg + * + * This function will convert a numeric string + * into an unsigned long value. + * + * Parameters: + * arg A character string representing a numeric value + * Outputs: + * *value the unsigned long represntation of arg. + * Returns: + * Zero on success, a kdb diagnostic on failure. + * Locking: + * No locking considerations required. + * Remarks: + */ + +int +kdbgetularg(const char *arg, unsigned long *value) +{ + char *endp; + unsigned long val; + + val = simple_strtoul(arg, &endp, 0); + + if (endp == arg) { + /* + * Try base 16, for us folks too lazy to type the + * leading 0x... + */ + val = simple_strtoul(arg, &endp, 16); + if (endp == arg) + return KDB_BADINT; + } + + *value = val; + + return 0; +} + +/* + * kdbgetaddrarg + * + * This function is responsible for parsing an + * address-expression and returning the value of + * the expression, symbol name, and offset to the caller. + * + * The argument may consist of a numeric value (decimal or + * hexidecimal), a symbol name, a register name (preceeded + * by the percent sign), an environment variable with a numeric + * value (preceeded by a dollar sign) or a simple arithmetic + * expression consisting of a symbol name, +/-, and a numeric + * constant value (offset). + * + * Parameters: + * argc - count of arguments in argv + * argv - argument vector + * *nextarg - index to next unparsed argument in argv[] + * regs - Register state at time of KDB entry + * Outputs: + * *value - receives the value of the address-expression + * *offset - receives the offset specified, if any + * *name - receives the symbol name, if any + * *nextarg - index to next unparsed argument in argv[] + * + * Returns: + * zero is returned on success, a kdb diagnostic code is + * returned on error. + * + * Locking: + * No locking requirements. + * + * Remarks: + * + */ + +int +kdbgetaddrarg(int argc, const char **argv, int *nextarg, + unsigned long *value, long *offset, + char **name, kdb_eframe_t ef) +{ + unsigned long addr; + long off = 0; + int positive; + int diag; + char *symname; + char symbol = '\0'; + char *cp; + + /* + * Process arguments which follow the following syntax: + * + * symbol | numeric-address [+/- numeric-offset] + * %register + * $environment-variable + */ + + if (*nextarg > argc) { + return KDB_ARGCOUNT; + } + + symname = (char *)argv[*nextarg]; + + /* + * If there is no whitespace between the symbol + * or address and the '+' or '-' symbols, we + * remember the character and replace it with a + * null so the symbol/value can be properly parsed + */ + if ((cp = strpbrk(symname, "+-")) != NULL) { + symbol = *cp; + *cp++ = '\0'; + } + + if (symname[0] == '$') { + diag = kdbgetulenv(&symname[1], &addr); + if (diag) + return diag; + } else if (symname[0] == '%') { + diag = kdba_getregcontents(&symname[1], ef, &addr); + if (diag) + return diag; + } else { + addr = kdbgetsymval(symname); + if (addr == 0) { + diag = kdbgetularg(argv[*nextarg], &addr); + if (diag) + return diag; + } + } + + symname = kdbnearsym(addr); + + (*nextarg)++; + + if (name) + *name = symname; + if (value) + *value = addr; + if (offset && name && *name) + *offset = addr - kdbgetsymval(*name); + + if ((*nextarg > argc) + && (symbol == '\0')) + return 0; + + /* + * check for +/- and offset + */ + + if (symbol == '\0') { + if ((argv[*nextarg][0] != '+') + && (argv[*nextarg][0] != '-')) { + /* + * Not our argument. Return. + */ + return 0; + } else { + positive = (argv[*nextarg][0] == '+'); + (*nextarg)++; + } + } else + positive = (symbol == '+'); + + /* + * Now there must be an offset! + */ + if ((*nextarg > argc) + && (symbol == '\0')) { + return KDB_INVADDRFMT; + } + + if (!symbol) { + cp = (char *)argv[*nextarg]; + (*nextarg)++; + } + + diag = kdbgetularg(cp, &off); + if (diag) + return diag; + + if (!positive) + off = -off; + + if (offset) + *offset += off; + + if (value) + *value += off; + + return 0; +} + +static void +kdb_cmderror(int diag) +{ + int i; + + if (diag >= 0) { + kdb_printf("no error detected\n"); + return; + } + + for(i=0; i<__nkdb_err; i++) { + if (kdbmsgs[i].km_diag == diag) { + kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg); + return; + } + } + + kdb_printf("Unknown diag %d\n", -diag); +} + +/* + * kdb_parse + * + * Parse the command line, search the command table for a + * matching command and invoke the command function. + * + * Parameters: + * cmdstr The input command line to be parsed. + * regs The registers at the time kdb was entered. + * Outputs: + * None. + * Returns: + * Zero for success, a kdb diagnostic if failure. + * Locking: + * None. + * Remarks: + * Limited to 20 tokens. + * + * Real rudimentary tokenization. Basically only whitespace + * is considered a token delimeter (but special consideration + * is taken of the '=' sign as used by the 'set' command). + * + * The algorithm used to tokenize the input string relies on + * there being at least one whitespace (or otherwise useless) + * character between tokens as the character immediately following + * the token is altered in-place to a null-byte to terminate the + * token string. + */ + +#define MAXARGC 20 + +static int +kdb_parse(char *cmdstr, kdb_eframe_t ef) +{ + char *argv[MAXARGC]; + int argc=0; + char *cp; + kdbtab_t *tp; + int i; + + /* + * First tokenize the command string. + */ + cp = cmdstr; + + /* + * If a null statement is provided, do nothing. + */ + if ((*cp == '\n') || (*cp == '\0')) + return 0; + + while (*cp) { + /* skip whitespace */ + while (isspace(*cp)) cp++; + if ((*cp == '\0') || (*cp == '\n')) + break; + argv[argc++] = cp; + /* Skip to next whitespace */ + for(; *cp && (!isspace(*cp) && (*cp != '=')); cp++); + *cp++ = '\0'; /* Squash a ws or '=' character */ + } + + for(tp=kdb_commands, i=0; i < KDB_MAX_COMMANDS; i++,tp++) { + if (tp->cmd_name) { + /* + * If this command is allowed to be abbreviated, + * check to see if this is it. + */ + + if (tp->cmd_minlen + && (strlen(argv[0]) <= tp->cmd_minlen)) { + if (strncmp(argv[0], + tp->cmd_name, + tp->cmd_minlen) == 0) { + break; + } + } + + if (strcmp(argv[0], tp->cmd_name)==0) { + break; + } + } + } + + if (i < KDB_MAX_COMMANDS) { + return (*tp->cmd_func)(argc-1, + (const char**)argv, + (const char**)__env, + ef); + } + + /* + * If the input with which we were presented does not + * map to an existing command, attempt to parse it as an + * address argument and display the result. Useful for + * obtaining the address of a variable, or the nearest symbol + * to an address contained in a register. + */ + { + unsigned long value; + char *name = NULL; + long offset; + int nextarg = 0; + + if (kdbgetaddrarg(0, (const char **)argv, &nextarg, + &value, &offset, &name, ef)) { + return KDB_NOTFOUND; + } + + kdb_printf(((sizeof(long)==4)?"%s = 0x%8.8x ":"%s = 0x%16.16lx "), argv[0], value); + if (name) { + kdb_printf("(%s+0x%lx)", name, offset); + } + kdb_printf("\n"); + return 0; + } +} + +#define KDB_CMD_HISTORY_COUNT 32 +#define CMD_BUFLEN 256 +static unsigned int cmd_head, cmd_tail; +static unsigned int cmdptr; +static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN]; + + +static int +handle_ctrl_cmd(char *cmd) +{ +#define CTRL_P 16 +#define CTRL_N 14 + + /* initial situation */ + if (cmd_head == cmd_tail) return 1; + + switch(*cmd) { + case '\n': + case CTRL_P: + if (cmdptr != cmd_tail) + cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT; + strcpy(cmd, cmd_hist[cmdptr]); + return 0; + case CTRL_N: + if (cmdptr != (cmd_head-1)) + cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT; + strcpy(cmd, cmd_hist[cmdptr]); + return 0; + } + return 1; +} + + +/* + * kdb + * + * This function is the entry point for the kernel debugger. It + * provides a command parser and associated support functions to + * allow examination and control of an active kernel. + * + * This function may be invoked directly from any + * point in the kernel by calling with reason == KDB_REASON_ENTER + * (XXX - note that the regs aren't set up this way - could + * use a software interrupt to enter kdb to get regs...) + * + * The breakpoint trap code should invoke this function with + * one of KDB_REASON_BREAK (int 03) or KDB_REASON_DEBUG (debug register) + * + * the panic function should invoke this function with + * KDB_REASON_PANIC. + * + * The kernel fault handler should invoke this function with + * reason == KDB_REASON_FAULT and error == trap vector #. + * + * Inputs: + * reason The reason KDB was invoked + * error The hardware-defined error code + * regs The registers at time of fault/breakpoint + * Returns: + * 0 KDB was invoked for an event which it wasn't responsible + * 1 KDB handled the event for which it was invoked. + * Locking: + * none + * Remarks: + * No assumptions of system state. This function may be invoked + * with arbitrary locks held. It will stop all other processors + * in an SMP environment, disable all interrupts and does not use + * the operating systems keyboard driver. + */ + +int +kdb(kdb_reason_t reason, int error, kdb_eframe_t ef) +{ + char *cmdbuf; + char cmd[CMD_BUFLEN]; + int diag=0; + int parsed_once=0; /* if falsem don't repeat last cmd on CR */ + kdb_intstate_t int_state; /* Interrupt state */ + + /* + * Disable processor interrupts during kdb command processing + */ + kdba_disableint(&int_state); + +#if defined(KDBDEBUG) + kdba_printlbr(); +#endif + + /* + * The processors may race getting to this point - if, + * for example, more than one processor hits a breakpoint + * at the same time. We'll serialize access to kdb here - + * other processors will loop here, and the NMI from the stop + * IPI should take them into kdb through the back door. Once + * the initial processor releases the debugger, the rest of + * the processors will race for it. + */ + + /* + * First, remove the breakpoints both to prevent double-faults + * if kdb happens to use a function where a breakpoint + * has been enabled, as well as so that the breakpoint register(s) + * will get restored correctly on other processors after they + * leave the kernel debugger serialization barrier. + */ + + /* XXX - kdb_state to be removed in future release */ + kdb_state.kdb_action = ACTION_UNKNOWN ; + /* will be set by kdb_db_trap */ + + kdb_bp_remove(); + + /* + * If this is a panic, and kdb is already active, + * print a message and continue - we can attempt to + * debug kdb this way. + */ + if (reason == KDB_REASON_PANIC) { + int save_active; + + spin_lock(&kdb_lock); + save_active = kdb_active; + spin_unlock(&kdb_lock); + + if (save_active) { + printk("Debugger re-enterred due to panic\n"); + } + } else + + /* + * If not entering the debugger due to CPU switch, + * serialize access here. + */ + if (reason != KDB_REASON_SWITCH) { + spin_lock(&kdb_lock); + + while (kdb_active) { + spin_unlock(&kdb_lock); + + while (kdb_active) + ; + + spin_lock(&kdb_lock); + } + + kdb_active = reason; + + spin_unlock(&kdb_lock); + kdb_new_cpu = -1; + } else if (!kdb_active) { + printk("kdb: CPU switch without kdb_active, I'm confused\n"); + } + + if (reason != KDB_REASON_DEBUG) { + kdb_printf("Entering kdb (0x%x) ", current); +#if defined(__SMP__) + kdb_printf("on processor %d ", smp_processor_id()); +#endif + } + + switch (reason) { + case KDB_REASON_DEBUG: + case KDB_REASON_FLTDBG: + { + kdb_dbtrap_t result; + /* + * If re-entering kdb after a single step + * command, don't print the message. + */ + result = kdb_db_trap(ef, reason); + switch(result) { + case KDB_DB_BPT: + kdb_printf("Entering kdb (0x%x) ", current); +#if defined(__SMP__) + kdb_printf("on processor %d ", smp_processor_id()); +#endif + break; + case KDB_DB_NOBPT: + /* + * Called due to non-existant breakpoint. This can + * happen if a breakpoint is cleared with the 'bc' + * command while other processors are queueud up + * waiting to enter kdb(). + * + * Ignore it, return, clear kdb_active. + */ + + kdb_active = 0; + kdba_restoreint(&int_state); + return 0; /* Indicate not handled */ + + case KDB_DB_SSB: + /* + * In the midst of ssb command. Just return. + */ + kdb_active = 0; + kdba_restoreint(&int_state); + return 1; /* We've handled this fault */ + + break; + case KDB_DB_SS: + break; + default: + printk("kdb: Bad result from kdb_db_trap: %d\n", + result); + break; + } + + } + break; + case KDB_REASON_FAULT: + break; + case KDB_REASON_INT: + kdb_printf("due to KDB_ENTER() call\n"); + break; + case KDB_REASON_KEYBOARD: + kdb_printf("due to Keyboard Entry\n"); + break; + case KDB_REASON_SWITCH: + kdb_printf("due to cpu switch\n"); + break; + case KDB_REASON_ENTER: + kdb_printf("due to function call\n"); + /* + * Get a set of registers that defines the current + * context (as of the call to kdb). + */ + kdb_getcurrentframe(ef); + kdba_setpc(ef, (long)(&kdb)); /* for traceback */ + break; + case KDB_REASON_PANIC: + kdb_printf("Panic: %s\n", kdb_diemsg); + kdb_printf("due to panic @ 0x%x\n", kdba_getpc(ef)); + kdba_dumpregs(ef, NULL, NULL); + break; + case KDB_REASON_NMI: + kdb_printf("due to NonMaskable Interrupt @ 0x%x\n", + kdba_getpc(ef)); + kdba_dumpregs(ef, NULL, NULL); + break; + case KDB_REASON_BREAK: + kdb_printf("due to Breakpoint @ 0x%x\n", kdba_getpc(ef)); + /* + * Determine if this breakpoint is one that we + * are interested in. + */ +#if 0 + switch (kdb_bp_trap(ef)) { + case KDB_DB_BPT: + break; + case KDB_DB_SS: + case KDB_DB_SSB: + printk("kdb: error return from kdb_bp_trap\n"); + /* FALLTHROUGH */ + case KDB_DB_NOBPT: + default: + return 0; /* Not for us, dismiss it */ + } +#endif + break; + default: + break; + } + +#if defined(__SMP__) + /* + * If SMP, stop other processors + */ + if ((reason != KDB_REASON_SWITCH) + && (smp_num_cpus > 1)) { + /* + * Stop all other processors + */ + smp_kdb_stop(1, ef); + } +#endif /* __SMP__ */ + + /* XXX - kdb_state to be removed in future release */ + if (kdb_state.kdb_action != ACTION_NOPROMPT) + while (1) { + /* + * Initialize pager context. + */ + kdb_nextline = 1; +#if 0 + /* + * Use kdb_setjmp/kdb_longjmp to break out of + * the pager early. + */ + if (kdb_setjmp(&kdbjmpbuf[smp_processor_id()])) { + /* + * Command aborted (usually in pager) + */ + + /* + * XXX - need to abort a SSB ? + */ + continue; + } +#endif + +do_full_getstr: +#if defined(CONFIG_SMP) + kdb_printf(kdbgetenv("PROMPT"), smp_processor_id()); +#else + kdb_printf(kdbgetenv("PROMPT")); +#endif + + + cmdbuf = cmd_hist[cmd_head]; + *cmdbuf = '\0'; +get_again: + /* + * Fetch command from keyboard + */ + cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN,""); + if (*cmdbuf < 32) { + int not_cr = *cmdbuf == '\n' ? 0 : 1; + + if (!(not_cr || parsed_once) + || handle_ctrl_cmd(cmdbuf)) goto do_full_getstr; + + if (not_cr) goto get_again; + } + + if (*cmdbuf != '\n') { + cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT; + if (cmd_head == cmd_tail) cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT; + + parsed_once = 1; + } + + cmdptr = cmd_head; + strcpy(cmd, cmdbuf); /* copy because of destructive parsing */ + diag = kdb_parse(cmd, ef); + if (diag == KDB_NOTFOUND) { + kdb_printf("Unknown kdb command: '%s'\n", cmd); + diag = 0; + } + if ((diag == KDB_GO) + || (diag == KDB_CPUSWITCH)) + break; /* Go or cpu switch command */ + + if (diag) + kdb_cmderror(diag); + } + +#if defined(__SMP__) + if ((diag == KDB_CPUSWITCH) + && (kdb_new_cpu != -1)) { + /* + * Leaving the other CPU's at the barrier, except the + * one we are switching to, we'll come to the barrier + * until released by the 'cpu' or 'go' commands. + */ + + set_bit(smp_processor_id(), &smp_kdb_wait); + /* + * let the new cpu go. + */ + clear_bit(kdb_new_cpu, &smp_kdb_wait); + + while (test_bit(smp_processor_id(), &smp_kdb_wait)) + ; + + if (kdb_new_cpu == smp_processor_id()) { + /* + * Back off the stack and revert to called location. + */ +#if 0 + kdb_longjmp(&kdbjmpbuf[smp_processor_id()], 2); +#endif + } + } else { + /* + * Let the other processors continue. + */ + kdb_new_cpu = -1; + smp_kdb_wait = 0; + } +#endif + /* + * Set up debug registers. + */ + /* XXX - kdb_state to be removed in future release */ + if (kdb_state.kdb_action != ACTION_NOBPINSTALL) { + kdb_bp_install(); + } + + kdb_flags &= ~(KDB_FLAG_SUPRESS|KDB_FLAG_FAULT); + + if (diag != KDB_CPUSWITCH) + kdb_active = 0; +#if 0 + kdba_enablelbr(); +#endif + kdba_restoreint(&int_state); + + return 1; +} + +/* + * kdb_md + * + * This function implements the 'md' and 'mds' commands. + * + * md|mds [ [ []]] + * + * Inputs: + * argc argument count + * argv argument vector + * envp environment vector + * regs registers at time kdb was entered. + * Outputs: + * None. + * Returns: + * zero for success, a kdb diagnostic if error + * Locking: + * none. + * Remarks: + */ + +int +kdb_md(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + char fmtchar; + char fmtstr[64]; + int radix, count, width; + unsigned long addr; + unsigned long word; + long offset = 0; + int diag; + int nextarg; + static unsigned long lastaddr = 0; + static unsigned long lastcount = 0; + static unsigned long lastradix = 0; + char lastbuf[50]; + int symbolic = 0; + + /* + * Defaults in case the relevent environment variables are unset + */ + radix = 16; + count = 8; + width = sizeof(long); + + if (argc == 0) { + if (lastaddr == 0) + return KDB_ARGCOUNT; + sprintf(lastbuf, "0x%lx", lastaddr); + argv[1] = lastbuf; + argc = 1; + count = lastcount; + radix = lastradix; + } else { + unsigned long val; + + if (argc >= 2) { + + diag = kdbgetularg(argv[2], &val); + if (!diag) + count = (int) val; + } else { + diag = kdbgetintenv("MDCOUNT", &count); + } + + if (argc >= 3) { + diag = kdbgetularg(argv[3], &val); + if (!diag) + radix = (int) val; + } else { + diag = kdbgetintenv("RADIX",&radix); + } + } + + switch (radix) { + case 10: + fmtchar = 'd'; + break; + case 16: + fmtchar = 'x'; + break; + case 8: + fmtchar = 'o'; + break; + default: + return KDB_BADRADIX; + } + + diag = kdbgetintenv("BYTESPERWORD", &width); + + if (strcmp(argv[0], "mds") == 0) { + symbolic = 1; + width = 4; + } + + switch (width) { + case 8: + sprintf(fmtstr, "%%16.16l%c ", fmtchar); + break; + case 4: + sprintf(fmtstr, "%%8.8%c ", fmtchar); + break; + case 2: + sprintf(fmtstr, "%%4.4%c ", fmtchar); + break; + case 1: + sprintf(fmtstr, "%%2.2%c ", fmtchar); + break; + default: + return KDB_BADWIDTH; + } + + + nextarg = 1; + diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); + if (diag) + return diag; + + /* Round address down modulo BYTESPERWORD */ + + addr &= ~(width-1); + + /* + * Remember count and radix for next 'md' + */ + lastcount = count; + lastradix = radix; + + while (count--) { + int num = (symbolic?1 :(16 / width)); + char cbuf[32]; + char *c = cbuf; + char t; + int i; + + for(i=0; i argc) + return KDB_ARGCOUNT; + + diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL, regs); + if (diag) + return diag; + + if (nextarg != argc + 1) + return KDB_ARGCOUNT; + + /* + * To prevent modification of invalid addresses, check first. + */ + word = kdba_getword(addr, sizeof(word)); + if (kdb_flags & KDB_FLAG_SUPRESS) { + kdb_flags &= ~KDB_FLAG_SUPRESS; + return 0; + } + + diag = kdba_putword(addr, sizeof(contents), contents); + + kdb_printf("0x%lx = 0x%lx\n", addr, contents); + + return 0; +} + +/* + * kdb_go + * + * This function implements the 'go' command. + * + * go [address-expression] + * + * Inputs: + * argc argument count + * argv argument vector + * envp environment vector + * regs registers at time kdb was entered. + * Outputs: + * None. + * Returns: + * zero for success, a kdb diagnostic if error + * Locking: + * none. + * Remarks: + */ + +int +kdb_go(int argc, const char **argv, const char **envp, kdb_eframe_t ef) +{ + unsigned long addr; + int diag; + int nextarg; + long offset; + + if (argc == 1) { + nextarg = 1; + diag = kdbgetaddrarg(argc, argv, &nextarg, + &addr, &offset, NULL, ef); + if (diag) + return diag; + + kdba_setpc(ef, addr); + } else if (argc) + return KDB_ARGCOUNT; + + /* XXX - kdb_state to be removed in future release */ + kdb_state.cmd_given = CMDGIVEN_GO ; + + return KDB_GO; +} + +/* + * kdb_rd + * + * This function implements the 'rd' command. + * + * rd display all general registers. + * rd c display all control registers. + * rd d display all debug registers. + * + * Inputs: + * argc argument count + * argv argument vector + * envp environment vector + * regs registers at time kdb was entered. + * Outputs: + * None. + * Returns: + * zero for success, a kdb diagnostic if error + * Locking: + * none. + * Remarks: + */ + +int +kdb_rd(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + /* + */ + + if (argc == 0) { + return kdba_dumpregs(regs, NULL, NULL); + } + + if (argc > 2) { + return KDB_ARGCOUNT; + } + + return kdba_dumpregs(regs, argv[1], argv[2]); +} + +/* + * kdb_rm + * + * This function implements the 'rm' (register modify) command. + * + * rm register-name new-contents + * + * Inputs: + * argc argument count + * argv argument vector + * envp environment vector + * regs registers at time kdb was entered. + * Outputs: + * None. + * Returns: + * zero for success, a kdb diagnostic if error + * Locking: + * none. + * Remarks: + * Currently doesn't allow modification of control or + * debug registers, nor does it allow modification + * of model-specific registers (MSR). + */ + +int +kdb_rm(int argc, const char **argv, const char **envp, kdb_eframe_t ef) +{ + int diag; + int ind = 0; + unsigned long contents; + + if (argc != 2) { + return KDB_ARGCOUNT; + } + + /* + * Allow presence or absence of leading '%' symbol. + */ + + if (argv[1][0] == '%') + ind = 1; + + diag = kdbgetularg(argv[2], &contents); + if (diag) + return diag; + + diag = kdba_setregcontents(&argv[1][ind], ef, contents); + if (diag) + return diag; + + return 0; +} + +#if defined(CONFIG_MAGIC_SYSRQ) +/* + * kdb_sr + * + * This function implements the 'sr' (SYSRQ key) command which + * interfaces to the soi-disant MAGIC SYSRQ functionality. + * + * sr + * + * Inputs: + * argc argument count + * argv argument vector + * envp environment vector + * regs registers at time kdb was entered. + * Outputs: + * None. + * Returns: + * zero for success, a kdb diagnostic if error + * Locking: + * none. + * Remarks: + * None. + */ +int +kdb_sr(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + if (argc != 1) { + return KDB_ARGCOUNT; + } + + handle_sysrq(*argv[1], regs, 0, 0); + + return 0; +} +#endif /* CONFIG_MAGIC_SYSRQ */ + +/* + * kdb_ef + * + * This function implements the 'ef' (display exception frame) + * command. This command takes an address and expects to find + * an exception frame at that address, formats and prints it. + * + * ef address-expression + * + * Inputs: + * argc argument count + * argv argument vector + * envp environment vector + * regs registers at time kdb was entered. + * Outputs: + * None. + * Returns: + * zero for success, a kdb diagnostic if error + * Locking: + * none. + * Remarks: + * Not done yet. + */ + +int +kdb_ef(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + int diag; + kdb_machreg_t addr; + long offset; + int nextarg; + + if (argc == 1) { + nextarg = 1; + diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); + if (diag) + return diag; + + return kdba_dumpregs((struct pt_regs *)addr, NULL, NULL); + } + + return KDB_ARGCOUNT; +} + +/* + * kdb_reboot + * + * This function implements the 'reboot' command. Reboot the system + * immediately. + * + * Inputs: + * argc argument count + * argv argument vector + * envp environment vector + * regs registers at time kdb was entered. + * Outputs: + * None. + * Returns: + * zero for success, a kdb diagnostic if error + * Locking: + * none. + * Remarks: + * Shouldn't return from this function. + */ + +int +kdb_reboot(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + machine_restart(0); + /* NOTREACHED */ + return 0; +} + +/* + * kdb_env + * + * This function implements the 'env' command. Display the current + * environment variables. + * + * Inputs: + * argc argument count + * argv argument vector + * envp environment vector + * regs registers at time kdb was entered. + * Outputs: + * None. + * Returns: + * zero for success, a kdb diagnostic if error + * Locking: + * none. + * Remarks: + */ + +int +kdb_env(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + int i; + + for(i=0; i<__nenv; i++) { + if (__env[i]) { + kdb_printf("%s\n", __env[i]); + } + } + + return 0; +} + +/* + * kdb_set + * + * This function implements the 'set' command. Alter an existing + * environment variable or create a new one. + * + * Inputs: + * argc argument count + * argv argument vector + * envp environment vector + * regs registers at time kdb was entered. + * Outputs: + * None. + * Returns: + * zero for success, a kdb diagnostic if error + * Locking: + * none. + * Remarks: + */ + +int +kdb_set(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + int i; + char *ep; + size_t varlen, vallen; + + /* + * we can be invoked two ways: + * set var=value argv[1]="var", argv[2]="value" + * set var = value argv[1]="var", argv[2]="=", argv[3]="value" + * - if the latter, shift 'em down. + */ + if (argc == 3) { + argv[2] = argv[3]; + argc--; + } + + if (argc != 2) + return KDB_ARGCOUNT; + + /* + * Tokenizer squashed the '=' sign. argv[1] is variable + * name, argv[2] = value. + */ + varlen = strlen(argv[1]); + vallen = strlen(argv[2]); + ep = kdballocenv(varlen + vallen + 2); + if (ep == (char *)0) + return KDB_ENVBUFFULL; + + sprintf(ep, "%s=%s", argv[1], argv[2]); + + ep[varlen+vallen+1]='\0'; + + for(i=0; i<__nenv; i++) { + if (__env[i] + && ((strncmp(__env[i], argv[1], varlen)==0) + && ((__env[i][varlen] == '\0') + || (__env[i][varlen] == '=')))) { + __env[i] = ep; + return 0; + } + } + + /* + * Wasn't existing variable. Fit into slot. + */ + for(i=0; i<__nenv-1; i++) { + if (__env[i] == (char *)0) { + __env[i] = ep; + return 0; + } + } + + return KDB_ENVFULL; +} + +#if defined(__SMP__) +/* + * kdb_cpu + * + * This function implements the 'cpu' command. + * + * cpu [] + * + * Inputs: + * argc argument count + * argv argument vector + * envp environment vector + * regs registers at time kdb was entered. + * Outputs: + * None. + * Returns: + * zero for success, a kdb diagnostic if error + * Locking: + * none. + * Remarks: + */ + +int +kdb_cpu(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + unsigned long cpunum; + int diag; + + if (argc == 0) { + int i; + + kdb_printf("Currently on cpu %d\n", smp_processor_id()); + kdb_printf("Available cpus: "); + for (i=0; i NR_CPUS) + || !test_bit(cpunum, &cpu_online_map)) + return KDB_BADCPUNUM; + + kdb_new_cpu = cpunum; + + /* + * Switch to other cpu + */ + return KDB_CPUSWITCH; +} +#endif /* __SMP__ */ + +/* + * kdb_ps + * + * This function implements the 'ps' command which shows + * a list of the active processes. + * + * Inputs: + * argc argument count + * argv argument vector + * envp environment vector + * regs registers at time kdb was entered. + * Outputs: + * None. + * Returns: + * zero for success, a kdb diagnostic if error + * Locking: + * none. + * Remarks: + */ + +int +kdb_ps(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + struct task_struct *p; + + kdb_printf("Task Addr Pid Parent [*] cpu State Thread Command\n"); + for_each_task(p) { + kdb_printf("0x%8.8x %8.8d %8.8d %1.1d %3.3d %s 0x%8.8x%c%s\n", + p, p->pid, p->p_pptr->pid, + p->has_cpu, p->processor, + (p->state == 0)?"run ":(p->state>0)?"stop":"unrn", + &p->thread, + (p == current) ? '*': ' ', + p->comm); + } + + return 0; +} + +/* + * kdb_ll + * + * This function implements the 'll' command which follows a linked + * list and executes an arbitrary command for each element. + * + * Inputs: + * argc argument count + * argv argument vector + * envp environment vector + * regs registers at time kdb was entered. + * Outputs: + * None. + * Returns: + * zero for success, a kdb diagnostic if error + * Locking: + * none. + * Remarks: + */ + +int +kdb_ll(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + int diag; + unsigned long addr; + long offset = 0; + unsigned long va; + unsigned long linkoffset; + int nextarg; + + if (argc != 3) { + return KDB_ARGCOUNT; + } + + nextarg = 1; + diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL, regs); + if (diag) + return diag; + + diag = kdbgetularg(argv[2], &linkoffset); + if (diag) + return diag; + + /* + * Using the starting address as + * the first element in the list, and assuming that + * the list ends with a null pointer. + */ + + va = addr; + + while (va) { + char buf[80]; + + sprintf(buf, "%s 0x%lx\n", argv[3], va); + diag = kdb_parse(buf, regs); + if (diag) + return diag; + + addr = va + linkoffset; + va = kdba_getword(addr, sizeof(va)); + if (kdb_flags & KDB_FLAG_SUPRESS) { + kdb_flags &= ~KDB_FLAG_SUPRESS; + return 0; + } + } + + return 0; +} + +/* + * kdb_help + * + * This function implements the 'help' and '?' commands. + * + * Inputs: + * argc argument count + * argv argument vector + * envp environment vector + * regs registers at time kdb was entered. + * Outputs: + * None. + * Returns: + * zero for success, a kdb diagnostic if error + * Locking: + * none. + * Remarks: + */ + +int +kdb_help(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + kdbtab_t *kt; + + kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description"); + kdb_printf("----------------------------------------------------------\n"); + for(kt=kdb_commands; kt->cmd_name; kt++) { + kdb_printf("%-15.15s %-20.20s %s\n", kt->cmd_name, + kt->cmd_usage, kt->cmd_help); + } + return 0; +} + +/* + * kdb_register + * + * This function is used to register a kernel debugger command. + * + * Inputs: + * cmd Command name + * func Function to execute the command + * usage A simple usage string showing arguments + * help A simple help string describing command + * Outputs: + * None. + * Returns: + * zero for success, one if a duplicate command. + * Locking: + * none. + * Remarks: + * + */ + +int +kdb_register(char *cmd, + kdb_func_t func, + char *usage, + char *help, + short minlen) +{ + int i; + kdbtab_t *kp; + + /* + * Brute force method to determine duplicates + */ + for (i=0, kp=kdb_commands; icmd_name && (strcmp(kp->cmd_name, cmd)==0)) { + kdb_printf("Duplicate kdb command registered: '%s'\n", + cmd); + return 1; + } + } + + /* + * Insert command into first available location in table + */ + for (i=0, kp=kdb_commands; icmd_name == NULL) { + kp->cmd_name = cmd; + kp->cmd_func = func; + kp->cmd_usage = usage; + kp->cmd_help = help; + kp->cmd_flags = 0; + kp->cmd_minlen = minlen; + break; + } + } + return 0; +} + +/* + * kdb_unregister + * + * This function is used to unregister a kernel debugger command. + * It is generally called when a module which implements kdb + * commands is unloaded. + * + * Inputs: + * cmd Command name + * Outputs: + * None. + * Returns: + * zero for success, one command not registered. + * Locking: + * none. + * Remarks: + * + */ + +int +kdb_unregister(char *cmd) +{ + int i; + kdbtab_t *kp; + + /* + * find the command. + */ + for (i=0, kp=kdb_commands; icmd_name && (strcmp(kp->cmd_name, cmd)==0)) { + kp->cmd_name = NULL; + return 0; + } + } + + /* + * Couldn't find it. + */ + return 1; +} + +/* + * kdb_id + * + * This function is used to disassemble code from memory + * + */ +int +kdb_id(int argc, const char **argv, const char **envp, kdb_eframe_t regs) +{ + return kdba_id(argc, argv, envp, regs); +} + + +/* + * kdb_inittab + * + * This function is called by the kdb_init function to initialize + * the kdb command table. It must be called prior to any other + * call to kdb_register. + * + * Inputs: + * None. + * Outputs: + * None. + * Returns: + * None. + * Locking: + * None. + * Remarks: + * + */ + +void +kdb_inittab(void) +{ + int i; + kdbtab_t *kp; + + for(i=0, kp=kdb_commands; i < KDB_MAX_COMMANDS; i++,kp++) { + kp->cmd_name = NULL; + } + + kdb_register("md", kdb_md, "", "Display Memory Contents", 1); + kdb_register("mds", kdb_md, "", "Display Memory Symbolically", 0); + kdb_register("mm", kdb_mm, " ", "Modify Memory Contents", 0); + kdb_register("id", kdb_id, "[] [bundle_count]", "Disassemble Instructions", 1); + kdb_register("go", kdb_go, "[]", "Continue Execution", 1); + kdb_register("rd", kdb_rd, "", "Display Registers", 1); + kdb_register("rm", kdb_rm, " ", "Modify Registers", 0); + kdb_register("ef", kdb_ef, "", "Display exception frame", 0); + kdb_register("bt", kdb_bt, "[]", "Stack traceback", 1); + kdb_register("btp", kdb_bt, "", "Display stack for process ", 0); + kdb_register("bta", kdb_bt, "", "Display stack all processes", 0); + kdb_register("ll", kdb_ll, " ", "Execute cmd for each element in linked list", 0); + kdb_register("env", kdb_env, "", "Show environment variables", 0); + kdb_register("set", kdb_set, "", "Set environment variables", 0); + kdb_register("help", kdb_help, "", "Display Help Message", 1); + kdb_register("?", kdb_help, "", "Display Help Message", 0); +#if defined(__SMP__) + kdb_register("cpu", kdb_cpu, "","Switch to new cpu", 0); +#endif /* __SMP__ */ + kdb_register("ps", kdb_ps, "", "Display active task list", 0); + kdb_register("reboot", kdb_reboot, "", "Reboot the machine immediately", 0); +#if defined(CONFIG_MAGIC_SYSRQ) + kdb_register("sr", kdb_sr, "", "Magic SysRq key", 0); +#endif +} + +/* + * kdb_init + * + * Initialize the kernel debugger environment. + * + * Parameters: + * None. + * Returns: + * None. + * Locking: + * None. + * Remarks: + * None. + */ + +void +kdb_init(void) +{ + /* + * This must be called before any calls to kdb_printf. + */ + kdb_io_init(); + + kdb_inittab(); /* Initialize Command Table */ + kdb_initbptab(); /* Initialize Breakpoint Table */ +#if 0 + kdb_id_init(); /* Initialize Disassembler */ +#endif + kdba_init(); /* Architecture Dependent Initialization */ + + /* + * Use printk() to get message in log_buf[]; + */ + printk("kdb version %d.%d by Scott Lurndal. "\ + "Copyright SGI, All Rights Reserved\n", + KDB_MAJOR_VERSION, KDB_MINOR_VERSION); +} diff -urN test4.official/kdb/kdbsupport.c test4.official.kdb/kdb/kdbsupport.c --- test4.official/kdb/kdbsupport.c Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/kdb/kdbsupport.c Fri Aug 11 11:25:45 2000 @@ -0,0 +1,358 @@ +/* + * Kernel Debugger Architecture Independent Support Functions + * + * Copyright (C) 1999 Silicon Graphics, Inc. + * Copyright (C) Scott Lurndal (slurn@engr.sgi.com) + * Copyright (C) Scott Foehner (sfoehner@engr.sgi.com) + * Copyright (C) Srinivasa Thirumalachar (sprasad@engr.sgi.com) + * + * Written March 1999 by Scott Lurndal at Silicon Graphics, Inc. + * + * Modifications from: + * Richard Bass 1999/07/20 + * Many bug fixes and enhancements. + * Scott Foehner + * Port to ia64 + * Scott Lurndal 1999/12/12 + * v1.0 restructuring. + */ +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +/* + * Symbol table functions. + */ + +/* + * kdbgetsym + * + * Return the symbol table entry for the given symbol + * + * Parameters: + * symname Character string containing symbol name + * Outputs: + * Returns: + * NULL Symbol doesn't exist + * ksp Pointer to symbol table entry + * Locking: + * None. + * Remarks: + * If the symbol cannot be located in the symbol table, it may + * be because the symbol table contains the symbol with a + * module version string appended. If CONFIG_MODVERSIONS + * is enabled, attempt to match the substring excluding the + * module versions string. + */ + +#if defined(CONFIG_MODVERSIONS) +#if defined(CONFIG_SMP) +#define FLAG_STR "_Rsmp_" +#else +#define FLAG_STR "_R" +#endif +#define VER_NO_LEN 8 +#define FLAG_STR_LEN (sizeof(FLAG_STR)-1) +#define SYMLEN (FLAG_STR_LEN + VER_NO_LEN) +#endif + +__ksymtab_t * +kdbgetsym(const char *symname) +{ + __ksymtab_t *ksp = __kdbsymtab; + int i; + + if (symname == NULL) + return NULL; + + for (i=0; i<__kdbsymtabsize; i++, ksp++) { + if (ksp->name + && (strcmp(ksp->name, symname)==0)) { + return ksp; + } +#if defined(CONFIG_MODVERSIONS) + if (ksp->name + && (memcmp(ksp->name, symname, strlen(symname)) == 0) + && (memcmp(ksp->name+strlen(symname), FLAG_STR, FLAG_STR_LEN) == 0) + && (strlen(ksp->name) == (strlen(symname)+SYMLEN))) { + return ksp; + } +#endif /* CONFIG_MODVERSIONS */ + } + + return NULL; +} + +/* + * kdbgetsymval + * + * Return the address of the given symbol. + * + * Parameters: + * symname Character string containing symbol name + * Outputs: + * Returns: + * 0 Symbol name is NULL + * addr Address corresponding to symname + * Locking: + * None. + * Remarks: + */ + +unsigned long +kdbgetsymval(const char *symname) +{ + __ksymtab_t *ksp = kdbgetsym(symname); + + return (ksp?ksp->value:0); +} + +/* + * kdbaddmodsym + * + * Add a symbol to the kernel debugger symbol table. Called when + * a new module is loaded into the kernel. + * + * Parameters: + * symname Character string containing symbol name + * value Value of symbol + * Outputs: + * Returns: + * 0 Successfully added to table. + * 1 Duplicate symbol + * 2 Symbol table full + * Locking: + * None. + * Remarks: + */ + +int +kdbaddmodsym(char *symname, unsigned long value) +{ + + /* + * Check for duplicate symbols. + */ + if (kdbgetsym(symname)) { + printk("kdb: Attempt to register duplicate symbol '%s' @ 0x%lx\n", + symname, value); + return 1; + } + + if (__kdbsymtabsize < __kdbmaxsymtabsize) { + __ksymtab_t *ksp = &__kdbsymtab[__kdbsymtabsize++]; + + ksp->name = symname; + ksp->value = value; + return 0; + } + + /* + * No room left in kernel symbol table. + */ + { + static int __kdbwarn = 0; + + if (__kdbwarn == 0) { + __kdbwarn++; + printk("kdb: Exceeded symbol table size. Increase KDBMAXSYMTABSIZE in scripts/genkdbsym.awk\n"); + } + } + + return 2; +} + +/* + * kdbdelmodsym + * + * Add a symbol to the kernel debugger symbol table. Called when + * a new module is loaded into the kernel. + * + * Parameters: + * symname Character string containing symbol name + * value Value of symbol + * Outputs: + * Returns: + * 0 Successfully added to table. + * 1 Symbol not found + * Locking: + * None. + * Remarks: + */ + +int +kdbdelmodsym(const char *symname) +{ + __ksymtab_t *ksp, *endksp; + + if (symname == NULL) + return 1; + + /* + * Search for the symbol. If found, move + * all successive symbols down one position + * in the symbol table to avoid leaving holes. + */ + endksp = &__kdbsymtab[__kdbsymtabsize]; + for (ksp = __kdbsymtab; ksp < endksp; ksp++) { + if (ksp->name && (strcmp(ksp->name, symname) == 0)) { + endksp--; + for ( ; ksp < endksp; ksp++) { + *ksp = *(ksp + 1); + } + __kdbsymtabsize--; + return 0; + } + } + + return 1; +} + +/* + * kdbnearsym + * + * Return the name of the symbol with the nearest address + * less than 'addr'. + * + * Parameters: + * addr Address to check for symbol near + * Outputs: + * Returns: + * NULL No symbol with address less than 'addr' + * symbol Returns the actual name of the symbol. + * Locking: + * None. + * Remarks: + */ + +char * +kdbnearsym(unsigned long addr) +{ + __ksymtab_t *ksp = __kdbsymtab; + __ksymtab_t *kpp = NULL; + int i; + + for(i=0; i<__kdbsymtabsize; i++, ksp++) { + if (!ksp->name) + continue; + + if (addr == ksp->value) { + kpp = ksp; + break; + } + if (addr > ksp->value) { + if ((kpp == NULL) + || (ksp->value > kpp->value)) { + kpp = ksp; + } + } + } + + /* + * If more than 128k away, don't bother. + */ + if ((kpp == NULL) + || ((addr - kpp->value) > 0x20000)) { + return NULL; + } + + return kpp->name; +} + +#if defined(CONFIG_SMP) +/* + * kdb_ipi + * + * This function is called from the non-maskable interrupt + * handler to handle a kdb IPI instruction. + * + * Inputs: + * ef = Exception frame pointer + * Outputs: + * None. + * Returns: + * 0 - Did not handle NMI + * 1 - Handled NMI + * Locking: + * None. + * Remarks: + * + */ + +int +kdb_ipi(kdb_eframe_t ef, void (*ack_interrupt)(void)) +{ + if (kdb_active + && test_bit(smp_processor_id(), &smp_kdb_wait)) { + /* + * Switching processors in KDB via the 'cpu' command. + * + * Wait for the kernel debugger to let us go - either + * as a result of the 'go' command or due to a cpu + * switch. If a CPU switch, the appropriate bit + * will be cleared in smp_kdb_wait, and we'll call + * kdb. + * + * At this point, since we are executing in the + * NMI handler, we can no longer use NMI to stop + * any of the processors (but we can be assured that + * they are all either in the loop that follows, or + * activily executing KDB code). + */ + + /* + * Acknowledge the interrupt + */ + if (ack_interrupt) + (*ack_interrupt)(); + + /* + * We need to clear out the breakpoint registers + * here because a 'bc' could clear one of these + * from the kernel debugger on the processor which + * caused the kdb stop condition. + */ + kdb_bp_remove(); + + /* + * Wait for the controlling processor to let us go. + */ + while (test_bit(smp_processor_id(), &smp_kdb_wait)) + ; + + /* + * The controlling processor let us go. Either we + * are the new controlling processor, or 'go' was + * entered. If we're the new controlling processor, + * call the kernel debugger. + */ + if (kdb_new_cpu == smp_processor_id()) { + kdb(KDB_REASON_SWITCH, 0, ef); + } + + /* + * Reinstall the debug registers. + */ + kdb_bp_install(); + + return 1; + } + + return 0; +} +#endif /* CONFIG_SMP */ + +void +kdb_enablehwfault(void) +{ +#if 0 + kdba_enablemce(); +#endif +} diff -urN test4.official/kernel/module.c test4.official.kdb/kernel/module.c --- test4.official/kernel/module.c Mon Jun 26 12:11:10 2000 +++ test4.official.kdb/kernel/module.c Fri Aug 11 11:25:45 2000 @@ -6,6 +6,9 @@ #include #include #include +#if defined(CONFIG_KDB) +#include +#endif /* * Originally by Anonymous (as far as I know...) @@ -164,6 +167,9 @@ long namelen, n_namelen, i, error; unsigned long mod_user_size; struct module_ref *dep; +#if defined(CONFIG_KDB) + struct module_symbol *s; +#endif if (!capable(CAP_SYS_MODULE)) return -EPERM; @@ -335,6 +341,11 @@ } atomic_dec(&mod->uc.usecount); +#if defined(CONFIG_KDB) + for(i=0,s=mod->syms; insyms; i++, s++){ + kdbaddmodsym(s->name, s->value); + } +#endif /* And set it running. */ mod->flags = (mod->flags | MOD_RUNNING) & ~MOD_INITIALIZING; error = 0; @@ -801,6 +812,9 @@ { struct module_ref *dep; unsigned i; +#if defined(CONFIG_KDB) + struct module_symbol *s; +#endif /* Let the module clean up. */ @@ -810,6 +824,15 @@ mod->cleanup(); mod->flags &= ~MOD_RUNNING; } + +#if defined(CONFIG_KDB) + /* + * Remove symbols from kernel debugger + */ + for(i=0,s=mod->syms; insyms; i++, s++){ + kdbdelmodsym(s->name); + } +#endif /* Remove the module from the dependency lists. */ diff -urN test4.official/mm/vmalloc.c test4.official.kdb/mm/vmalloc.c --- test4.official/mm/vmalloc.c Mon Jun 26 12:01:03 2000 +++ test4.official.kdb/mm/vmalloc.c Fri Aug 11 11:25:45 2000 @@ -16,6 +16,44 @@ rwlock_t vmlist_lock = RW_LOCK_UNLOCKED; struct vm_struct * vmlist = NULL; +#if defined(CONFIG_KDB) +/* kdb_vmlist_check + * Check to determine if an address is within a vmalloced range. + * Parameters: + * starta -- Starting address of region to check + * enda -- Ending address of region to check + * Returns: + * 0 -- [starta,enda] not within a vmalloc area + * 1 -- [starta,enda] within a vmalloc area + * Locking: + * None. + * Remarks: + * Shouldn't acquire locks. Always called with all interrupts + * disabled and other cpus halted. Yet, if a breakpoint or fault + * occurs while the vmlist is in an indeterminate state, this + * function could fail. + */ +int +kdb_vmlist_check(unsigned long starta, unsigned long enda) +{ + struct vm_struct *vp; + + return 1; /* XXX hack alert */ + for(vp=vmlist; vp; vp = vp->next) { + unsigned long end = (unsigned long)vp->addr + vp->size; + + end -= PAGE_SIZE; /* Unbias for guard page */ + + if ((starta >= (unsigned long)vp->addr) + && (starta < end) + && (enda < end)) { + return 1; + } + } + return 0; +} +#endif + static inline void free_area_pte(pmd_t * pmd, unsigned long address, unsigned long size) { pte_t * pte; diff -urN test4.official/scripts/genkdbsym.awk test4.official.kdb/scripts/genkdbsym.awk --- test4.official/scripts/genkdbsym.awk Wed Dec 31 16:00:00 1969 +++ test4.official.kdb/scripts/genkdbsym.awk Fri Aug 11 11:25:45 2000 @@ -0,0 +1,24 @@ + +BEGIN { + printf("#include \n"); + printf("#include \n"); + printf("#include \n"); + printf("#include \n"); + printf("#include \"ksym.h\"\n\n"); + printf("\n__ksymtab_t __attribute__ ((section(\"kdbsymtab\"))) __kdbsymtab[CONFIG_KDB_STBSIZE] = {\n"); + symcount = 0 + printf("/* Generated file */\n") > "ksym.h"; + printf("char __attribute__ ((section(\"kdbstrings\"))) kdb_null[]=\"\";\n") >> "ksym.h"; + } + + { symname = sprintf("_kdbs%d", symcount); + printf("{%s, 0x%s},\n", symname, $1); + printf("char __attribute__ ((section(\"kdbstrings\"))) %s[] = \"%s\";\n", symname, $3) >> "ksym.h"; + symcount = symcount + 1 + } + +END { + printf(" [%d ... CONFIG_KDB_STBSIZE-1] = {kdb_null, 0xf}};\n", symcount); + printf("int __attribute__ ((section(\"kdbsymtab\"))) __kdbsymtabsize = %d;\n", symcount); + printf("int __attribute__ ((section(\"kdbsymtab\"))) __kdbmaxsymtabsize = CONFIG_KDB_STBSIZE;\n"); + }