Tcl Source Code

Check-in [2886da4545]
Login
Bounty program for improvements to Tcl and certain Tcl packages.
Tcl 2019 Conference, Houston/TX, US, Nov 4-8
Send your abstracts to [email protected]
or submit via the online form by Sep 9.

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:merge trunk
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | dgp-refactor
Files: files | file ages | folders
SHA3-256: 2886da45456c9e57b2b93aa033393354a7d4fb2f5735eaa507750125dd409dad
User & Date: dgp 2019-03-08 15:09:48
Context
2019-03-15
15:51
merge trunk check-in: 84d2435115 user: dgp tags: dgp-refactor
2019-03-08
15:09
merge trunk check-in: 2886da4545 user: dgp tags: dgp-refactor
14:56
merge 8.7 check-in: 839cfa7059 user: dgp tags: trunk
2019-02-28
20:35
merge trunk check-in: e4e3193004 user: dgp tags: dgp-refactor
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to .fossil-settings/ignore-glob.

    15     15   */config.log
    16     16   */config.status
    17     17   */tclConfig.sh
    18     18   */tclsh*
    19     19   */tcltest*
    20     20   */versions.vc
    21     21   */version.vc
           22  +*/libtcl.vfs
           23  +*/libtcl_*.zip
    22     24   html
    23     25   libtommath/bn.ilg
    24     26   libtommath/bn.ind
    25     27   libtommath/pretty.build
    26     28   libtommath/tommath.src
    27     29   libtommath/*.pdf
    28     30   libtommath/*.pl

Changes to .travis.yml.

    65     65           apt:
    66     66             sources:
    67     67               - ubuntu-toolchain-r-test
    68     68             packages:
    69     69               - g++-7
    70     70         env:
    71     71           - BUILD_DIR=unix
           72  +    - os: linux
           73  +      dist: xenial
           74  +      compiler: gcc-7
           75  +      addons:
           76  +        apt:
           77  +          sources:
           78  +            - ubuntu-toolchain-r-test
           79  +          packages:
           80  +            - g++-7
           81  +      env:
           82  +        - BUILD_DIR=unix
           83  +        - CFGOPT=CFLAGS=-DTCL_UTF_MAX=6
    72     84       - os: osx
    73     85         osx_image: xcode8
    74     86         env:
    75     87           - BUILD_DIR=unix
    76     88       - os: osx
    77     89         osx_image: xcode8
    78     90         env:

Added doc/timerate.n.

            1  +'\"
            2  +'\" Copyright (c) 2005 Sergey Brester aka sebres.
            3  +'\"
            4  +'\" See the file "license.terms" for information on usage and redistribution
            5  +'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
            6  +'\"
            7  +.TH timerate n "" Tcl "Tcl Built-In Commands"
            8  +.so man.macros
            9  +.BS
           10  +'\" Note:  do not modify the .SH NAME line immediately below!
           11  +.SH NAME
           12  +timerate \- Time-related execution resp. performance measurement of a script
           13  +.SH SYNOPSIS
           14  +\fBtimerate \fIscript\fR \fI?time ?max-count??\fR
           15  +.sp
           16  +\fBtimerate \fI?-direct?\fR \fI?-overhead double?\fR \fIscript\fR \fI?time ?max-count??\fR
           17  +.sp
           18  +\fBtimerate \fI?-calibrate?\fR \fI?-direct?\fR \fIscript\fR \fI?time ?max-count??\fR
           19  +.BE
           20  +.SH DESCRIPTION
           21  +.PP
           22  +The first and second form will evaluate \fIscript\fR until the interval
           23  +\fItime\fR given in milliseconds elapses, or for 1000 milliseconds (1 second)
           24  +if \fItime\fR is not specified.
           25  +.sp
           26  +The parameter \fImax-count\fR could additionally impose a further restriction
           27  +by the maximal number of iterations to evaluate the script.
           28  +If \fImax-count\fR is specified, the evalution will stop either this count of
           29  +iterations is reached or the time is exceeded.
           30  +.sp
           31  +It will then return a canonical tcl-list of the form
           32  +.PP
           33  +.CS
           34  +\fB0.095977 \(mcs/# 52095836 # 10419167 #/sec 5000.000 nett-ms\fR
           35  +.CE
           36  +.PP
           37  +which indicates:
           38  +.IP \(bu
           39  +the average amount of time required per iteration, in microseconds ([\fBlindex\fR $result 0])
           40  +.IP \(bu
           41  +the count how many times it was executed ([\fBlindex\fR $result 2])
           42  +.IP \(bu
           43  +the estimated rate per second ([\fBlindex\fR $result 4])
           44  +.IP \(bu
           45  +the estimated real execution time without measurement overhead ([\fBlindex\fR $result 6])
           46  +.PP
           47  +Time is measured in elapsed time using the finest timer resolution as possible,
           48  +not CPU time.
           49  +This command may be used to provide information as to how well the script or a
           50  +tcl-command is performing and can help determine bottlenecks and fine-tune
           51  +application performance.
           52  +.TP
           53  +\fI-calibrate\fR
           54  +.
           55  +To measure very fast scripts as exact as posible the calibration process
           56  +may be required.
           57  +
           58  +The \fI-calibrate\fR option is used to calibrate timerate, calculating the
           59  +estimated overhead of the given script as the default overhead for future 
           60  +invocations of the \fBtimerate\fR command. If the \fItime\fR parameter is not 
           61  +specified, the calibrate procedure runs for up to 10 seconds.
           62  +.TP
           63  +\fI-overhead double\fR
           64  +.
           65  +The \fI-overhead\fR parameter supplies an estimate (in microseconds) of the
           66  +measurement overhead of each iteration of the tested script. This quantity
           67  +will be subtracted from the measured time prior to reporting results.
           68  +.TP
           69  +\fI-direct\fR
           70  +.
           71  +The \fI-direct\fR option causes direct execution of the supplied script,
           72  +without compilation, in a manner similar to the \fBtime\fR command. It can be
           73  +used to measure the cost of \fBTcl_EvalObjEx\fR, of the invocation of canonical
           74  +lists, and of the uncompiled versions of bytecoded commands.
           75  +.PP
           76  +As opposed to the \fBtime\fR commmand, which runs the tested script for a fixed
           77  +number of iterations, the timerate command runs it for a fixed time.
           78  +Additionally, the compiled variant of the script will be used during the entire
           79  +measurement, as if the script were part of a compiled procedure, if the \fI-direct\fR
           80  +option is not specified. The fixed time period and possibility of compilation allow
           81  +for more precise results and prevent very long execution times by slow scripts, making
           82  +it practical for measuring scripts with highly uncertain execution times.
           83  +
           84  +.SH EXAMPLE
           85  +Estimate how fast it takes for a simple Tcl \fBfor\fR loop (including
           86  +operations on variable \fIi\fR) to count to a ten:
           87  +.PP
           88  +.CS
           89  +# calibrate:
           90  +timerate -calibrate {}
           91  +# measure:
           92  +timerate { for {set i 0} {$i<10} {incr i} {} } 5000
           93  +.CE
           94  +.PP
           95  +Estimate how fast it takes for a simple Tcl \fBfor\fR loop, ignoring the
           96  +overhead for to perform ten iterations, ignoring the overhead of the management
           97  +of the variable that controls the loop:
           98  +.PP
           99  +.CS
          100  +# calibrate for overhead of variable operations:
          101  +set i 0; timerate -calibrate {expr {$i<10}; incr i} 1000
          102  +# measure:
          103  +timerate { for {set i 0} {$i<10} {incr i} {} } 5000
          104  +.CE
          105  +.PP
          106  +Estimate the speed of calculating the hour of the day using \fBclock format\fR only,
          107  +ignoring overhead of the portion of the script that prepares the time for it to
          108  +calculate:
          109  +.PP
          110  +.CS
          111  +# calibrate:
          112  +timerate -calibrate {}
          113  +# estimate overhead:
          114  +set tm 0
          115  +set ovh [lindex [timerate { incr tm [expr {24*60*60}] }] 0]
          116  +# measure using esimated overhead:
          117  +set tm 0
          118  +timerate -overhead $ovh {
          119  +    clock format $tm -format %H
          120  +    incr tm [expr {24*60*60}]; # overhead for this is ignored
          121  +} 5000
          122  +.CE
          123  +.SH "SEE ALSO"
          124  +time(n)
          125  +.SH KEYWORDS
          126  +script, timerate, time
          127  +.\" Local Variables:
          128  +.\" mode: nroff
          129  +.\" End:

Changes to generic/regc_locale.c.

   149    149       {0xb13, 0xb28}, {0xb2a, 0xb30}, {0xb35, 0xb39}, {0xb5f, 0xb61},
   150    150       {0xb85, 0xb8a}, {0xb8e, 0xb90}, {0xb92, 0xb95}, {0xba8, 0xbaa},
   151    151       {0xbae, 0xbb9}, {0xc05, 0xc0c}, {0xc0e, 0xc10}, {0xc12, 0xc28},
   152    152       {0xc2a, 0xc39}, {0xc58, 0xc5a}, {0xc85, 0xc8c}, {0xc8e, 0xc90},
   153    153       {0xc92, 0xca8}, {0xcaa, 0xcb3}, {0xcb5, 0xcb9}, {0xd05, 0xd0c},
   154    154       {0xd0e, 0xd10}, {0xd12, 0xd3a}, {0xd54, 0xd56}, {0xd5f, 0xd61},
   155    155       {0xd7a, 0xd7f}, {0xd85, 0xd96}, {0xd9a, 0xdb1}, {0xdb3, 0xdbb},
   156         -    {0xdc0, 0xdc6}, {0xe01, 0xe30}, {0xe40, 0xe46}, {0xe94, 0xe97},
   157         -    {0xe99, 0xe9f}, {0xea1, 0xea3}, {0xead, 0xeb0}, {0xec0, 0xec4},
   158         -    {0xedc, 0xedf}, {0xf40, 0xf47}, {0xf49, 0xf6c}, {0xf88, 0xf8c},
   159         -    {0x1000, 0x102a}, {0x1050, 0x1055}, {0x105a, 0x105d}, {0x106e, 0x1070},
   160         -    {0x1075, 0x1081}, {0x10a0, 0x10c5}, {0x10d0, 0x10fa}, {0x10fc, 0x1248},
   161         -    {0x124a, 0x124d}, {0x1250, 0x1256}, {0x125a, 0x125d}, {0x1260, 0x1288},
   162         -    {0x128a, 0x128d}, {0x1290, 0x12b0}, {0x12b2, 0x12b5}, {0x12b8, 0x12be},
   163         -    {0x12c2, 0x12c5}, {0x12c8, 0x12d6}, {0x12d8, 0x1310}, {0x1312, 0x1315},
   164         -    {0x1318, 0x135a}, {0x1380, 0x138f}, {0x13a0, 0x13f5}, {0x13f8, 0x13fd},
   165         -    {0x1401, 0x166c}, {0x166f, 0x167f}, {0x1681, 0x169a}, {0x16a0, 0x16ea},
   166         -    {0x16f1, 0x16f8}, {0x1700, 0x170c}, {0x170e, 0x1711}, {0x1720, 0x1731},
   167         -    {0x1740, 0x1751}, {0x1760, 0x176c}, {0x176e, 0x1770}, {0x1780, 0x17b3},
   168         -    {0x1820, 0x1878}, {0x1880, 0x1884}, {0x1887, 0x18a8}, {0x18b0, 0x18f5},
   169         -    {0x1900, 0x191e}, {0x1950, 0x196d}, {0x1970, 0x1974}, {0x1980, 0x19ab},
   170         -    {0x19b0, 0x19c9}, {0x1a00, 0x1a16}, {0x1a20, 0x1a54}, {0x1b05, 0x1b33},
   171         -    {0x1b45, 0x1b4b}, {0x1b83, 0x1ba0}, {0x1bba, 0x1be5}, {0x1c00, 0x1c23},
   172         -    {0x1c4d, 0x1c4f}, {0x1c5a, 0x1c7d}, {0x1c80, 0x1c88}, {0x1c90, 0x1cba},
   173         -    {0x1cbd, 0x1cbf}, {0x1ce9, 0x1cec}, {0x1cee, 0x1cf1}, {0x1d00, 0x1dbf},
   174         -    {0x1e00, 0x1f15}, {0x1f18, 0x1f1d}, {0x1f20, 0x1f45}, {0x1f48, 0x1f4d},
   175         -    {0x1f50, 0x1f57}, {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, {0x1fb6, 0x1fbc},
   176         -    {0x1fc2, 0x1fc4}, {0x1fc6, 0x1fcc}, {0x1fd0, 0x1fd3}, {0x1fd6, 0x1fdb},
   177         -    {0x1fe0, 0x1fec}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffc}, {0x2090, 0x209c},
   178         -    {0x210a, 0x2113}, {0x2119, 0x211d}, {0x212a, 0x212d}, {0x212f, 0x2139},
   179         -    {0x213c, 0x213f}, {0x2145, 0x2149}, {0x2c00, 0x2c2e}, {0x2c30, 0x2c5e},
   180         -    {0x2c60, 0x2ce4}, {0x2ceb, 0x2cee}, {0x2d00, 0x2d25}, {0x2d30, 0x2d67},
   181         -    {0x2d80, 0x2d96}, {0x2da0, 0x2da6}, {0x2da8, 0x2dae}, {0x2db0, 0x2db6},
   182         -    {0x2db8, 0x2dbe}, {0x2dc0, 0x2dc6}, {0x2dc8, 0x2dce}, {0x2dd0, 0x2dd6},
   183         -    {0x2dd8, 0x2dde}, {0x3031, 0x3035}, {0x3041, 0x3096}, {0x309d, 0x309f},
   184         -    {0x30a1, 0x30fa}, {0x30fc, 0x30ff}, {0x3105, 0x312f}, {0x3131, 0x318e},
   185         -    {0x31a0, 0x31ba}, {0x31f0, 0x31ff}, {0x3400, 0x4db5}, {0x4e00, 0x9fef},
   186         -    {0xa000, 0xa48c}, {0xa4d0, 0xa4fd}, {0xa500, 0xa60c}, {0xa610, 0xa61f},
   187         -    {0xa640, 0xa66e}, {0xa67f, 0xa69d}, {0xa6a0, 0xa6e5}, {0xa717, 0xa71f},
   188         -    {0xa722, 0xa788}, {0xa78b, 0xa7b9}, {0xa7f7, 0xa801}, {0xa803, 0xa805},
          156  +    {0xdc0, 0xdc6}, {0xe01, 0xe30}, {0xe40, 0xe46}, {0xe86, 0xe8a},
          157  +    {0xe8c, 0xea3}, {0xea7, 0xeb0}, {0xec0, 0xec4}, {0xedc, 0xedf},
          158  +    {0xf40, 0xf47}, {0xf49, 0xf6c}, {0xf88, 0xf8c}, {0x1000, 0x102a},
          159  +    {0x1050, 0x1055}, {0x105a, 0x105d}, {0x106e, 0x1070}, {0x1075, 0x1081},
          160  +    {0x10a0, 0x10c5}, {0x10d0, 0x10fa}, {0x10fc, 0x1248}, {0x124a, 0x124d},
          161  +    {0x1250, 0x1256}, {0x125a, 0x125d}, {0x1260, 0x1288}, {0x128a, 0x128d},
          162  +    {0x1290, 0x12b0}, {0x12b2, 0x12b5}, {0x12b8, 0x12be}, {0x12c2, 0x12c5},
          163  +    {0x12c8, 0x12d6}, {0x12d8, 0x1310}, {0x1312, 0x1315}, {0x1318, 0x135a},
          164  +    {0x1380, 0x138f}, {0x13a0, 0x13f5}, {0x13f8, 0x13fd}, {0x1401, 0x166c},
          165  +    {0x166f, 0x167f}, {0x1681, 0x169a}, {0x16a0, 0x16ea}, {0x16f1, 0x16f8},
          166  +    {0x1700, 0x170c}, {0x170e, 0x1711}, {0x1720, 0x1731}, {0x1740, 0x1751},
          167  +    {0x1760, 0x176c}, {0x176e, 0x1770}, {0x1780, 0x17b3}, {0x1820, 0x1878},
          168  +    {0x1880, 0x1884}, {0x1887, 0x18a8}, {0x18b0, 0x18f5}, {0x1900, 0x191e},
          169  +    {0x1950, 0x196d}, {0x1970, 0x1974}, {0x1980, 0x19ab}, {0x19b0, 0x19c9},
          170  +    {0x1a00, 0x1a16}, {0x1a20, 0x1a54}, {0x1b05, 0x1b33}, {0x1b45, 0x1b4b},
          171  +    {0x1b83, 0x1ba0}, {0x1bba, 0x1be5}, {0x1c00, 0x1c23}, {0x1c4d, 0x1c4f},
          172  +    {0x1c5a, 0x1c7d}, {0x1c80, 0x1c88}, {0x1c90, 0x1cba}, {0x1cbd, 0x1cbf},
          173  +    {0x1ce9, 0x1cec}, {0x1cee, 0x1cf3}, {0x1d00, 0x1dbf}, {0x1e00, 0x1f15},
          174  +    {0x1f18, 0x1f1d}, {0x1f20, 0x1f45}, {0x1f48, 0x1f4d}, {0x1f50, 0x1f57},
          175  +    {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, {0x1fb6, 0x1fbc}, {0x1fc2, 0x1fc4},
          176  +    {0x1fc6, 0x1fcc}, {0x1fd0, 0x1fd3}, {0x1fd6, 0x1fdb}, {0x1fe0, 0x1fec},
          177  +    {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffc}, {0x2090, 0x209c}, {0x210a, 0x2113},
          178  +    {0x2119, 0x211d}, {0x212a, 0x212d}, {0x212f, 0x2139}, {0x213c, 0x213f},
          179  +    {0x2145, 0x2149}, {0x2c00, 0x2c2e}, {0x2c30, 0x2c5e}, {0x2c60, 0x2ce4},
          180  +    {0x2ceb, 0x2cee}, {0x2d00, 0x2d25}, {0x2d30, 0x2d67}, {0x2d80, 0x2d96},
          181  +    {0x2da0, 0x2da6}, {0x2da8, 0x2dae}, {0x2db0, 0x2db6}, {0x2db8, 0x2dbe},
          182  +    {0x2dc0, 0x2dc6}, {0x2dc8, 0x2dce}, {0x2dd0, 0x2dd6}, {0x2dd8, 0x2dde},
          183  +    {0x3031, 0x3035}, {0x3041, 0x3096}, {0x309d, 0x309f}, {0x30a1, 0x30fa},
          184  +    {0x30fc, 0x30ff}, {0x3105, 0x312f}, {0x3131, 0x318e}, {0x31a0, 0x31ba},
          185  +    {0x31f0, 0x31ff}, {0x3400, 0x4db5}, {0x4e00, 0x9fef}, {0xa000, 0xa48c},
          186  +    {0xa4d0, 0xa4fd}, {0xa500, 0xa60c}, {0xa610, 0xa61f}, {0xa640, 0xa66e},
          187  +    {0xa67f, 0xa69d}, {0xa6a0, 0xa6e5}, {0xa717, 0xa71f}, {0xa722, 0xa788},
          188  +    {0xa78b, 0xa7bf}, {0xa7c2, 0xa7c6}, {0xa7f7, 0xa801}, {0xa803, 0xa805},
   189    189       {0xa807, 0xa80a}, {0xa80c, 0xa822}, {0xa840, 0xa873}, {0xa882, 0xa8b3},
   190    190       {0xa8f2, 0xa8f7}, {0xa90a, 0xa925}, {0xa930, 0xa946}, {0xa960, 0xa97c},
   191    191       {0xa984, 0xa9b2}, {0xa9e0, 0xa9e4}, {0xa9e6, 0xa9ef}, {0xa9fa, 0xa9fe},
   192    192       {0xaa00, 0xaa28}, {0xaa40, 0xaa42}, {0xaa44, 0xaa4b}, {0xaa60, 0xaa76},
   193    193       {0xaa7e, 0xaaaf}, {0xaab9, 0xaabd}, {0xaadb, 0xaadd}, {0xaae0, 0xaaea},
   194    194       {0xaaf2, 0xaaf4}, {0xab01, 0xab06}, {0xab09, 0xab0e}, {0xab11, 0xab16},
   195         -    {0xab20, 0xab26}, {0xab28, 0xab2e}, {0xab30, 0xab5a}, {0xab5c, 0xab65},
          195  +    {0xab20, 0xab26}, {0xab28, 0xab2e}, {0xab30, 0xab5a}, {0xab5c, 0xab67},
   196    196       {0xab70, 0xabe2}, {0xac00, 0xd7a3}, {0xd7b0, 0xd7c6}, {0xd7cb, 0xd7fb},
   197    197       {0xf900, 0xfa6d}, {0xfa70, 0xfad9}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17},
   198    198       {0xfb1f, 0xfb28}, {0xfb2a, 0xfb36}, {0xfb38, 0xfb3c}, {0xfb46, 0xfbb1},
   199    199       {0xfbd3, 0xfd3d}, {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7}, {0xfdf0, 0xfdfb},
   200    200       {0xfe70, 0xfe74}, {0xfe76, 0xfefc}, {0xff21, 0xff3a}, {0xff41, 0xff5a},
   201    201       {0xff66, 0xffbe}, {0xffc2, 0xffc7}, {0xffca, 0xffcf}, {0xffd2, 0xffd7},
   202    202       {0xffda, 0xffdc}
................................................................................
   209    209       {0x10600, 0x10736}, {0x10740, 0x10755}, {0x10760, 0x10767}, {0x10800, 0x10805},
   210    210       {0x1080a, 0x10835}, {0x1083f, 0x10855}, {0x10860, 0x10876}, {0x10880, 0x1089e},
   211    211       {0x108e0, 0x108f2}, {0x10900, 0x10915}, {0x10920, 0x10939}, {0x10980, 0x109b7},
   212    212       {0x10a10, 0x10a13}, {0x10a15, 0x10a17}, {0x10a19, 0x10a35}, {0x10a60, 0x10a7c},
   213    213       {0x10a80, 0x10a9c}, {0x10ac0, 0x10ac7}, {0x10ac9, 0x10ae4}, {0x10b00, 0x10b35},
   214    214       {0x10b40, 0x10b55}, {0x10b60, 0x10b72}, {0x10b80, 0x10b91}, {0x10c00, 0x10c48},
   215    215       {0x10c80, 0x10cb2}, {0x10cc0, 0x10cf2}, {0x10d00, 0x10d23}, {0x10f00, 0x10f1c},
   216         -    {0x10f30, 0x10f45}, {0x11003, 0x11037}, {0x11083, 0x110af}, {0x110d0, 0x110e8},
   217         -    {0x11103, 0x11126}, {0x11150, 0x11172}, {0x11183, 0x111b2}, {0x111c1, 0x111c4},
   218         -    {0x11200, 0x11211}, {0x11213, 0x1122b}, {0x11280, 0x11286}, {0x1128a, 0x1128d},
   219         -    {0x1128f, 0x1129d}, {0x1129f, 0x112a8}, {0x112b0, 0x112de}, {0x11305, 0x1130c},
   220         -    {0x11313, 0x11328}, {0x1132a, 0x11330}, {0x11335, 0x11339}, {0x1135d, 0x11361},
   221         -    {0x11400, 0x11434}, {0x11447, 0x1144a}, {0x11480, 0x114af}, {0x11580, 0x115ae},
   222         -    {0x115d8, 0x115db}, {0x11600, 0x1162f}, {0x11680, 0x116aa}, {0x11700, 0x1171a},
   223         -    {0x11800, 0x1182b}, {0x118a0, 0x118df}, {0x11a0b, 0x11a32}, {0x11a5c, 0x11a83},
   224         -    {0x11a86, 0x11a89}, {0x11ac0, 0x11af8}, {0x11c00, 0x11c08}, {0x11c0a, 0x11c2e},
   225         -    {0x11c72, 0x11c8f}, {0x11d00, 0x11d06}, {0x11d0b, 0x11d30}, {0x11d60, 0x11d65},
   226         -    {0x11d6a, 0x11d89}, {0x11ee0, 0x11ef2}, {0x12000, 0x12399}, {0x12480, 0x12543},
   227         -    {0x13000, 0x1342e}, {0x14400, 0x14646}, {0x16800, 0x16a38}, {0x16a40, 0x16a5e},
   228         -    {0x16ad0, 0x16aed}, {0x16b00, 0x16b2f}, {0x16b40, 0x16b43}, {0x16b63, 0x16b77},
   229         -    {0x16b7d, 0x16b8f}, {0x16e40, 0x16e7f}, {0x16f00, 0x16f44}, {0x16f93, 0x16f9f},
   230         -    {0x17000, 0x187f1}, {0x18800, 0x18af2}, {0x1b000, 0x1b11e}, {0x1b170, 0x1b2fb},
          216  +    {0x10f30, 0x10f45}, {0x10fe0, 0x10ff6}, {0x11003, 0x11037}, {0x11083, 0x110af},
          217  +    {0x110d0, 0x110e8}, {0x11103, 0x11126}, {0x11150, 0x11172}, {0x11183, 0x111b2},
          218  +    {0x111c1, 0x111c4}, {0x11200, 0x11211}, {0x11213, 0x1122b}, {0x11280, 0x11286},
          219  +    {0x1128a, 0x1128d}, {0x1128f, 0x1129d}, {0x1129f, 0x112a8}, {0x112b0, 0x112de},
          220  +    {0x11305, 0x1130c}, {0x11313, 0x11328}, {0x1132a, 0x11330}, {0x11335, 0x11339},
          221  +    {0x1135d, 0x11361}, {0x11400, 0x11434}, {0x11447, 0x1144a}, {0x11480, 0x114af},
          222  +    {0x11580, 0x115ae}, {0x115d8, 0x115db}, {0x11600, 0x1162f}, {0x11680, 0x116aa},
          223  +    {0x11700, 0x1171a}, {0x11800, 0x1182b}, {0x118a0, 0x118df}, {0x119a0, 0x119a7},
          224  +    {0x119aa, 0x119d0}, {0x11a0b, 0x11a32}, {0x11a5c, 0x11a89}, {0x11ac0, 0x11af8},
          225  +    {0x11c00, 0x11c08}, {0x11c0a, 0x11c2e}, {0x11c72, 0x11c8f}, {0x11d00, 0x11d06},
          226  +    {0x11d0b, 0x11d30}, {0x11d60, 0x11d65}, {0x11d6a, 0x11d89}, {0x11ee0, 0x11ef2},
          227  +    {0x12000, 0x12399}, {0x12480, 0x12543}, {0x13000, 0x1342e}, {0x14400, 0x14646},
          228  +    {0x16800, 0x16a38}, {0x16a40, 0x16a5e}, {0x16ad0, 0x16aed}, {0x16b00, 0x16b2f},
          229  +    {0x16b40, 0x16b43}, {0x16b63, 0x16b77}, {0x16b7d, 0x16b8f}, {0x16e40, 0x16e7f},
          230  +    {0x16f00, 0x16f4a}, {0x16f93, 0x16f9f}, {0x17000, 0x187f7}, {0x18800, 0x18af2},
          231  +    {0x1b000, 0x1b11e}, {0x1b150, 0x1b152}, {0x1b164, 0x1b167}, {0x1b170, 0x1b2fb},
   231    232       {0x1bc00, 0x1bc6a}, {0x1bc70, 0x1bc7c}, {0x1bc80, 0x1bc88}, {0x1bc90, 0x1bc99},
   232    233       {0x1d400, 0x1d454}, {0x1d456, 0x1d49c}, {0x1d4a9, 0x1d4ac}, {0x1d4ae, 0x1d4b9},
   233    234       {0x1d4bd, 0x1d4c3}, {0x1d4c5, 0x1d505}, {0x1d507, 0x1d50a}, {0x1d50d, 0x1d514},
   234    235       {0x1d516, 0x1d51c}, {0x1d51e, 0x1d539}, {0x1d53b, 0x1d53e}, {0x1d540, 0x1d544},
   235    236       {0x1d54a, 0x1d550}, {0x1d552, 0x1d6a5}, {0x1d6a8, 0x1d6c0}, {0x1d6c2, 0x1d6da},
   236    237       {0x1d6dc, 0x1d6fa}, {0x1d6fc, 0x1d714}, {0x1d716, 0x1d734}, {0x1d736, 0x1d74e},
   237    238       {0x1d750, 0x1d76e}, {0x1d770, 0x1d788}, {0x1d78a, 0x1d7a8}, {0x1d7aa, 0x1d7c2},
   238         -    {0x1d7c4, 0x1d7cb}, {0x1e800, 0x1e8c4}, {0x1e900, 0x1e943}, {0x1ee00, 0x1ee03},
   239         -    {0x1ee05, 0x1ee1f}, {0x1ee29, 0x1ee32}, {0x1ee34, 0x1ee37}, {0x1ee4d, 0x1ee4f},
   240         -    {0x1ee67, 0x1ee6a}, {0x1ee6c, 0x1ee72}, {0x1ee74, 0x1ee77}, {0x1ee79, 0x1ee7c},
   241         -    {0x1ee80, 0x1ee89}, {0x1ee8b, 0x1ee9b}, {0x1eea1, 0x1eea3}, {0x1eea5, 0x1eea9},
   242         -    {0x1eeab, 0x1eebb}, {0x20000, 0x2a6d6}, {0x2a700, 0x2b734}, {0x2b740, 0x2b81d},
   243         -    {0x2b820, 0x2cea1}, {0x2ceb0, 0x2ebe0}, {0x2f800, 0x2fa1d}
          239  +    {0x1d7c4, 0x1d7cb}, {0x1e100, 0x1e12c}, {0x1e137, 0x1e13d}, {0x1e2c0, 0x1e2eb},
          240  +    {0x1e800, 0x1e8c4}, {0x1e900, 0x1e943}, {0x1ee00, 0x1ee03}, {0x1ee05, 0x1ee1f},
          241  +    {0x1ee29, 0x1ee32}, {0x1ee34, 0x1ee37}, {0x1ee4d, 0x1ee4f}, {0x1ee67, 0x1ee6a},
          242  +    {0x1ee6c, 0x1ee72}, {0x1ee74, 0x1ee77}, {0x1ee79, 0x1ee7c}, {0x1ee80, 0x1ee89},
          243  +    {0x1ee8b, 0x1ee9b}, {0x1eea1, 0x1eea3}, {0x1eea5, 0x1eea9}, {0x1eeab, 0x1eebb},
          244  +    {0x20000, 0x2a6d6}, {0x2a700, 0x2b734}, {0x2b740, 0x2b81d}, {0x2b820, 0x2cea1},
          245  +    {0x2ceb0, 0x2ebe0}, {0x2f800, 0x2fa1d}
   244    246   #endif
   245    247   };
   246    248   
   247    249   #define NUM_ALPHA_RANGE (sizeof(alphaRangeTable)/sizeof(crange))
   248    250   
   249    251   static const chr alphaCharTable[] = {
   250    252       0xaa, 0xb5, 0xba, 0x2ec, 0x2ee, 0x376, 0x377, 0x37f, 0x386,
................................................................................
   253    255       0x93d, 0x950, 0x98f, 0x990, 0x9b2, 0x9bd, 0x9ce, 0x9dc, 0x9dd,
   254    256       0x9f0, 0x9f1, 0x9fc, 0xa0f, 0xa10, 0xa32, 0xa33, 0xa35, 0xa36,
   255    257       0xa38, 0xa39, 0xa5e, 0xab2, 0xab3, 0xabd, 0xad0, 0xae0, 0xae1,
   256    258       0xaf9, 0xb0f, 0xb10, 0xb32, 0xb33, 0xb3d, 0xb5c, 0xb5d, 0xb71,
   257    259       0xb83, 0xb99, 0xb9a, 0xb9c, 0xb9e, 0xb9f, 0xba3, 0xba4, 0xbd0,
   258    260       0xc3d, 0xc60, 0xc61, 0xc80, 0xcbd, 0xcde, 0xce0, 0xce1, 0xcf1,
   259    261       0xcf2, 0xd3d, 0xd4e, 0xdbd, 0xe32, 0xe33, 0xe81, 0xe82, 0xe84,
   260         -    0xe87, 0xe88, 0xe8a, 0xe8d, 0xea5, 0xea7, 0xeaa, 0xeab, 0xeb2,
   261         -    0xeb3, 0xebd, 0xec6, 0xf00, 0x103f, 0x1061, 0x1065, 0x1066, 0x108e,
   262         -    0x10c7, 0x10cd, 0x1258, 0x12c0, 0x17d7, 0x17dc, 0x18aa, 0x1aa7, 0x1bae,
   263         -    0x1baf, 0x1cf5, 0x1cf6, 0x1f59, 0x1f5b, 0x1f5d, 0x1fbe, 0x2071, 0x207f,
   264         -    0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128, 0x214e, 0x2183, 0x2184,
   265         -    0x2cf2, 0x2cf3, 0x2d27, 0x2d2d, 0x2d6f, 0x2e2f, 0x3005, 0x3006, 0x303b,
   266         -    0x303c, 0xa62a, 0xa62b, 0xa8fb, 0xa8fd, 0xa8fe, 0xa9cf, 0xaa7a, 0xaab1,
   267         -    0xaab5, 0xaab6, 0xaac0, 0xaac2, 0xfb1d, 0xfb3e, 0xfb40, 0xfb41, 0xfb43,
   268         -    0xfb44
          262  +    0xea5, 0xeb2, 0xeb3, 0xebd, 0xec6, 0xf00, 0x103f, 0x1061, 0x1065,
          263  +    0x1066, 0x108e, 0x10c7, 0x10cd, 0x1258, 0x12c0, 0x17d7, 0x17dc, 0x18aa,
          264  +    0x1aa7, 0x1bae, 0x1baf, 0x1cf5, 0x1cf6, 0x1cfa, 0x1f59, 0x1f5b, 0x1f5d,
          265  +    0x1fbe, 0x2071, 0x207f, 0x2102, 0x2107, 0x2115, 0x2124, 0x2126, 0x2128,
          266  +    0x214e, 0x2183, 0x2184, 0x2cf2, 0x2cf3, 0x2d27, 0x2d2d, 0x2d6f, 0x2e2f,
          267  +    0x3005, 0x3006, 0x303b, 0x303c, 0xa62a, 0xa62b, 0xa8fb, 0xa8fd, 0xa8fe,
          268  +    0xa9cf, 0xaa7a, 0xaab1, 0xaab5, 0xaab6, 0xaac0, 0xaac2, 0xfb1d, 0xfb3e,
          269  +    0xfb40, 0xfb41, 0xfb43, 0xfb44
   269    270   #if CHRBITS > 16
   270    271       ,0x1003c, 0x1003d, 0x10808, 0x10837, 0x10838, 0x1083c, 0x108f4, 0x108f5, 0x109be,
   271    272       0x109bf, 0x10a00, 0x10f27, 0x11144, 0x11176, 0x111da, 0x111dc, 0x11288, 0x1130f,
   272         -    0x11310, 0x11332, 0x11333, 0x1133d, 0x11350, 0x114c4, 0x114c5, 0x114c7, 0x11644,
   273         -    0x118ff, 0x11a00, 0x11a3a, 0x11a50, 0x11a9d, 0x11c40, 0x11d08, 0x11d09, 0x11d46,
   274         -    0x11d67, 0x11d68, 0x11d98, 0x16f50, 0x16fe0, 0x16fe1, 0x1d49e, 0x1d49f, 0x1d4a2,
   275         -    0x1d4a5, 0x1d4a6, 0x1d4bb, 0x1d546, 0x1ee21, 0x1ee22, 0x1ee24, 0x1ee27, 0x1ee39,
   276         -    0x1ee3b, 0x1ee42, 0x1ee47, 0x1ee49, 0x1ee4b, 0x1ee51, 0x1ee52, 0x1ee54, 0x1ee57,
   277         -    0x1ee59, 0x1ee5b, 0x1ee5d, 0x1ee5f, 0x1ee61, 0x1ee62, 0x1ee64, 0x1ee7e
          273  +    0x11310, 0x11332, 0x11333, 0x1133d, 0x11350, 0x1145f, 0x114c4, 0x114c5, 0x114c7,
          274  +    0x11644, 0x116b8, 0x118ff, 0x119e1, 0x119e3, 0x11a00, 0x11a3a, 0x11a50, 0x11a9d,
          275  +    0x11c40, 0x11d08, 0x11d09, 0x11d46, 0x11d67, 0x11d68, 0x11d98, 0x16f50, 0x16fe0,
          276  +    0x16fe1, 0x16fe3, 0x1d49e, 0x1d49f, 0x1d4a2, 0x1d4a5, 0x1d4a6, 0x1d4bb, 0x1d546,
          277  +    0x1e14e, 0x1e94b, 0x1ee21, 0x1ee22, 0x1ee24, 0x1ee27, 0x1ee39, 0x1ee3b, 0x1ee42,
          278  +    0x1ee47, 0x1ee49, 0x1ee4b, 0x1ee51, 0x1ee52, 0x1ee54, 0x1ee57, 0x1ee59, 0x1ee5b,
          279  +    0x1ee5d, 0x1ee5f, 0x1ee61, 0x1ee62, 0x1ee64, 0x1ee7e
   278    280   #endif
   279    281   };
   280    282   
   281    283   #define NUM_ALPHA_CHAR (sizeof(alphaCharTable)/sizeof(chr))
   282    284   
   283    285   /*
   284    286    * Unicode: control characters.
................................................................................
   285    287    */
   286    288   
   287    289   static const crange controlRangeTable[] = {
   288    290       {0x0, 0x1f}, {0x7f, 0x9f}, {0x600, 0x605}, {0x200b, 0x200f},
   289    291       {0x202a, 0x202e}, {0x2060, 0x2064}, {0x2066, 0x206f}, {0xe000, 0xf8ff},
   290    292       {0xfff9, 0xfffb}
   291    293   #if CHRBITS > 16
   292         -    ,{0x1bca0, 0x1bca3}, {0x1d173, 0x1d17a}, {0xe0020, 0xe007f}, {0xf0000, 0xffffd},
   293         -    {0x100000, 0x10fffd}
          294  +    ,{0x13430, 0x13438}, {0x1bca0, 0x1bca3}, {0x1d173, 0x1d17a}, {0xe0020, 0xe007f},
          295  +    {0xf0000, 0xffffd}, {0x100000, 0x10fffd}
   294    296   #endif
   295    297   };
   296    298   
   297    299   #define NUM_CONTROL_RANGE (sizeof(controlRangeTable)/sizeof(crange))
   298    300   
   299    301   static const chr controlCharTable[] = {
   300    302       0xad, 0x61c, 0x6dd, 0x70f, 0x8e2, 0x180e, 0xfeff
................................................................................
   321    323       {0xa9d0, 0xa9d9}, {0xa9f0, 0xa9f9}, {0xaa50, 0xaa59}, {0xabf0, 0xabf9},
   322    324       {0xff10, 0xff19}
   323    325   #if CHRBITS > 16
   324    326       ,{0x104a0, 0x104a9}, {0x10d30, 0x10d39}, {0x11066, 0x1106f}, {0x110f0, 0x110f9},
   325    327       {0x11136, 0x1113f}, {0x111d0, 0x111d9}, {0x112f0, 0x112f9}, {0x11450, 0x11459},
   326    328       {0x114d0, 0x114d9}, {0x11650, 0x11659}, {0x116c0, 0x116c9}, {0x11730, 0x11739},
   327    329       {0x118e0, 0x118e9}, {0x11c50, 0x11c59}, {0x11d50, 0x11d59}, {0x11da0, 0x11da9},
   328         -    {0x16a60, 0x16a69}, {0x16b50, 0x16b59}, {0x1d7ce, 0x1d7ff}, {0x1e950, 0x1e959}
          330  +    {0x16a60, 0x16a69}, {0x16b50, 0x16b59}, {0x1d7ce, 0x1d7ff}, {0x1e140, 0x1e149},
          331  +    {0x1e2f0, 0x1e2f9}, {0x1e950, 0x1e959}
   329    332   #endif
   330    333   };
   331    334   
   332    335   #define NUM_DIGIT_RANGE (sizeof(digitRangeTable)/sizeof(crange))
   333    336   
   334    337   /*
   335    338    * no singletons of digit characters.
................................................................................
   344    347       {0x55a, 0x55f}, {0x66a, 0x66d}, {0x700, 0x70d}, {0x7f7, 0x7f9},
   345    348       {0x830, 0x83e}, {0xf04, 0xf12}, {0xf3a, 0xf3d}, {0xfd0, 0xfd4},
   346    349       {0x104a, 0x104f}, {0x1360, 0x1368}, {0x16eb, 0x16ed}, {0x17d4, 0x17d6},
   347    350       {0x17d8, 0x17da}, {0x1800, 0x180a}, {0x1aa0, 0x1aa6}, {0x1aa8, 0x1aad},
   348    351       {0x1b5a, 0x1b60}, {0x1bfc, 0x1bff}, {0x1c3b, 0x1c3f}, {0x1cc0, 0x1cc7},
   349    352       {0x2010, 0x2027}, {0x2030, 0x2043}, {0x2045, 0x2051}, {0x2053, 0x205e},
   350    353       {0x2308, 0x230b}, {0x2768, 0x2775}, {0x27e6, 0x27ef}, {0x2983, 0x2998},
   351         -    {0x29d8, 0x29db}, {0x2cf9, 0x2cfc}, {0x2e00, 0x2e2e}, {0x2e30, 0x2e4e},
          354  +    {0x29d8, 0x29db}, {0x2cf9, 0x2cfc}, {0x2e00, 0x2e2e}, {0x2e30, 0x2e4f},
   352    355       {0x3001, 0x3003}, {0x3008, 0x3011}, {0x3014, 0x301f}, {0xa60d, 0xa60f},
   353    356       {0xa6f2, 0xa6f7}, {0xa874, 0xa877}, {0xa8f8, 0xa8fa}, {0xa9c1, 0xa9cd},
   354    357       {0xaa5c, 0xaa5f}, {0xfe10, 0xfe19}, {0xfe30, 0xfe52}, {0xfe54, 0xfe61},
   355    358       {0xff01, 0xff03}, {0xff05, 0xff0a}, {0xff0c, 0xff0f}, {0xff3b, 0xff3d},
   356    359       {0xff5f, 0xff65}
   357    360   #if CHRBITS > 16
   358    361       ,{0x10100, 0x10102}, {0x10a50, 0x10a58}, {0x10af0, 0x10af6}, {0x10b39, 0x10b3f},
................................................................................
   368    371   #define NUM_PUNCT_RANGE (sizeof(punctRangeTable)/sizeof(crange))
   369    372   
   370    373   static const chr punctCharTable[] = {
   371    374       0x3a, 0x3b, 0x3f, 0x40, 0x5f, 0x7b, 0x7d, 0xa1, 0xa7,
   372    375       0xab, 0xb6, 0xb7, 0xbb, 0xbf, 0x37e, 0x387, 0x589, 0x58a,
   373    376       0x5be, 0x5c0, 0x5c3, 0x5c6, 0x5f3, 0x5f4, 0x609, 0x60a, 0x60c,
   374    377       0x60d, 0x61b, 0x61e, 0x61f, 0x6d4, 0x85e, 0x964, 0x965, 0x970,
   375         -    0x9fd, 0xa76, 0xaf0, 0xc84, 0xdf4, 0xe4f, 0xe5a, 0xe5b, 0xf14,
   376         -    0xf85, 0xfd9, 0xfda, 0x10fb, 0x1400, 0x166d, 0x166e, 0x169b, 0x169c,
          378  +    0x9fd, 0xa76, 0xaf0, 0xc77, 0xc84, 0xdf4, 0xe4f, 0xe5a, 0xe5b,
          379  +    0xf14, 0xf85, 0xfd9, 0xfda, 0x10fb, 0x1400, 0x166e, 0x169b, 0x169c,
   377    380       0x1735, 0x1736, 0x1944, 0x1945, 0x1a1e, 0x1a1f, 0x1c7e, 0x1c7f, 0x1cd3,
   378    381       0x207d, 0x207e, 0x208d, 0x208e, 0x2329, 0x232a, 0x27c5, 0x27c6, 0x29fc,
   379    382       0x29fd, 0x2cfe, 0x2cff, 0x2d70, 0x3030, 0x303d, 0x30a0, 0x30fb, 0xa4fe,
   380    383       0xa4ff, 0xa673, 0xa67e, 0xa8ce, 0xa8cf, 0xa8fc, 0xa92e, 0xa92f, 0xa95f,
   381    384       0xa9de, 0xa9df, 0xaade, 0xaadf, 0xaaf0, 0xaaf1, 0xabeb, 0xfd3e, 0xfd3f,
   382    385       0xfe63, 0xfe68, 0xfe6a, 0xfe6b, 0xff1a, 0xff1b, 0xff1f, 0xff20, 0xff3f,
   383    386       0xff5b, 0xff5d
   384    387   #if CHRBITS > 16
   385    388       ,0x1039f, 0x103d0, 0x1056f, 0x10857, 0x1091f, 0x1093f, 0x10a7f, 0x110bb, 0x110bc,
   386    389       0x11174, 0x11175, 0x111cd, 0x111db, 0x112a9, 0x1145b, 0x1145d, 0x114c6, 0x1183b,
   387         -    0x11c70, 0x11c71, 0x11ef7, 0x11ef8, 0x16a6e, 0x16a6f, 0x16af5, 0x16b44, 0x1bc9f,
   388         -    0x1e95e, 0x1e95f
          390  +    0x119e2, 0x11c70, 0x11c71, 0x11ef7, 0x11ef8, 0x11fff, 0x16a6e, 0x16a6f, 0x16af5,
          391  +    0x16b44, 0x16fe2, 0x1bc9f, 0x1e95e, 0x1e95f
   389    392   #endif
   390    393   };
   391    394   
   392    395   #define NUM_PUNCT_CHAR (sizeof(punctCharTable)/sizeof(chr))
   393    396   
   394    397   /*
   395    398    * Unicode: white space characters.
................................................................................
   420    423       {0x10fd, 0x10ff}, {0x13f8, 0x13fd}, {0x1c80, 0x1c88}, {0x1d00, 0x1d2b},
   421    424       {0x1d6b, 0x1d77}, {0x1d79, 0x1d9a}, {0x1e95, 0x1e9d}, {0x1eff, 0x1f07},
   422    425       {0x1f10, 0x1f15}, {0x1f20, 0x1f27}, {0x1f30, 0x1f37}, {0x1f40, 0x1f45},
   423    426       {0x1f50, 0x1f57}, {0x1f60, 0x1f67}, {0x1f70, 0x1f7d}, {0x1f80, 0x1f87},
   424    427       {0x1f90, 0x1f97}, {0x1fa0, 0x1fa7}, {0x1fb0, 0x1fb4}, {0x1fc2, 0x1fc4},
   425    428       {0x1fd0, 0x1fd3}, {0x1fe0, 0x1fe7}, {0x1ff2, 0x1ff4}, {0x2146, 0x2149},
   426    429       {0x2c30, 0x2c5e}, {0x2c76, 0x2c7b}, {0x2d00, 0x2d25}, {0xa72f, 0xa731},
   427         -    {0xa771, 0xa778}, {0xa793, 0xa795}, {0xab30, 0xab5a}, {0xab60, 0xab65},
          430  +    {0xa771, 0xa778}, {0xa793, 0xa795}, {0xab30, 0xab5a}, {0xab60, 0xab67},
   428    431       {0xab70, 0xabbf}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xff41, 0xff5a}
   429    432   #if CHRBITS > 16
   430    433       ,{0x10428, 0x1044f}, {0x104d8, 0x104fb}, {0x10cc0, 0x10cf2}, {0x118c0, 0x118df},
   431    434       {0x16e60, 0x16e7f}, {0x1d41a, 0x1d433}, {0x1d44e, 0x1d454}, {0x1d456, 0x1d467},
   432    435       {0x1d482, 0x1d49b}, {0x1d4b6, 0x1d4b9}, {0x1d4bd, 0x1d4c3}, {0x1d4c5, 0x1d4cf},
   433    436       {0x1d4ea, 0x1d503}, {0x1d51e, 0x1d537}, {0x1d552, 0x1d56b}, {0x1d586, 0x1d59f},
   434    437       {0x1d5ba, 0x1d5d3}, {0x1d5ee, 0x1d607}, {0x1d622, 0x1d63b}, {0x1d656, 0x1d66f},
................................................................................
   500    503       0xa691, 0xa693, 0xa695, 0xa697, 0xa699, 0xa69b, 0xa723, 0xa725, 0xa727,
   501    504       0xa729, 0xa72b, 0xa72d, 0xa733, 0xa735, 0xa737, 0xa739, 0xa73b, 0xa73d,
   502    505       0xa73f, 0xa741, 0xa743, 0xa745, 0xa747, 0xa749, 0xa74b, 0xa74d, 0xa74f,
   503    506       0xa751, 0xa753, 0xa755, 0xa757, 0xa759, 0xa75b, 0xa75d, 0xa75f, 0xa761,
   504    507       0xa763, 0xa765, 0xa767, 0xa769, 0xa76b, 0xa76d, 0xa76f, 0xa77a, 0xa77c,
   505    508       0xa77f, 0xa781, 0xa783, 0xa785, 0xa787, 0xa78c, 0xa78e, 0xa791, 0xa797,
   506    509       0xa799, 0xa79b, 0xa79d, 0xa79f, 0xa7a1, 0xa7a3, 0xa7a5, 0xa7a7, 0xa7a9,
   507         -    0xa7af, 0xa7b5, 0xa7b7, 0xa7b9, 0xa7fa
          510  +    0xa7af, 0xa7b5, 0xa7b7, 0xa7b9, 0xa7bb, 0xa7bd, 0xa7bf, 0xa7c3, 0xa7fa
   508    511   #if CHRBITS > 16
   509    512       ,0x1d4bb, 0x1d7cb
   510    513   #endif
   511    514   };
   512    515   
   513    516   #define NUM_LOWER_CHAR (sizeof(lowerCharTable)/sizeof(chr))
   514    517   
................................................................................
   523    526       {0x3d2, 0x3d4}, {0x3fd, 0x42f}, {0x531, 0x556}, {0x10a0, 0x10c5},
   524    527       {0x13a0, 0x13f5}, {0x1c90, 0x1cba}, {0x1cbd, 0x1cbf}, {0x1f08, 0x1f0f},
   525    528       {0x1f18, 0x1f1d}, {0x1f28, 0x1f2f}, {0x1f38, 0x1f3f}, {0x1f48, 0x1f4d},
   526    529       {0x1f68, 0x1f6f}, {0x1fb8, 0x1fbb}, {0x1fc8, 0x1fcb}, {0x1fd8, 0x1fdb},
   527    530       {0x1fe8, 0x1fec}, {0x1ff8, 0x1ffb}, {0x210b, 0x210d}, {0x2110, 0x2112},
   528    531       {0x2119, 0x211d}, {0x212a, 0x212d}, {0x2130, 0x2133}, {0x2c00, 0x2c2e},
   529    532       {0x2c62, 0x2c64}, {0x2c6d, 0x2c70}, {0x2c7e, 0x2c80}, {0xa7aa, 0xa7ae},
   530         -    {0xa7b0, 0xa7b4}, {0xff21, 0xff3a}
          533  +    {0xa7b0, 0xa7b4}, {0xa7c4, 0xa7c6}, {0xff21, 0xff3a}
   531    534   #if CHRBITS > 16
   532    535       ,{0x10400, 0x10427}, {0x104b0, 0x104d3}, {0x10c80, 0x10cb2}, {0x118a0, 0x118bf},
   533    536       {0x16e40, 0x16e5f}, {0x1d400, 0x1d419}, {0x1d434, 0x1d44d}, {0x1d468, 0x1d481},
   534    537       {0x1d4a9, 0x1d4ac}, {0x1d4ae, 0x1d4b5}, {0x1d4d0, 0x1d4e9}, {0x1d507, 0x1d50a},
   535    538       {0x1d50d, 0x1d514}, {0x1d516, 0x1d51c}, {0x1d53b, 0x1d53e}, {0x1d540, 0x1d544},
   536    539       {0x1d54a, 0x1d550}, {0x1d56c, 0x1d585}, {0x1d5a0, 0x1d5b9}, {0x1d5d4, 0x1d5ed},
   537    540       {0x1d608, 0x1d621}, {0x1d63c, 0x1d655}, {0x1d670, 0x1d689}, {0x1d6a8, 0x1d6c0},
................................................................................
   602    605       0xa698, 0xa69a, 0xa722, 0xa724, 0xa726, 0xa728, 0xa72a, 0xa72c, 0xa72e,
   603    606       0xa732, 0xa734, 0xa736, 0xa738, 0xa73a, 0xa73c, 0xa73e, 0xa740, 0xa742,
   604    607       0xa744, 0xa746, 0xa748, 0xa74a, 0xa74c, 0xa74e, 0xa750, 0xa752, 0xa754,
   605    608       0xa756, 0xa758, 0xa75a, 0xa75c, 0xa75e, 0xa760, 0xa762, 0xa764, 0xa766,
   606    609       0xa768, 0xa76a, 0xa76c, 0xa76e, 0xa779, 0xa77b, 0xa77d, 0xa77e, 0xa780,
   607    610       0xa782, 0xa784, 0xa786, 0xa78b, 0xa78d, 0xa790, 0xa792, 0xa796, 0xa798,
   608    611       0xa79a, 0xa79c, 0xa79e, 0xa7a0, 0xa7a2, 0xa7a4, 0xa7a6, 0xa7a8, 0xa7b6,
   609         -    0xa7b8
          612  +    0xa7b8, 0xa7ba, 0xa7bc, 0xa7be, 0xa7c2
   610    613   #if CHRBITS > 16
   611    614       ,0x1d49c, 0x1d49e, 0x1d49f, 0x1d4a2, 0x1d4a5, 0x1d4a6, 0x1d504, 0x1d505, 0x1d538,
   612    615       0x1d539, 0x1d546, 0x1d7ca
   613    616   #endif
   614    617   };
   615    618   
   616    619   #define NUM_UPPER_CHAR (sizeof(upperCharTable)/sizeof(chr))
................................................................................
   636    639       {0xae0, 0xae3}, {0xae6, 0xaf1}, {0xaf9, 0xaff}, {0xb01, 0xb03},
   637    640       {0xb05, 0xb0c}, {0xb13, 0xb28}, {0xb2a, 0xb30}, {0xb35, 0xb39},
   638    641       {0xb3c, 0xb44}, {0xb4b, 0xb4d}, {0xb5f, 0xb63}, {0xb66, 0xb77},
   639    642       {0xb85, 0xb8a}, {0xb8e, 0xb90}, {0xb92, 0xb95}, {0xba8, 0xbaa},
   640    643       {0xbae, 0xbb9}, {0xbbe, 0xbc2}, {0xbc6, 0xbc8}, {0xbca, 0xbcd},
   641    644       {0xbe6, 0xbfa}, {0xc00, 0xc0c}, {0xc0e, 0xc10}, {0xc12, 0xc28},
   642    645       {0xc2a, 0xc39}, {0xc3d, 0xc44}, {0xc46, 0xc48}, {0xc4a, 0xc4d},
   643         -    {0xc58, 0xc5a}, {0xc60, 0xc63}, {0xc66, 0xc6f}, {0xc78, 0xc8c},
          646  +    {0xc58, 0xc5a}, {0xc60, 0xc63}, {0xc66, 0xc6f}, {0xc77, 0xc8c},
   644    647       {0xc8e, 0xc90}, {0xc92, 0xca8}, {0xcaa, 0xcb3}, {0xcb5, 0xcb9},
   645    648       {0xcbc, 0xcc4}, {0xcc6, 0xcc8}, {0xcca, 0xccd}, {0xce0, 0xce3},
   646    649       {0xce6, 0xcef}, {0xd00, 0xd03}, {0xd05, 0xd0c}, {0xd0e, 0xd10},
   647    650       {0xd12, 0xd44}, {0xd46, 0xd48}, {0xd4a, 0xd4f}, {0xd54, 0xd63},
   648    651       {0xd66, 0xd7f}, {0xd85, 0xd96}, {0xd9a, 0xdb1}, {0xdb3, 0xdbb},
   649    652       {0xdc0, 0xdc6}, {0xdcf, 0xdd4}, {0xdd8, 0xddf}, {0xde6, 0xdef},
   650         -    {0xdf2, 0xdf4}, {0xe01, 0xe3a}, {0xe3f, 0xe5b}, {0xe94, 0xe97},
   651         -    {0xe99, 0xe9f}, {0xea1, 0xea3}, {0xead, 0xeb9}, {0xebb, 0xebd},
   652         -    {0xec0, 0xec4}, {0xec8, 0xecd}, {0xed0, 0xed9}, {0xedc, 0xedf},
   653         -    {0xf00, 0xf47}, {0xf49, 0xf6c}, {0xf71, 0xf97}, {0xf99, 0xfbc},
   654         -    {0xfbe, 0xfcc}, {0xfce, 0xfda}, {0x1000, 0x10c5}, {0x10d0, 0x1248},
   655         -    {0x124a, 0x124d}, {0x1250, 0x1256}, {0x125a, 0x125d}, {0x1260, 0x1288},
   656         -    {0x128a, 0x128d}, {0x1290, 0x12b0}, {0x12b2, 0x12b5}, {0x12b8, 0x12be},
   657         -    {0x12c2, 0x12c5}, {0x12c8, 0x12d6}, {0x12d8, 0x1310}, {0x1312, 0x1315},
   658         -    {0x1318, 0x135a}, {0x135d, 0x137c}, {0x1380, 0x1399}, {0x13a0, 0x13f5},
   659         -    {0x13f8, 0x13fd}, {0x1400, 0x167f}, {0x1681, 0x169c}, {0x16a0, 0x16f8},
   660         -    {0x1700, 0x170c}, {0x170e, 0x1714}, {0x1720, 0x1736}, {0x1740, 0x1753},
   661         -    {0x1760, 0x176c}, {0x176e, 0x1770}, {0x1780, 0x17dd}, {0x17e0, 0x17e9},
   662         -    {0x17f0, 0x17f9}, {0x1800, 0x180d}, {0x1810, 0x1819}, {0x1820, 0x1878},
   663         -    {0x1880, 0x18aa}, {0x18b0, 0x18f5}, {0x1900, 0x191e}, {0x1920, 0x192b},
   664         -    {0x1930, 0x193b}, {0x1944, 0x196d}, {0x1970, 0x1974}, {0x1980, 0x19ab},
   665         -    {0x19b0, 0x19c9}, {0x19d0, 0x19da}, {0x19de, 0x1a1b}, {0x1a1e, 0x1a5e},
   666         -    {0x1a60, 0x1a7c}, {0x1a7f, 0x1a89}, {0x1a90, 0x1a99}, {0x1aa0, 0x1aad},
   667         -    {0x1ab0, 0x1abe}, {0x1b00, 0x1b4b}, {0x1b50, 0x1b7c}, {0x1b80, 0x1bf3},
   668         -    {0x1bfc, 0x1c37}, {0x1c3b, 0x1c49}, {0x1c4d, 0x1c88}, {0x1c90, 0x1cba},
   669         -    {0x1cbd, 0x1cc7}, {0x1cd0, 0x1cf9}, {0x1d00, 0x1df9}, {0x1dfb, 0x1f15},
   670         -    {0x1f18, 0x1f1d}, {0x1f20, 0x1f45}, {0x1f48, 0x1f4d}, {0x1f50, 0x1f57},
   671         -    {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, {0x1fb6, 0x1fc4}, {0x1fc6, 0x1fd3},
   672         -    {0x1fd6, 0x1fdb}, {0x1fdd, 0x1fef}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffe},
   673         -    {0x2010, 0x2027}, {0x2030, 0x205e}, {0x2074, 0x208e}, {0x2090, 0x209c},
   674         -    {0x20a0, 0x20bf}, {0x20d0, 0x20f0}, {0x2100, 0x218b}, {0x2190, 0x2426},
   675         -    {0x2440, 0x244a}, {0x2460, 0x2b73}, {0x2b76, 0x2b95}, {0x2b98, 0x2bc8},
   676         -    {0x2bca, 0x2bfe}, {0x2c00, 0x2c2e}, {0x2c30, 0x2c5e}, {0x2c60, 0x2cf3},
          653  +    {0xdf2, 0xdf4}, {0xe01, 0xe3a}, {0xe3f, 0xe5b}, {0xe86, 0xe8a},
          654  +    {0xe8c, 0xea3}, {0xea7, 0xebd}, {0xec0, 0xec4}, {0xec8, 0xecd},
          655  +    {0xed0, 0xed9}, {0xedc, 0xedf}, {0xf00, 0xf47}, {0xf49, 0xf6c},
          656  +    {0xf71, 0xf97}, {0xf99, 0xfbc}, {0xfbe, 0xfcc}, {0xfce, 0xfda},
          657  +    {0x1000, 0x10c5}, {0x10d0, 0x1248}, {0x124a, 0x124d}, {0x1250, 0x1256},
          658  +    {0x125a, 0x125d}, {0x1260, 0x1288}, {0x128a, 0x128d}, {0x1290, 0x12b0},
          659  +    {0x12b2, 0x12b5}, {0x12b8, 0x12be}, {0x12c2, 0x12c5}, {0x12c8, 0x12d6},
          660  +    {0x12d8, 0x1310}, {0x1312, 0x1315}, {0x1318, 0x135a}, {0x135d, 0x137c},
          661  +    {0x1380, 0x1399}, {0x13a0, 0x13f5}, {0x13f8, 0x13fd}, {0x1400, 0x167f},
          662  +    {0x1681, 0x169c}, {0x16a0, 0x16f8}, {0x1700, 0x170c}, {0x170e, 0x1714},
          663  +    {0x1720, 0x1736}, {0x1740, 0x1753}, {0x1760, 0x176c}, {0x176e, 0x1770},
          664  +    {0x1780, 0x17dd}, {0x17e0, 0x17e9}, {0x17f0, 0x17f9}, {0x1800, 0x180d},
          665  +    {0x1810, 0x1819}, {0x1820, 0x1878}, {0x1880, 0x18aa}, {0x18b0, 0x18f5},
          666  +    {0x1900, 0x191e}, {0x1920, 0x192b}, {0x1930, 0x193b}, {0x1944, 0x196d},
          667  +    {0x1970, 0x1974}, {0x1980, 0x19ab}, {0x19b0, 0x19c9}, {0x19d0, 0x19da},
          668  +    {0x19de, 0x1a1b}, {0x1a1e, 0x1a5e}, {0x1a60, 0x1a7c}, {0x1a7f, 0x1a89},
          669  +    {0x1a90, 0x1a99}, {0x1aa0, 0x1aad}, {0x1ab0, 0x1abe}, {0x1b00, 0x1b4b},
          670  +    {0x1b50, 0x1b7c}, {0x1b80, 0x1bf3}, {0x1bfc, 0x1c37}, {0x1c3b, 0x1c49},
          671  +    {0x1c4d, 0x1c88}, {0x1c90, 0x1cba}, {0x1cbd, 0x1cc7}, {0x1cd0, 0x1cfa},
          672  +    {0x1d00, 0x1df9}, {0x1dfb, 0x1f15}, {0x1f18, 0x1f1d}, {0x1f20, 0x1f45},
          673  +    {0x1f48, 0x1f4d}, {0x1f50, 0x1f57}, {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4},
          674  +    {0x1fb6, 0x1fc4}, {0x1fc6, 0x1fd3}, {0x1fd6, 0x1fdb}, {0x1fdd, 0x1fef},
          675  +    {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffe}, {0x2010, 0x2027}, {0x2030, 0x205e},
          676  +    {0x2074, 0x208e}, {0x2090, 0x209c}, {0x20a0, 0x20bf}, {0x20d0, 0x20f0},
          677  +    {0x2100, 0x218b}, {0x2190, 0x2426}, {0x2440, 0x244a}, {0x2460, 0x2b73},
          678  +    {0x2b76, 0x2b95}, {0x2b98, 0x2c2e}, {0x2c30, 0x2c5e}, {0x2c60, 0x2cf3},
   677    679       {0x2cf9, 0x2d25}, {0x2d30, 0x2d67}, {0x2d7f, 0x2d96}, {0x2da0, 0x2da6},
   678    680       {0x2da8, 0x2dae}, {0x2db0, 0x2db6}, {0x2db8, 0x2dbe}, {0x2dc0, 0x2dc6},
   679         -    {0x2dc8, 0x2dce}, {0x2dd0, 0x2dd6}, {0x2dd8, 0x2dde}, {0x2de0, 0x2e4e},
          681  +    {0x2dc8, 0x2dce}, {0x2dd0, 0x2dd6}, {0x2dd8, 0x2dde}, {0x2de0, 0x2e4f},
   680    682       {0x2e80, 0x2e99}, {0x2e9b, 0x2ef3}, {0x2f00, 0x2fd5}, {0x2ff0, 0x2ffb},
   681    683       {0x3001, 0x303f}, {0x3041, 0x3096}, {0x3099, 0x30ff}, {0x3105, 0x312f},
   682    684       {0x3131, 0x318e}, {0x3190, 0x31ba}, {0x31c0, 0x31e3}, {0x31f0, 0x321e},
   683    685       {0x3220, 0x32fe}, {0x3300, 0x4db5}, {0x4dc0, 0x9fef}, {0xa000, 0xa48c},
   684         -    {0xa490, 0xa4c6}, {0xa4d0, 0xa62b}, {0xa640, 0xa6f7}, {0xa700, 0xa7b9},
   685         -    {0xa7f7, 0xa82b}, {0xa830, 0xa839}, {0xa840, 0xa877}, {0xa880, 0xa8c5},
   686         -    {0xa8ce, 0xa8d9}, {0xa8e0, 0xa953}, {0xa95f, 0xa97c}, {0xa980, 0xa9cd},
   687         -    {0xa9cf, 0xa9d9}, {0xa9de, 0xa9fe}, {0xaa00, 0xaa36}, {0xaa40, 0xaa4d},
   688         -    {0xaa50, 0xaa59}, {0xaa5c, 0xaac2}, {0xaadb, 0xaaf6}, {0xab01, 0xab06},
   689         -    {0xab09, 0xab0e}, {0xab11, 0xab16}, {0xab20, 0xab26}, {0xab28, 0xab2e},
   690         -    {0xab30, 0xab65}, {0xab70, 0xabed}, {0xabf0, 0xabf9}, {0xac00, 0xd7a3},
   691         -    {0xd7b0, 0xd7c6}, {0xd7cb, 0xd7fb}, {0xf900, 0xfa6d}, {0xfa70, 0xfad9},
   692         -    {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xfb1d, 0xfb36}, {0xfb38, 0xfb3c},
   693         -    {0xfb46, 0xfbc1}, {0xfbd3, 0xfd3f}, {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7},
   694         -    {0xfdf0, 0xfdfd}, {0xfe00, 0xfe19}, {0xfe20, 0xfe52}, {0xfe54, 0xfe66},
   695         -    {0xfe68, 0xfe6b}, {0xfe70, 0xfe74}, {0xfe76, 0xfefc}, {0xff01, 0xffbe},
   696         -    {0xffc2, 0xffc7}, {0xffca, 0xffcf}, {0xffd2, 0xffd7}, {0xffda, 0xffdc},
   697         -    {0xffe0, 0xffe6}, {0xffe8, 0xffee}
          686  +    {0xa490, 0xa4c6}, {0xa4d0, 0xa62b}, {0xa640, 0xa6f7}, {0xa700, 0xa7bf},
          687  +    {0xa7c2, 0xa7c6}, {0xa7f7, 0xa82b}, {0xa830, 0xa839}, {0xa840, 0xa877},
          688  +    {0xa880, 0xa8c5}, {0xa8ce, 0xa8d9}, {0xa8e0, 0xa953}, {0xa95f, 0xa97c},
          689  +    {0xa980, 0xa9cd}, {0xa9cf, 0xa9d9}, {0xa9de, 0xa9fe}, {0xaa00, 0xaa36},
          690  +    {0xaa40, 0xaa4d}, {0xaa50, 0xaa59}, {0xaa5c, 0xaac2}, {0xaadb, 0xaaf6},
          691  +    {0xab01, 0xab06}, {0xab09, 0xab0e}, {0xab11, 0xab16}, {0xab20, 0xab26},
          692  +    {0xab28, 0xab2e}, {0xab30, 0xab67}, {0xab70, 0xabed}, {0xabf0, 0xabf9},
          693  +    {0xac00, 0xd7a3}, {0xd7b0, 0xd7c6}, {0xd7cb, 0xd7fb}, {0xf900, 0xfa6d},
          694  +    {0xfa70, 0xfad9}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xfb1d, 0xfb36},
          695  +    {0xfb38, 0xfb3c}, {0xfb46, 0xfbc1}, {0xfbd3, 0xfd3f}, {0xfd50, 0xfd8f},
          696  +    {0xfd92, 0xfdc7}, {0xfdf0, 0xfdfd}, {0xfe00, 0xfe19}, {0xfe20, 0xfe52},
          697  +    {0xfe54, 0xfe66}, {0xfe68, 0xfe6b}, {0xfe70, 0xfe74}, {0xfe76, 0xfefc},
          698  +    {0xff01, 0xffbe}, {0xffc2, 0xffc7}, {0xffca, 0xffcf}, {0xffd2, 0xffd7},
          699  +    {0xffda, 0xffdc}, {0xffe0, 0xffe6}, {0xffe8, 0xffee}
   698    700   #if CHRBITS > 16
   699    701       ,{0x10000, 0x1000b}, {0x1000d, 0x10026}, {0x10028, 0x1003a}, {0x1003f, 0x1004d},
   700    702       {0x10050, 0x1005d}, {0x10080, 0x100fa}, {0x10100, 0x10102}, {0x10107, 0x10133},
   701    703       {0x10137, 0x1018e}, {0x10190, 0x1019b}, {0x101d0, 0x101fd}, {0x10280, 0x1029c},
   702    704       {0x102a0, 0x102d0}, {0x102e0, 0x102fb}, {0x10300, 0x10323}, {0x1032d, 0x1034a},
   703    705       {0x10350, 0x1037a}, {0x10380, 0x1039d}, {0x1039f, 0x103c3}, {0x103c8, 0x103d5},
   704    706       {0x10400, 0x1049d}, {0x104a0, 0x104a9}, {0x104b0, 0x104d3}, {0x104d8, 0x104fb},
................................................................................
   707    709       {0x10857, 0x1089e}, {0x108a7, 0x108af}, {0x108e0, 0x108f2}, {0x108fb, 0x1091b},
   708    710       {0x1091f, 0x10939}, {0x10980, 0x109b7}, {0x109bc, 0x109cf}, {0x109d2, 0x10a03},
   709    711       {0x10a0c, 0x10a13}, {0x10a15, 0x10a17}, {0x10a19, 0x10a35}, {0x10a38, 0x10a3a},
   710    712       {0x10a3f, 0x10a48}, {0x10a50, 0x10a58}, {0x10a60, 0x10a9f}, {0x10ac0, 0x10ae6},
   711    713       {0x10aeb, 0x10af6}, {0x10b00, 0x10b35}, {0x10b39, 0x10b55}, {0x10b58, 0x10b72},
   712    714       {0x10b78, 0x10b91}, {0x10b99, 0x10b9c}, {0x10ba9, 0x10baf}, {0x10c00, 0x10c48},
   713    715       {0x10c80, 0x10cb2}, {0x10cc0, 0x10cf2}, {0x10cfa, 0x10d27}, {0x10d30, 0x10d39},
   714         -    {0x10e60, 0x10e7e}, {0x10f00, 0x10f27}, {0x10f30, 0x10f59}, {0x11000, 0x1104d},
   715         -    {0x11052, 0x1106f}, {0x1107f, 0x110bc}, {0x110be, 0x110c1}, {0x110d0, 0x110e8},
   716         -    {0x110f0, 0x110f9}, {0x11100, 0x11134}, {0x11136, 0x11146}, {0x11150, 0x11176},
   717         -    {0x11180, 0x111cd}, {0x111d0, 0x111df}, {0x111e1, 0x111f4}, {0x11200, 0x11211},
   718         -    {0x11213, 0x1123e}, {0x11280, 0x11286}, {0x1128a, 0x1128d}, {0x1128f, 0x1129d},
   719         -    {0x1129f, 0x112a9}, {0x112b0, 0x112ea}, {0x112f0, 0x112f9}, {0x11300, 0x11303},
   720         -    {0x11305, 0x1130c}, {0x11313, 0x11328}, {0x1132a, 0x11330}, {0x11335, 0x11339},
   721         -    {0x1133b, 0x11344}, {0x1134b, 0x1134d}, {0x1135d, 0x11363}, {0x11366, 0x1136c},
   722         -    {0x11370, 0x11374}, {0x11400, 0x11459}, {0x11480, 0x114c7}, {0x114d0, 0x114d9},
   723         -    {0x11580, 0x115b5}, {0x115b8, 0x115dd}, {0x11600, 0x11644}, {0x11650, 0x11659},
   724         -    {0x11660, 0x1166c}, {0x11680, 0x116b7}, {0x116c0, 0x116c9}, {0x11700, 0x1171a},
   725         -    {0x1171d, 0x1172b}, {0x11730, 0x1173f}, {0x11800, 0x1183b}, {0x118a0, 0x118f2},
   726         -    {0x11a00, 0x11a47}, {0x11a50, 0x11a83}, {0x11a86, 0x11aa2}, {0x11ac0, 0x11af8},
          716  +    {0x10e60, 0x10e7e}, {0x10f00, 0x10f27}, {0x10f30, 0x10f59}, {0x10fe0, 0x10ff6},
          717  +    {0x11000, 0x1104d}, {0x11052, 0x1106f}, {0x1107f, 0x110bc}, {0x110be, 0x110c1},
          718  +    {0x110d0, 0x110e8}, {0x110f0, 0x110f9}, {0x11100, 0x11134}, {0x11136, 0x11146},
          719  +    {0x11150, 0x11176}, {0x11180, 0x111cd}, {0x111d0, 0x111df}, {0x111e1, 0x111f4},
          720  +    {0x11200, 0x11211}, {0x11213, 0x1123e}, {0x11280, 0x11286}, {0x1128a, 0x1128d},
          721  +    {0x1128f, 0x1129d}, {0x1129f, 0x112a9}, {0x112b0, 0x112ea}, {0x112f0, 0x112f9},
          722  +    {0x11300, 0x11303}, {0x11305, 0x1130c}, {0x11313, 0x11328}, {0x1132a, 0x11330},
          723  +    {0x11335, 0x11339}, {0x1133b, 0x11344}, {0x1134b, 0x1134d}, {0x1135d, 0x11363},
          724  +    {0x11366, 0x1136c}, {0x11370, 0x11374}, {0x11400, 0x11459}, {0x1145d, 0x1145f},
          725  +    {0x11480, 0x114c7}, {0x114d0, 0x114d9}, {0x11580, 0x115b5}, {0x115b8, 0x115dd},
          726  +    {0x11600, 0x11644}, {0x11650, 0x11659}, {0x11660, 0x1166c}, {0x11680, 0x116b8},
          727  +    {0x116c0, 0x116c9}, {0x11700, 0x1171a}, {0x1171d, 0x1172b}, {0x11730, 0x1173f},
          728  +    {0x11800, 0x1183b}, {0x118a0, 0x118f2}, {0x119a0, 0x119a7}, {0x119aa, 0x119d7},
          729  +    {0x119da, 0x119e4}, {0x11a00, 0x11a47}, {0x11a50, 0x11aa2}, {0x11ac0, 0x11af8},
   727    730       {0x11c00, 0x11c08}, {0x11c0a, 0x11c36}, {0x11c38, 0x11c45}, {0x11c50, 0x11c6c},
   728    731       {0x11c70, 0x11c8f}, {0x11c92, 0x11ca7}, {0x11ca9, 0x11cb6}, {0x11d00, 0x11d06},
   729    732       {0x11d0b, 0x11d36}, {0x11d3f, 0x11d47}, {0x11d50, 0x11d59}, {0x11d60, 0x11d65},
   730    733       {0x11d6a, 0x11d8e}, {0x11d93, 0x11d98}, {0x11da0, 0x11da9}, {0x11ee0, 0x11ef8},
   731         -    {0x12000, 0x12399}, {0x12400, 0x1246e}, {0x12470, 0x12474}, {0x12480, 0x12543},
   732         -    {0x13000, 0x1342e}, {0x14400, 0x14646}, {0x16800, 0x16a38}, {0x16a40, 0x16a5e},
   733         -    {0x16a60, 0x16a69}, {0x16ad0, 0x16aed}, {0x16af0, 0x16af5}, {0x16b00, 0x16b45},
   734         -    {0x16b50, 0x16b59}, {0x16b5b, 0x16b61}, {0x16b63, 0x16b77}, {0x16b7d, 0x16b8f},
   735         -    {0x16e40, 0x16e9a}, {0x16f00, 0x16f44}, {0x16f50, 0x16f7e}, {0x16f8f, 0x16f9f},
   736         -    {0x17000, 0x187f1}, {0x18800, 0x18af2}, {0x1b000, 0x1b11e}, {0x1b170, 0x1b2fb},
          734  +    {0x11fc0, 0x11ff1}, {0x11fff, 0x12399}, {0x12400, 0x1246e}, {0x12470, 0x12474},
          735  +    {0x12480, 0x12543}, {0x13000, 0x1342e}, {0x14400, 0x14646}, {0x16800, 0x16a38},
          736  +    {0x16a40, 0x16a5e}, {0x16a60, 0x16a69}, {0x16ad0, 0x16aed}, {0x16af0, 0x16af5},
          737  +    {0x16b00, 0x16b45}, {0x16b50, 0x16b59}, {0x16b5b, 0x16b61}, {0x16b63, 0x16b77},
          738  +    {0x16b7d, 0x16b8f}, {0x16e40, 0x16e9a}, {0x16f00, 0x16f4a}, {0x16f4f, 0x16f87},
          739  +    {0x16f8f, 0x16f9f}, {0x16fe0, 0x16fe3}, {0x17000, 0x187f7}, {0x18800, 0x18af2},
          740  +    {0x1b000, 0x1b11e}, {0x1b150, 0x1b152}, {0x1b164, 0x1b167}, {0x1b170, 0x1b2fb},
   737    741       {0x1bc00, 0x1bc6a}, {0x1bc70, 0x1bc7c}, {0x1bc80, 0x1bc88}, {0x1bc90, 0x1bc99},
   738    742       {0x1bc9c, 0x1bc9f}, {0x1d000, 0x1d0f5}, {0x1d100, 0x1d126}, {0x1d129, 0x1d172},
   739    743       {0x1d17b, 0x1d1e8}, {0x1d200, 0x1d245}, {0x1d2e0, 0x1d2f3}, {0x1d300, 0x1d356},
   740    744       {0x1d360, 0x1d378}, {0x1d400, 0x1d454}, {0x1d456, 0x1d49c}, {0x1d4a9, 0x1d4ac},
   741    745       {0x1d4ae, 0x1d4b9}, {0x1d4bd, 0x1d4c3}, {0x1d4c5, 0x1d505}, {0x1d507, 0x1d50a},
   742    746       {0x1d50d, 0x1d514}, {0x1d516, 0x1d51c}, {0x1d51e, 0x1d539}, {0x1d53b, 0x1d53e},
   743    747       {0x1d540, 0x1d544}, {0x1d54a, 0x1d550}, {0x1d552, 0x1d6a5}, {0x1d6a8, 0x1d7cb},
   744    748       {0x1d7ce, 0x1da8b}, {0x1da9b, 0x1da9f}, {0x1daa1, 0x1daaf}, {0x1e000, 0x1e006},
   745         -    {0x1e008, 0x1e018}, {0x1e01b, 0x1e021}, {0x1e026, 0x1e02a}, {0x1e800, 0x1e8c4},
   746         -    {0x1e8c7, 0x1e8d6}, {0x1e900, 0x1e94a}, {0x1e950, 0x1e959}, {0x1ec71, 0x1ecb4},
   747         -    {0x1ee00, 0x1ee03}, {0x1ee05, 0x1ee1f}, {0x1ee29, 0x1ee32}, {0x1ee34, 0x1ee37},
   748         -    {0x1ee4d, 0x1ee4f}, {0x1ee67, 0x1ee6a}, {0x1ee6c, 0x1ee72}, {0x1ee74, 0x1ee77},
   749         -    {0x1ee79, 0x1ee7c}, {0x1ee80, 0x1ee89}, {0x1ee8b, 0x1ee9b}, {0x1eea1, 0x1eea3},
   750         -    {0x1eea5, 0x1eea9}, {0x1eeab, 0x1eebb}, {0x1f000, 0x1f02b}, {0x1f030, 0x1f093},
   751         -    {0x1f0a0, 0x1f0ae}, {0x1f0b1, 0x1f0bf}, {0x1f0c1, 0x1f0cf}, {0x1f0d1, 0x1f0f5},
   752         -    {0x1f100, 0x1f10c}, {0x1f110, 0x1f16b}, {0x1f170, 0x1f1ac}, {0x1f1e6, 0x1f202},
   753         -    {0x1f210, 0x1f23b}, {0x1f240, 0x1f248}, {0x1f260, 0x1f265}, {0x1f300, 0x1f6d4},
   754         -    {0x1f6e0, 0x1f6ec}, {0x1f6f0, 0x1f6f9}, {0x1f700, 0x1f773}, {0x1f780, 0x1f7d8},
   755         -    {0x1f800, 0x1f80b}, {0x1f810, 0x1f847}, {0x1f850, 0x1f859}, {0x1f860, 0x1f887},
   756         -    {0x1f890, 0x1f8ad}, {0x1f900, 0x1f90b}, {0x1f910, 0x1f93e}, {0x1f940, 0x1f970},
   757         -    {0x1f973, 0x1f976}, {0x1f97c, 0x1f9a2}, {0x1f9b0, 0x1f9b9}, {0x1f9c0, 0x1f9c2},
   758         -    {0x1f9d0, 0x1f9ff}, {0x1fa60, 0x1fa6d}, {0x20000, 0x2a6d6}, {0x2a700, 0x2b734},
   759         -    {0x2b740, 0x2b81d}, {0x2b820, 0x2cea1}, {0x2ceb0, 0x2ebe0}, {0x2f800, 0x2fa1d},
   760         -    {0xe0100, 0xe01ef}
          749  +    {0x1e008, 0x1e018}, {0x1e01b, 0x1e021}, {0x1e026, 0x1e02a}, {0x1e100, 0x1e12c},
          750  +    {0x1e130, 0x1e13d}, {0x1e140, 0x1e149}, {0x1e2c0, 0x1e2f9}, {0x1e800, 0x1e8c4},
          751  +    {0x1e8c7, 0x1e8d6}, {0x1e900, 0x1e94b}, {0x1e950, 0x1e959}, {0x1ec71, 0x1ecb4},
          752  +    {0x1ed01, 0x1ed3d}, {0x1ee00, 0x1ee03}, {0x1ee05, 0x1ee1f}, {0x1ee29, 0x1ee32},
          753  +    {0x1ee34, 0x1ee37}, {0x1ee4d, 0x1ee4f}, {0x1ee67, 0x1ee6a}, {0x1ee6c, 0x1ee72},
          754  +    {0x1ee74, 0x1ee77}, {0x1ee79, 0x1ee7c}, {0x1ee80, 0x1ee89}, {0x1ee8b, 0x1ee9b},
          755  +    {0x1eea1, 0x1eea3}, {0x1eea5, 0x1eea9}, {0x1eeab, 0x1eebb}, {0x1f000, 0x1f02b},
          756  +    {0x1f030, 0x1f093}, {0x1f0a0, 0x1f0ae}, {0x1f0b1, 0x1f0bf}, {0x1f0c1, 0x1f0cf},
          757  +    {0x1f0d1, 0x1f0f5}, {0x1f100, 0x1f10c}, {0x1f110, 0x1f16c}, {0x1f170, 0x1f1ac},
          758  +    {0x1f1e6, 0x1f202}, {0x1f210, 0x1f23b}, {0x1f240, 0x1f248}, {0x1f260, 0x1f265},
          759  +    {0x1f300, 0x1f6d5}, {0x1f6e0, 0x1f6ec}, {0x1f6f0, 0x1f6fa}, {0x1f700, 0x1f773},
          760  +    {0x1f780, 0x1f7d8}, {0x1f7e0, 0x1f7eb}, {0x1f800, 0x1f80b}, {0x1f810, 0x1f847},
          761  +    {0x1f850, 0x1f859}, {0x1f860, 0x1f887}, {0x1f890, 0x1f8ad}, {0x1f900, 0x1f90b},
          762  +    {0x1f90d, 0x1f971}, {0x1f973, 0x1f976}, {0x1f97a, 0x1f9a2}, {0x1f9a5, 0x1f9aa},
          763  +    {0x1f9ae, 0x1f9ca}, {0x1f9cd, 0x1fa53}, {0x1fa60, 0x1fa6d}, {0x1fa70, 0x1fa73},
          764  +    {0x1fa78, 0x1fa7a}, {0x1fa80, 0x1fa82}, {0x1fa90, 0x1fa95}, {0x20000, 0x2a6d6},
          765  +    {0x2a700, 0x2b734}, {0x2b740, 0x2b81d}, {0x2b820, 0x2cea1}, {0x2ceb0, 0x2ebe0},
          766  +    {0x2f800, 0x2fa1d}, {0xe0100, 0xe01ef}
   761    767   #endif
   762    768   };
   763    769   
   764    770   #define NUM_GRAPH_RANGE (sizeof(graphRangeTable)/sizeof(crange))
   765    771   
   766    772   static const chr graphCharTable[] = {
   767    773       0x38c, 0x85e, 0x98f, 0x990, 0x9b2, 0x9c7, 0x9c8, 0x9d7, 0x9dc,
   768    774       0x9dd, 0xa0f, 0xa10, 0xa32, 0xa33, 0xa35, 0xa36, 0xa38, 0xa39,
   769    775       0xa3c, 0xa47, 0xa48, 0xa51, 0xa5e, 0xab2, 0xab3, 0xad0, 0xb0f,
   770    776       0xb10, 0xb32, 0xb33, 0xb47, 0xb48, 0xb56, 0xb57, 0xb5c, 0xb5d,
   771    777       0xb82, 0xb83, 0xb99, 0xb9a, 0xb9c, 0xb9e, 0xb9f, 0xba3, 0xba4,
   772    778       0xbd0, 0xbd7, 0xc55, 0xc56, 0xcd5, 0xcd6, 0xcde, 0xcf1, 0xcf2,
   773         -    0xd82, 0xd83, 0xdbd, 0xdca, 0xdd6, 0xe81, 0xe82, 0xe84, 0xe87,
   774         -    0xe88, 0xe8a, 0xe8d, 0xea5, 0xea7, 0xeaa, 0xeab, 0xec6, 0x10c7,
   775         -    0x10cd, 0x1258, 0x12c0, 0x1772, 0x1773, 0x1940, 0x1f59, 0x1f5b, 0x1f5d,
   776         -    0x2070, 0x2071, 0x2d27, 0x2d2d, 0x2d6f, 0x2d70, 0xfb3e, 0xfb40, 0xfb41,
   777         -    0xfb43, 0xfb44, 0xfffc, 0xfffd
          779  +    0xd82, 0xd83, 0xdbd, 0xdca, 0xdd6, 0xe81, 0xe82, 0xe84, 0xea5,
          780  +    0xec6, 0x10c7, 0x10cd, 0x1258, 0x12c0, 0x1772, 0x1773, 0x1940, 0x1f59,
          781  +    0x1f5b, 0x1f5d, 0x2070, 0x2071, 0x2d27, 0x2d2d, 0x2d6f, 0x2d70, 0xfb3e,
          782  +    0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfffc, 0xfffd
   778    783   #if CHRBITS > 16
   779    784       ,0x1003c, 0x1003d, 0x101a0, 0x1056f, 0x10808, 0x10837, 0x10838, 0x1083c, 0x108f4,
   780    785       0x108f5, 0x1093f, 0x10a05, 0x10a06, 0x11288, 0x1130f, 0x11310, 0x11332, 0x11333,
   781         -    0x11347, 0x11348, 0x11350, 0x11357, 0x1145b, 0x1145d, 0x1145e, 0x118ff, 0x11d08,
   782         -    0x11d09, 0x11d3a, 0x11d3c, 0x11d3d, 0x11d67, 0x11d68, 0x11d90, 0x11d91, 0x16a6e,
   783         -    0x16a6f, 0x16fe0, 0x16fe1, 0x1d49e, 0x1d49f, 0x1d4a2, 0x1d4a5, 0x1d4a6, 0x1d4bb,
   784         -    0x1d546, 0x1e023, 0x1e024, 0x1e95e, 0x1e95f, 0x1ee21, 0x1ee22, 0x1ee24, 0x1ee27,
   785         -    0x1ee39, 0x1ee3b, 0x1ee42, 0x1ee47, 0x1ee49, 0x1ee4b, 0x1ee51, 0x1ee52, 0x1ee54,
   786         -    0x1ee57, 0x1ee59, 0x1ee5b, 0x1ee5d, 0x1ee5f, 0x1ee61, 0x1ee62, 0x1ee64, 0x1ee7e,
   787         -    0x1eef0, 0x1eef1, 0x1f250, 0x1f251, 0x1f97a
          786  +    0x11347, 0x11348, 0x11350, 0x11357, 0x1145b, 0x118ff, 0x11d08, 0x11d09, 0x11d3a,
          787  +    0x11d3c, 0x11d3d, 0x11d67, 0x11d68, 0x11d90, 0x11d91, 0x16a6e, 0x16a6f, 0x1d49e,
          788  +    0x1d49f, 0x1d4a2, 0x1d4a5, 0x1d4a6, 0x1d4bb, 0x1d546, 0x1e023, 0x1e024, 0x1e14e,
          789  +    0x1e14f, 0x1e2ff, 0x1e95e, 0x1e95f, 0x1ee21, 0x1ee22, 0x1ee24, 0x1ee27, 0x1ee39,
          790  +    0x1ee3b, 0x1ee42, 0x1ee47, 0x1ee49, 0x1ee4b, 0x1ee51, 0x1ee52, 0x1ee54, 0x1ee57,
          791  +    0x1ee59, 0x1ee5b, 0x1ee5d, 0x1ee5f, 0x1ee61, 0x1ee62, 0x1ee64, 0x1ee7e, 0x1eef0,
          792  +    0x1eef1, 0x1f250, 0x1f251
   788    793   #endif
   789    794   };
   790    795   
   791    796   #define NUM_GRAPH_CHAR (sizeof(graphCharTable)/sizeof(chr))
   792    797   
   793    798   /*
   794    799    *	End of auto-generated Unicode character ranges declarations.

Changes to generic/tclBasic.c.

   296    296       {"pwd",		Tcl_PwdObjCmd,		NULL,			NULL,	0},
   297    297       {"read",		Tcl_ReadObjCmd,		NULL,			NULL,	CMD_IS_SAFE},
   298    298       {"seek",		Tcl_SeekObjCmd,		NULL,			NULL,	CMD_IS_SAFE},
   299    299       {"socket",		Tcl_SocketObjCmd,	NULL,			NULL,	0},
   300    300       {"source",		Tcl_SourceObjCmd,	NULL,			TclNRSourceObjCmd,	0},
   301    301       {"tell",		Tcl_TellObjCmd,		NULL,			NULL,	CMD_IS_SAFE},
   302    302       {"time",		Tcl_TimeObjCmd,		NULL,			NULL,	CMD_IS_SAFE},
          303  +    {"timerate",	Tcl_TimeRateObjCmd,	NULL,			NULL,	CMD_IS_SAFE},
   303    304       {"unload",		Tcl_UnloadObjCmd,	NULL,			NULL,	0},
   304    305       {"update",		Tcl_UpdateObjCmd,	NULL,			NULL,	CMD_IS_SAFE},
   305    306       {"vwait",		Tcl_VwaitObjCmd,	NULL,			NULL,	CMD_IS_SAFE},
   306    307       {NULL,		NULL,			NULL,			NULL,	0}
   307    308   };
   308    309   
   309    310   /*
................................................................................
   536    537   {
   537    538       Interp *iPtr;
   538    539       Tcl_Interp *interp;
   539    540       Command *cmdPtr;
   540    541       const BuiltinFuncDef *builtinFuncPtr;
   541    542       const OpCmdInfo *opcmdInfoPtr;
   542    543       const CmdInfo *cmdInfoPtr;
   543         -    Tcl_Namespace *mathfuncNSPtr, *mathopNSPtr;
          544  +    Tcl_Namespace *nsPtr;
   544    545       Tcl_HashEntry *hPtr;
   545    546       int isNew;
   546    547       CancelInfo *cancelInfo;
   547    548       union {
   548    549   	char c[sizeof(short)];
   549    550   	short s;
   550    551       } order;
................................................................................
   934    935       cmdPtr = (Command *) Tcl_NRCreateCommand(interp,
   935    936               "::tcl::unsupported::assemble", Tcl_AssembleObjCmd,
   936    937               TclNRAssembleObjCmd, NULL, NULL);
   937    938       cmdPtr->compileProc = &TclCompileAssembleCmd;
   938    939   
   939    940       Tcl_NRCreateCommand(interp, "::tcl::unsupported::inject", NULL,
   940    941   	    NRCoroInjectObjCmd, NULL, NULL);
          942  +
          943  +    /* Export unsupported commands */
          944  +    nsPtr = Tcl_FindNamespace(interp, "::tcl::unsupported", NULL, 0);
          945  +    if (nsPtr) {
          946  +	Tcl_Export(interp, nsPtr, "*", 1);
          947  +    }
          948  +
   941    949   
   942    950   #ifdef USE_DTRACE
   943    951       /*
   944    952        * Register the tcl::dtrace command.
   945    953        */
   946    954   
   947    955       Tcl_CreateObjCommand(interp, "::tcl::dtrace", DTraceObjCmd, NULL, NULL);
   948    956   #endif /* USE_DTRACE */
   949    957   
   950    958       /*
   951    959        * Register the builtin math functions.
   952    960        */
   953    961   
   954         -    mathfuncNSPtr = Tcl_CreateNamespace(interp, "::tcl::mathfunc", NULL,NULL);
   955         -    if (mathfuncNSPtr == NULL) {
          962  +    nsPtr = Tcl_CreateNamespace(interp, "::tcl::mathfunc", NULL,NULL);
          963  +    if (nsPtr == NULL) {
   956    964   	Tcl_Panic("Can't create math function namespace");
   957    965       }
   958    966   #define MATH_FUNC_PREFIX_LEN 17 /* == strlen("::tcl::mathfunc::") */
   959    967       memcpy(mathFuncName, "::tcl::mathfunc::", MATH_FUNC_PREFIX_LEN);
   960    968       for (builtinFuncPtr = BuiltinFuncTable; builtinFuncPtr->name != NULL;
   961    969   	    builtinFuncPtr++) {
   962    970   	strcpy(mathFuncName+MATH_FUNC_PREFIX_LEN, builtinFuncPtr->name);
   963    971   	Tcl_CreateObjCommand(interp, mathFuncName,
   964    972   		builtinFuncPtr->objCmdProc, builtinFuncPtr->clientData, NULL);
   965         -	Tcl_Export(interp, mathfuncNSPtr, builtinFuncPtr->name, 0);
          973  +	Tcl_Export(interp, nsPtr, builtinFuncPtr->name, 0);
   966    974       }
   967    975   
   968    976       /*
   969    977        * Register the mathematical "operator" commands. [TIP #174]
   970    978        */
   971    979   
   972         -    mathopNSPtr = Tcl_CreateNamespace(interp, "::tcl::mathop", NULL, NULL);
   973         -    if (mathopNSPtr == NULL) {
          980  +    nsPtr = Tcl_CreateNamespace(interp, "::tcl::mathop", NULL, NULL);
          981  +    if (nsPtr == NULL) {
   974    982   	Tcl_Panic("can't create math operator namespace");
   975    983       }
   976         -    Tcl_Export(interp, mathopNSPtr, "*", 1);
          984  +    Tcl_Export(interp, nsPtr, "*", 1);
   977    985   #define MATH_OP_PREFIX_LEN 15 /* == strlen("::tcl::mathop::") */
   978    986       memcpy(mathFuncName, "::tcl::mathop::", MATH_OP_PREFIX_LEN);
   979    987       for (opcmdInfoPtr=mathOpCmds ; opcmdInfoPtr->name!=NULL ; opcmdInfoPtr++){
   980    988   	TclOpCmdClientData *occdPtr = Tcl_Alloc(sizeof(TclOpCmdClientData));
   981    989   
   982    990   	occdPtr->op = opcmdInfoPtr->name;
   983    991   	occdPtr->i.numArgs = opcmdInfoPtr->i.numArgs;
................................................................................
  6800   6808   	    }
  6801   6809   	}
  6802   6810   	break;
  6803   6811       case TCL_NUMBER_BIG:
  6804   6812   	if (Tcl_GetBignumFromObj(interp, objv[1], &big) != TCL_OK) {
  6805   6813   	    return TCL_ERROR;
  6806   6814   	}
  6807         -	if (SIGN(&big) == MP_NEG) {
         6815  +	if (mp_isneg(&big)) {
  6808   6816   	    mp_clear(&big);
  6809   6817   	    goto negarg;
  6810   6818   	}
  6811   6819   	break;
  6812   6820       default:
  6813   6821   	if (TclGetWideIntFromObj(interp, objv[1], &w) != TCL_OK) {
  6814   6822   	    return TCL_ERROR;

Changes to generic/tclClock.c.

  1768   1768   #ifdef TCL_WIDE_CLICKS
  1769   1769   	clicks = TclpGetWideClicks();
  1770   1770   #else
  1771   1771   	clicks = (Tcl_WideInt) TclpGetClicks();
  1772   1772   #endif
  1773   1773   	break;
  1774   1774       case CLICKS_MICROS:
  1775         -	Tcl_GetTime(&now);
  1776         -	clicks = ((Tcl_WideInt) now.sec * 1000000) + now.usec;
         1775  +	clicks = TclpGetMicroseconds();
  1777   1776   	break;
  1778   1777       }
  1779   1778   
  1780   1779       Tcl_SetObjResult(interp, Tcl_NewWideIntObj(clicks));
  1781   1780       return TCL_OK;
  1782   1781   }
  1783   1782   
................................................................................
  1839   1838   int
  1840   1839   ClockMicrosecondsObjCmd(
  1841   1840       ClientData clientData,	/* Client data is unused */
  1842   1841       Tcl_Interp *interp,		/* Tcl interpreter */
  1843   1842       int objc,			/* Parameter count */
  1844   1843       Tcl_Obj *const *objv)	/* Parameter values */
  1845   1844   {
  1846         -    Tcl_Time now;
  1847         -
  1848   1845       if (objc != 1) {
  1849   1846   	Tcl_WrongNumArgs(interp, 1, objv, NULL);
  1850   1847   	return TCL_ERROR;
  1851   1848       }
  1852         -    Tcl_GetTime(&now);
  1853         -    Tcl_SetObjResult(interp, Tcl_NewWideIntObj(
  1854         -	    ((Tcl_WideInt) now.sec * 1000000) + now.usec));
         1849  +    Tcl_SetObjResult(interp, Tcl_NewWideIntObj(TclpGetMicroseconds()));
  1855   1850       return TCL_OK;
  1856   1851   }
  1857   1852   
  1858   1853   /*
  1859   1854    *-----------------------------------------------------------------------------
  1860   1855    *
  1861   1856    * ClockParseformatargsObjCmd --

Changes to generic/tclCmdMZ.c.

    13     13    * Copyright (c) 2003-2009 Donal K. Fellows.
    14     14    *
    15     15    * See the file "license.terms" for information on usage and redistribution of
    16     16    * this file, and for a DISCLAIMER OF ALL WARRANTIES.
    17     17    */
    18     18   
    19     19   #include "tclInt.h"
           20  +#include "tclCompile.h"
    20     21   #include "tclRegexp.h"
    21     22   #include "tclStringTrim.h"
    22     23   
    23     24   static inline Tcl_Obj *	During(Tcl_Interp *interp, int resultCode,
    24     25   			    Tcl_Obj *oldOptions, Tcl_Obj *errorInfo);
    25     26   static Tcl_NRPostProc	SwitchPostProc;
    26     27   static Tcl_NRPostProc	TryPostBody;
................................................................................
  1571   1572   	break;
  1572   1573       case STR_IS_ASCII:
  1573   1574   	chcomp = UniCharIsAscii;
  1574   1575   	break;
  1575   1576       case STR_IS_BOOL:
  1576   1577       case STR_IS_TRUE:
  1577   1578       case STR_IS_FALSE:
  1578         -	if ((objPtr->typePtr != &tclBooleanType)
         1579  +	if (!TclHasIntRep(objPtr, &tclBooleanType)
  1579   1580   		&& (TCL_OK != TclSetBooleanFromAny(NULL, objPtr))) {
  1580   1581   	    if (strict) {
  1581   1582   		result = 0;
  1582   1583   	    } else {
  1583   1584   		string1 = TclGetStringFromObj(objPtr, &length1);
  1584   1585   		result = length1 == 0;
  1585   1586   	    }
................................................................................
  4038   4039       i = count;
  4039   4040   #ifndef TCL_WIDE_CLICKS
  4040   4041       Tcl_GetTime(&start);
  4041   4042   #else
  4042   4043       start = TclpGetWideClicks();
  4043   4044   #endif
  4044   4045       while (i-- > 0) {
  4045         -	result = Tcl_EvalObjEx(interp, objPtr, 0);
         4046  +	result = TclEvalObjEx(interp, objPtr, 0, NULL, 0);
  4046   4047   	if (result != TCL_OK) {
  4047   4048   	    return result;
  4048   4049   	}
  4049   4050       }
  4050   4051   #ifndef TCL_WIDE_CLICKS
  4051   4052       Tcl_GetTime(&stop);
  4052   4053       totalMicroSec = ((double) (stop.sec - start.sec)) * 1.0e6
................................................................................
  4074   4075       TclNewLiteralStringObj(objs[1], "microseconds");
  4075   4076       TclNewLiteralStringObj(objs[2], "per");
  4076   4077       TclNewLiteralStringObj(objs[3], "iteration");
  4077   4078       Tcl_SetObjResult(interp, Tcl_NewListObj(4, objs));
  4078   4079   
  4079   4080       return TCL_OK;
  4080   4081   }
         4082  +
         4083  +/*
         4084  + *----------------------------------------------------------------------
         4085  + *
         4086  + * Tcl_TimeRateObjCmd --
         4087  + *
         4088  + *	This object-based procedure is invoked to process the "timerate" Tcl
         4089  + *	command.
         4090  + *	This is similar to command "time", except the execution limited by
         4091  + *	given time (in milliseconds) instead of repetition count.
         4092  + *
         4093  + * Example:
         4094  + *	timerate {after 5} 1000 ; # equivalent for `time {after 5} [expr 1000/5]`
         4095  + *
         4096  + * Results:
         4097  + *	A standard Tcl object result.
         4098  + *
         4099  + * Side effects:
         4100  + *	See the user documentation.
         4101  + *
         4102  + *----------------------------------------------------------------------
         4103  + */
         4104  +
         4105  +int
         4106  +Tcl_TimeRateObjCmd(
         4107  +    ClientData dummy,		/* Not used. */
         4108  +    Tcl_Interp *interp,		/* Current interpreter. */
         4109  +    int objc,			/* Number of arguments. */
         4110  +    Tcl_Obj *const objv[])	/* Argument objects. */
         4111  +{
         4112  +    static double measureOverhead = 0; /* global measure-overhead */
         4113  +    double overhead = -1;	/* given measure-overhead */
         4114  +    register Tcl_Obj *objPtr;
         4115  +    register int result, i;
         4116  +    Tcl_Obj *calibrate = NULL, *direct = NULL;
         4117  +    Tcl_WideUInt count = 0;	/* Holds repetition count */
         4118  +    Tcl_WideInt  maxms  = WIDE_MIN;
         4119  +				/* Maximal running time (in milliseconds) */
         4120  +    Tcl_WideUInt maxcnt = WIDE_MAX;
         4121  +				/* Maximal count of iterations. */
         4122  +    Tcl_WideUInt threshold = 1;	/* Current threshold for check time (faster
         4123  +				 * repeat count without time check) */
         4124  +    Tcl_WideUInt maxIterTm = 1;	/* Max time of some iteration as max threshold
         4125  +				 * additionally avoid divide to zero (never < 1) */
         4126  +    unsigned short factor = 50;	/* Factor (4..50) limiting threshold to avoid
         4127  +				 * growth of execution time. */
         4128  +    register Tcl_WideInt start, middle, stop;
         4129  +#ifndef TCL_WIDE_CLICKS
         4130  +    Tcl_Time now;
         4131  +#endif
         4132  +
         4133  +    static const char *const options[] = {
         4134  +	"-direct",	"-overhead",	"-calibrate",	"--",	NULL
         4135  +    };
         4136  +    enum options {
         4137  +	TMRT_EV_DIRECT,	TMRT_OVERHEAD,	TMRT_CALIBRATE,	TMRT_LAST
         4138  +    };
         4139  +
         4140  +    NRE_callback *rootPtr;
         4141  +    ByteCode	 *codePtr = NULL;
         4142  +
         4143  +    for (i = 1; i < objc - 1; i++) {
         4144  +    	int index;
         4145  +	if (Tcl_GetIndexFromObj(NULL, objv[i], options, "option", TCL_EXACT,
         4146  +		&index) != TCL_OK) {
         4147  +	    break;
         4148  +	}
         4149  +	if (index == TMRT_LAST) {
         4150  +	    i++;
         4151  +	    break;
         4152  +	}
         4153  +	switch (index) {
         4154  +	case TMRT_EV_DIRECT:
         4155  +	    direct = objv[i];
         4156  +	    break;
         4157  +	case TMRT_OVERHEAD:
         4158  +	    if (++i >= objc - 1) {
         4159  +		goto usage;
         4160  +	    }
         4161  +	    if (Tcl_GetDoubleFromObj(interp, objv[i], &overhead) != TCL_OK) {
         4162  +		return TCL_ERROR;
         4163  +	    }
         4164  +	    break;
         4165  +	case TMRT_CALIBRATE:
         4166  +	    calibrate = objv[i];
         4167  +	    break;
         4168  +	}
         4169  +    }
         4170  +
         4171  +    if (i >= objc || i < objc-3) {
         4172  +usage:
         4173  +	Tcl_WrongNumArgs(interp, 1, objv, "?-direct? ?-calibrate? ?-overhead double? command ?time ?max-count??");
         4174  +	return TCL_ERROR;
         4175  +    }
         4176  +    objPtr = objv[i++];
         4177  +    if (i < objc) {	/* max-time */
         4178  +	result = Tcl_GetWideIntFromObj(interp, objv[i++], &maxms);
         4179  +	if (result != TCL_OK) {
         4180  +	    return result;
         4181  +	}
         4182  +	if (i < objc) {	/* max-count*/
         4183  +	    Tcl_WideInt v;
         4184  +	    result = Tcl_GetWideIntFromObj(interp, objv[i], &v);
         4185  +	    if (result != TCL_OK) {
         4186  +		return result;
         4187  +	    }
         4188  +	    maxcnt = (v > 0) ? v : 0;
         4189  +	}
         4190  +    }
         4191  +
         4192  +    /* if calibrate */
         4193  +    if (calibrate) {
         4194  +
         4195  +	/* if no time specified for the calibration */
         4196  +	if (maxms == WIDE_MIN) {
         4197  +	    Tcl_Obj *clobjv[6];
         4198  +	    Tcl_WideInt maxCalTime = 5000;
         4199  +	    double lastMeasureOverhead = measureOverhead;
         4200  +
         4201  +	    clobjv[0] = objv[0];
         4202  +	    i = 1;
         4203  +	    if (direct) {
         4204  +	    	clobjv[i++] = direct;
         4205  +	    }
         4206  +	    clobjv[i++] = objPtr;
         4207  +
         4208  +	    /* reset last measurement overhead */
         4209  +	    measureOverhead = (double)0;
         4210  +
         4211  +	    /* self-call with 100 milliseconds to warm-up,
         4212  +	     * before entering the calibration cycle */
         4213  +	    TclNewIntObj(clobjv[i], 100);
         4214  +	    Tcl_IncrRefCount(clobjv[i]);
         4215  +	    result = Tcl_TimeRateObjCmd(dummy, interp, i+1, clobjv);
         4216  +	    Tcl_DecrRefCount(clobjv[i]);
         4217  +	    if (result != TCL_OK) {
         4218  +		return result;
         4219  +	    }
         4220  +
         4221  +	    i--;
         4222  +	    clobjv[i++] = calibrate;
         4223  +	    clobjv[i++] = objPtr;
         4224  +
         4225  +	    /* set last measurement overhead to max */
         4226  +	    measureOverhead = (double)UWIDE_MAX;
         4227  +
         4228  +	    /* calibration cycle until it'll be preciser */
         4229  +	    maxms = -1000;
         4230  +	    do {
         4231  +		lastMeasureOverhead = measureOverhead;
         4232  +		TclNewIntObj(clobjv[i], (int)maxms);
         4233  +		Tcl_IncrRefCount(clobjv[i]);
         4234  +		result = Tcl_TimeRateObjCmd(dummy, interp, i+1, clobjv);
         4235  +		Tcl_DecrRefCount(clobjv[i]);
         4236  +		if (result != TCL_OK) {
         4237  +		    return result;
         4238  +		}
         4239  +		maxCalTime += maxms;
         4240  +		/* increase maxms for preciser calibration */
         4241  +		maxms -= (-maxms / 4);
         4242  +		/* as long as new value more as 0.05% better */
         4243  +	    } while ( (measureOverhead >= lastMeasureOverhead
         4244  +		    || measureOverhead / lastMeasureOverhead <= 0.9995)
         4245  +		    && maxCalTime > 0
         4246  +	    );
         4247  +
         4248  +	    return result;
         4249  +	}
         4250  +	if (maxms == 0) {
         4251  +	    /* reset last measurement overhead */
         4252  +	    measureOverhead = 0;
         4253  +	    Tcl_SetObjResult(interp, Tcl_NewLongObj(0));
         4254  +	    return TCL_OK;
         4255  +	}
         4256  +
         4257  +	/* if time is negative - make current overhead more precise */
         4258  +	if (maxms > 0) {
         4259  +	    /* set last measurement overhead to max */
         4260  +	    measureOverhead = (double)UWIDE_MAX;
         4261  +	} else {
         4262  +	    maxms = -maxms;
         4263  +	}
         4264  +
         4265  +    }
         4266  +
         4267  +    if (maxms == WIDE_MIN) {
         4268  +    	maxms = 1000;
         4269  +    }
         4270  +    if (overhead == -1) {
         4271  +	overhead = measureOverhead;
         4272  +    }
         4273  +
         4274  +    /* be sure that resetting of result will not smudge the further measurement */
         4275  +    Tcl_ResetResult(interp);
         4276  +
         4277  +    /* compile object */
         4278  +    if (!direct) {
         4279  +	if (TclInterpReady(interp) != TCL_OK) {
         4280  +	    return TCL_ERROR;
         4281  +	}
         4282  +	codePtr = TclCompileObj(interp, objPtr, NULL, 0);
         4283  +	TclPreserveByteCode(codePtr);
         4284  +    }
         4285  +
         4286  +    /* get start and stop time */
         4287  +#ifdef TCL_WIDE_CLICKS
         4288  +    start = middle = TclpGetWideClicks();
         4289  +    /* time to stop execution (in wide clicks) */
         4290  +    stop = start + (maxms * 1000 / TclpWideClickInMicrosec());
         4291  +#else
         4292  +    Tcl_GetTime(&now);
         4293  +    start = now.sec; start *= 1000000; start += now.usec;
         4294  +    middle = start;
         4295  +    /* time to stop execution (in microsecs) */
         4296  +    stop = start + maxms * 1000;
         4297  +#endif
         4298  +
         4299  +    /* start measurement */
         4300  +    if (maxcnt > 0)
         4301  +    while (1) {
         4302  +    	/* eval single iteration */
         4303  +    	count++;
         4304  +
         4305  +	if (!direct) {
         4306  +	    /* precompiled */
         4307  +	    rootPtr = TOP_CB(interp);
         4308  +	    result = TclNRExecuteByteCode(interp, codePtr);
         4309  +	    result = TclNRRunCallbacks(interp, result, rootPtr);
         4310  +	} else {
         4311  +	    /* eval */
         4312  +	    result = TclEvalObjEx(interp, objPtr, 0, NULL, 0);
         4313  +	}
         4314  +	if (result != TCL_OK) {
         4315  +	    /* allow break from measurement cycle (used for conditional stop) */
         4316  +	    if (result != TCL_BREAK) {
         4317  +		goto done;
         4318  +	    }
         4319  +	    /* force stop immediately */
         4320  +	    threshold = 1;
         4321  +	    maxcnt = 0;
         4322  +	    result = TCL_OK;
         4323  +	}
         4324  +
         4325  +	/* don't check time up to threshold */
         4326  +	if (--threshold > 0) continue;
         4327  +
         4328  +	/* check stop time reached, estimate new threshold */
         4329  +    #ifdef TCL_WIDE_CLICKS
         4330  +	middle = TclpGetWideClicks();
         4331  +    #else
         4332  +	Tcl_GetTime(&now);
         4333  +	middle = now.sec; middle *= 1000000; middle += now.usec;
         4334  +    #endif
         4335  +	if (middle >= stop || count >= maxcnt) {
         4336  +	    break;
         4337  +	}
         4338  +
         4339  +	/* don't calculate threshold by few iterations, because sometimes first
         4340  +	 * iteration(s) can be too fast or slow (cached, delayed clean up, etc) */
         4341  +	if (count < 10) {
         4342  +	   threshold = 1; continue;
         4343  +	}
         4344  +
         4345  +	/* average iteration time in microsecs */
         4346  +	threshold = (middle - start) / count;
         4347  +	if (threshold > maxIterTm) {
         4348  +	    maxIterTm = threshold;
         4349  +	    /* interations seems to be longer */
         4350  +	    if (threshold > (maxIterTm * 2)) {
         4351  +		if ((factor *= 2) > 50) factor = 50;
         4352  +	    } else {
         4353  +		if (factor < 50) factor++;
         4354  +	    }
         4355  +	} else if (factor > 4) {
         4356  +	    /* interations seems to be shorter */
         4357  +	    if (threshold < (maxIterTm / 2)) {
         4358  +		if ((factor /= 2) < 4) factor = 4;
         4359  +	    } else {
         4360  +		factor--;
         4361  +	    }
         4362  +	}
         4363  +	/* as relation between remaining time and time since last check,
         4364  +	 * maximal some % of time (by factor), so avoid growing of the execution time
         4365  +	 * if iterations are not consistent, e. g. wax continuously on time) */
         4366  +	threshold = ((stop - middle) / maxIterTm) / factor + 1;
         4367  +	if (threshold > 100000) {	    /* fix for too large threshold */
         4368  +	    threshold = 100000;
         4369  +	}
         4370  +	/* consider max-count */
         4371  +	if (threshold > maxcnt - count) {
         4372  +	    threshold = maxcnt - count;
         4373  +	}
         4374  +    }
         4375  +
         4376  +    {
         4377  +	Tcl_Obj *objarr[8], **objs = objarr;
         4378  +	Tcl_WideInt val;
         4379  +	const char *fmt;
         4380  +
         4381  +	middle -= start;		     /* execution time in microsecs */
         4382  +
         4383  +    #ifdef TCL_WIDE_CLICKS
         4384  +	/* convert execution time in wide clicks to microsecs */
         4385  +	middle *= TclpWideClickInMicrosec();
         4386  +    #endif
         4387  +
         4388  +	/* if not calibrate */
         4389  +	if (!calibrate) {
         4390  +	    /* minimize influence of measurement overhead */
         4391  +	    if (overhead > 0) {
         4392  +		/* estimate the time of overhead (microsecs) */
         4393  +		Tcl_WideUInt curOverhead = overhead * count;
         4394  +		if (middle > (Tcl_WideInt)curOverhead) {
         4395  +		    middle -= curOverhead;
         4396  +		} else {
         4397  +		    middle = 0;
         4398  +		}
         4399  +	    }
         4400  +	} else {
         4401  +	    /* calibration - obtaining new measurement overhead */
         4402  +	    if (measureOverhead > (double)middle / count) {
         4403  +		measureOverhead = (double)middle / count;
         4404  +	    }
         4405  +	    objs[0] = Tcl_NewDoubleObj(measureOverhead);
         4406  +	    TclNewLiteralStringObj(objs[1], "\xC2\xB5s/#-overhead"); /* mics */
         4407  +	    objs += 2;
         4408  +	}
         4409  +
         4410  +	val = middle / count;		     /* microsecs per iteration */
         4411  +	if (val >= 1000000) {
         4412  +	    objs[0] = Tcl_NewWideIntObj(val);
         4413  +	} else {
         4414  +	    if (val < 10)    { fmt = "%.6f"; } else
         4415  +	    if (val < 100)   { fmt = "%.4f"; } else
         4416  +	    if (val < 1000)  { fmt = "%.3f"; } else
         4417  +	    if (val < 10000) { fmt = "%.2f"; } else
         4418  +			     { fmt = "%.1f"; };
         4419  +	    objs[0] = Tcl_ObjPrintf(fmt, ((double)middle)/count);
         4420  +	}
         4421  +
         4422  +	objs[2] = Tcl_NewWideIntObj(count); /* iterations */
         4423  +
         4424  +	/* calculate speed as rate (count) per sec */
         4425  +	if (!middle) middle++; /* +1 ms, just to avoid divide by zero */
         4426  +	if (count < (WIDE_MAX / 1000000)) {
         4427  +	    val = (count * 1000000) / middle;
         4428  +	    if (val < 100000) {
         4429  +		if (val < 100)	{ fmt = "%.3f"; } else
         4430  +		if (val < 1000) { fmt = "%.2f"; } else
         4431  +				{ fmt = "%.1f"; };
         4432  +		objs[4] = Tcl_ObjPrintf(fmt, ((double)(count * 1000000)) / middle);
         4433  +	    } else {
         4434  +		objs[4] = Tcl_NewWideIntObj(val);
         4435  +	    }
         4436  +	} else {
         4437  +	    objs[4] = Tcl_NewWideIntObj((count / middle) * 1000000);
         4438  +	}
         4439  +
         4440  +	/* estimated net execution time (in millisecs) */
         4441  +	if (!calibrate) {
         4442  +	    objs[6] = Tcl_ObjPrintf("%.3f", (double)middle / 1000);
         4443  +	    TclNewLiteralStringObj(objs[7], "nett-ms");
         4444  +	}
         4445  +
         4446  +	/*
         4447  +	* Construct the result as a list because many programs have always parsed
         4448  +	* as such (extracting the first element, typically).
         4449  +	*/
         4450  +
         4451  +	TclNewLiteralStringObj(objs[1], "\xC2\xB5s/#"); /* mics/# */
         4452  +	TclNewLiteralStringObj(objs[3], "#");
         4453  +	TclNewLiteralStringObj(objs[5], "#/sec");
         4454  +	Tcl_SetObjResult(interp, Tcl_NewListObj(8, objarr));
         4455  +    }
         4456  +
         4457  +done:
         4458  +
         4459  +    if (codePtr != NULL) {
         4460  +	TclReleaseByteCode(codePtr);
         4461  +    }
         4462  +
         4463  +    return result;
         4464  +}
  4081   4465   
  4082   4466   /*
  4083   4467    *----------------------------------------------------------------------
  4084   4468    *
  4085   4469    * Tcl_TryObjCmd, TclNRTryObjCmd --
  4086   4470    *
  4087   4471    *	This procedure is invoked to process the "try" Tcl command. See the

Changes to generic/tclCompExpr.c.

  2016   2016   	    /*
  2017   2017   	     * We have a number followed directly by bareword characters
  2018   2018   	     * (alpha, digit, underscore).  Is this a number followed by
  2019   2019   	     * bareword syntax error?  Or should we join into one bareword?
  2020   2020   	     * Example: Inf + luence + () becomes a valid function call.
  2021   2021   	     * [Bug 3401704]
  2022   2022   	     */
  2023         -	    if (literal->typePtr == &tclDoubleType) {
         2023  +	    if (TclHasIntRep(literal, &tclDoubleType)) {
  2024   2024   		const char *p = start;
  2025   2025   
  2026   2026   		while (p < end) {
  2027   2027   		    if (!TclIsBareword(*p++)) {
  2028   2028   			/*
  2029   2029   			 * The number has non-bareword characters, so we
  2030   2030   			 * must treat it as a number.

Changes to generic/tclEnv.c.

   117    117   
   118    118       if (environ[0] != NULL) {
   119    119   	int i;
   120    120   
   121    121   	Tcl_MutexLock(&envMutex);
   122    122   	for (i = 0; environ[i] != NULL; i++) {
   123    123   	    Tcl_Obj *obj1, *obj2;
   124         -	    char *p1, *p2;
          124  +	    const char *p1;
          125  +	    char *p2;
   125    126   
   126    127   	    p1 = Tcl_ExternalToUtfDString(NULL, environ[i], -1, &envString);
   127    128   	    p2 = strchr(p1, '=');
   128    129   	    if (p2 == NULL) {
   129    130   		/*
   130    131   		 * This condition seem to happen occasionally under some
   131    132   		 * versions of Solaris, or when encoding accidents swallow the
................................................................................
   133    134   		 */
   134    135   
   135    136   		Tcl_DStringFree(&envString);
   136    137   		continue;
   137    138   	    }
   138    139   	    p2++;
   139    140   	    p2[-1] = '\0';
          141  +#if defined(_WIN32)
          142  +	    /*
          143  +	     * Enforce PATH and COMSPEC to be all uppercase. This eliminates
          144  +	     * additional trace logic otherwise required in init.tcl.
          145  +	     */
          146  +
          147  +	    if (strcasecmp(p1, "PATH") == 0) {
          148  +		p1 = "PATH";
          149  +	    } else if (strcasecmp(p1, "COMSPEC") == 0) {
          150  +		p1 = "COMSPEC";
          151  +	    }
          152  +#endif
   140    153   	    obj1 = Tcl_NewStringObj(p1, -1);
   141    154   	    obj2 = Tcl_NewStringObj(p2, -1);
   142    155   	    Tcl_DStringFree(&envString);
   143    156   
   144    157   	    Tcl_IncrRefCount(obj1);
   145    158   	    Tcl_IncrRefCount(obj2);
   146    159   	    Tcl_ObjSetVar2(interp, varNamePtr, obj1, obj2, TCL_GLOBAL_ONLY);

Changes to generic/tclExecute.c.

   437    437    * TclGetNumberFromObj(). The ANSI C "prototype" is:
   438    438    *
   439    439    * MODULE_SCOPE int GetNumberFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
   440    440    *			ClientData *ptrPtr, int *tPtr);
   441    441    */
   442    442   
   443    443   #define GetNumberFromObj(interp, objPtr, ptrPtr, tPtr) \
   444         -    (((objPtr)->typePtr == &tclIntType)					\
          444  +    ((TclHasIntRep((objPtr), &tclIntType))					\
   445    445   	?	(*(tPtr) = TCL_NUMBER_INT,				\
   446    446   		*(ptrPtr) = (void *)				\
   447    447   		    (&((objPtr)->internalRep.wideValue)), TCL_OK) :	\
   448         -    ((objPtr)->typePtr == &tclDoubleType)				\
          448  +    TclHasIntRep((objPtr), &tclDoubleType)				\
   449    449   	?	(((TclIsNaN((objPtr)->internalRep.doubleValue))		\
   450    450   		    ?	(*(tPtr) = TCL_NUMBER_NAN)			\
   451    451   		    :	(*(tPtr) = TCL_NUMBER_DOUBLE)),			\
   452    452   		*(ptrPtr) = (void *)				\
   453    453   		    (&((objPtr)->internalRep.doubleValue)), TCL_OK) :	\
   454    454       (((objPtr)->bytes != NULL) && ((objPtr)->length == 0))		\
   455    455   	? TCL_ERROR :			\
................................................................................
  5273   5273   	value2Ptr = OBJ_UNDER_TOS;	/* Pattern */
  5274   5274   
  5275   5275   	/*
  5276   5276   	 * Check that at least one of the objects is Unicode before promoting
  5277   5277   	 * both.
  5278   5278   	 */
  5279   5279   
  5280         -	if ((valuePtr->typePtr == &tclStringType)
  5281         -		|| (value2Ptr->typePtr == &tclStringType)) {
         5280  +	if (TclHasIntRep(valuePtr, &tclStringType)
         5281  +		|| TclHasIntRep(value2Ptr, &tclStringType)) {
  5282   5282   	    Tcl_UniChar *ustring1, *ustring2;
  5283   5283   
  5284   5284   	    ustring1 = TclGetUnicodeFromObj(valuePtr, &slength);
  5285   5285   	    ustring2 = TclGetUnicodeFromObj(value2Ptr, &length2);
  5286   5286   	    match = TclUniCharMatch(ustring1, slength, ustring2, length2,
  5287   5287   		    nocase);
  5288   5288   	} else if (TclIsPureByteArray(valuePtr) && !nocase) {
................................................................................
  6081   6081       /*
  6082   6082        *	   End of numeric operator instructions.
  6083   6083        * -----------------------------------------------------------------
  6084   6084        */
  6085   6085   
  6086   6086       case INST_TRY_CVT_TO_BOOLEAN:
  6087   6087   	valuePtr = OBJ_AT_TOS;
  6088         -	if (valuePtr->typePtr == &tclBooleanType) {
         6088  +	if (TclHasIntRep(valuePtr,  &tclBooleanType)) {
  6089   6089   	    objResultPtr = TCONST(1);
  6090   6090   	} else {
  6091   6091   	    int result = (TclSetBooleanFromAny(NULL, valuePtr) == TCL_OK);
  6092   6092   	    objResultPtr = TCONST(result);
  6093   6093   	}
  6094   6094   	TRACE_WITH_OBJ(("\"%.30s\" => ", O2S(valuePtr)), objResultPtr);
  6095   6095   	NEXT_INST_F(1, 0, 1);

Changes to generic/tclIndexObj.c.

  1363   1363       Tcl_Obj *value,
  1364   1364       int *codePtr)		/* Argument objects. */
  1365   1365   {
  1366   1366       static const char *const returnCodes[] = {
  1367   1367   	"ok", "error", "return", "break", "continue", NULL
  1368   1368       };
  1369   1369   
  1370         -    if ((value->typePtr != &indexType)
         1370  +    if (!TclHasIntRep(value, &indexType)
  1371   1371   	    && TclGetIntFromObj(NULL, value, codePtr) == TCL_OK) {
  1372   1372   	return TCL_OK;
  1373   1373       }
  1374   1374       if (Tcl_GetIndexFromObj(NULL, value, returnCodes, NULL, TCL_EXACT,
  1375   1375   	    codePtr) == TCL_OK) {
  1376   1376   	return TCL_OK;
  1377   1377       }

Changes to generic/tclInt.h.

  2881   2881   				/* Procedure that unloads a loaded module */
  2882   2882   };
  2883   2883   
  2884   2884   /* Flags for conversion of doubles to digit strings */
  2885   2885   
  2886   2886   #define TCL_DD_SHORTEST 		0x4
  2887   2887   				/* Use the shortest possible string */
  2888         -#define TCL_DD_STEELE   		0x5
  2889         -				/* Use the original Steele&White algorithm */
  2890   2888   #define TCL_DD_E_FORMAT 		0x2
  2891   2889   				/* Use a fixed-length string of digits,
  2892   2890   				 * suitable for E format*/
  2893   2891   #define TCL_DD_F_FORMAT 		0x3
  2894   2892   				/* Use a fixed number of digits after the
  2895   2893   				 * decimal point, suitable for F format */
  2896   2894   
................................................................................
  2898   2896   				/* Allow return of a shorter digit string
  2899   2897   				 * if it converts losslessly */
  2900   2898   #define TCL_DD_NO_QUICK 		0x8
  2901   2899   				/* Debug flag: forbid quick FP conversion */
  2902   2900   
  2903   2901   #define TCL_DD_CONVERSION_TYPE_MASK	0x3
  2904   2902   				/* Mask to isolate the conversion type */
  2905         -#define TCL_DD_STEELE0 			0x1
  2906         -				/* 'Steele&White' after masking */
  2907         -#define TCL_DD_SHORTEST0		0x0
  2908         -				/* 'Shortest possible' after masking */
  2909   2903   
  2910   2904   /*
  2911   2905    *----------------------------------------------------------------
  2912   2906    * Procedures shared among Tcl modules but not used by the outside world:
  2913   2907    *----------------------------------------------------------------
  2914   2908    */
  2915   2909   
................................................................................
  3295   3289   MODULE_SCOPE int	TclpLoadMemory(Tcl_Interp *interp, void *buffer,
  3296   3290   			    int size, int codeSize, Tcl_LoadHandle *loadHandle,
  3297   3291   			    Tcl_FSUnloadFileProc **unloadProcPtr, int flags);
  3298   3292   #endif
  3299   3293   MODULE_SCOPE void	TclInitThreadStorage(void);
  3300   3294   MODULE_SCOPE void	TclFinalizeThreadDataThread(void);
  3301   3295   MODULE_SCOPE void	TclFinalizeThreadStorage(void);
         3296  +
  3302   3297   #ifdef TCL_WIDE_CLICKS
  3303   3298   MODULE_SCOPE Tcl_WideInt TclpGetWideClicks(void);
  3304   3299   MODULE_SCOPE double	TclpWideClicksToNanoseconds(Tcl_WideInt clicks);
         3300  +MODULE_SCOPE double	TclpWideClickInMicrosec(void);
         3301  +#else
         3302  +#   ifdef _WIN32
         3303  +#	define TCL_WIDE_CLICKS 1
         3304  +MODULE_SCOPE Tcl_WideInt TclpGetWideClicks(void);
         3305  +MODULE_SCOPE double	TclpWideClickInMicrosec(void);
         3306  +#	define		TclpWideClicksToNanoseconds(clicks) \
         3307  +				((double)(clicks) * TclpWideClickInMicrosec() * 1000)
         3308  +#   endif
  3305   3309   #endif
         3310  +MODULE_SCOPE Tcl_WideInt TclpGetMicroseconds(void);
         3311  +
  3306   3312   MODULE_SCOPE int	TclZlibInit(Tcl_Interp *interp);
  3307   3313   MODULE_SCOPE void *	TclpThreadCreateKey(void);
  3308   3314   MODULE_SCOPE void	TclpThreadDeleteKey(void *keyPtr);
  3309   3315   MODULE_SCOPE void	TclpThreadSetMasterTSD(void *tsdKeyPtr, void *ptr);
  3310   3316   MODULE_SCOPE void *	TclpThreadGetMasterTSD(void *tsdKeyPtr);
  3311   3317   MODULE_SCOPE void	TclErrorStackResetIf(Tcl_Interp *interp,
  3312   3318   			    const char *msg, size_t length);
................................................................................
  3569   3575   MODULE_SCOPE int	Tcl_TellObjCmd(void *clientData,
  3570   3576   			    Tcl_Interp *interp, int objc,
  3571   3577   			    Tcl_Obj *const objv[]);
  3572   3578   MODULE_SCOPE int	Tcl_ThrowObjCmd(void *dummy, Tcl_Interp *interp,
  3573   3579   			    int objc, Tcl_Obj *const objv[]);
  3574   3580   MODULE_SCOPE int	Tcl_TimeObjCmd(void *clientData,
  3575   3581   			    Tcl_Interp *interp, int objc,
         3582  +			    Tcl_Obj *const objv[]);
         3583  +MODULE_SCOPE int	Tcl_TimeRateObjCmd(void *clientData,
         3584  +			    Tcl_Interp *interp, int objc,
  3576   3585   			    Tcl_Obj *const objv[]);
  3577   3586   MODULE_SCOPE int	Tcl_TraceObjCmd(void *clientData,
  3578   3587   			    Tcl_Interp *interp, int objc,
  3579   3588   			    Tcl_Obj *const objv[]);
  3580   3589   MODULE_SCOPE int	Tcl_TryObjCmd(void *clientData,
  3581   3590   			    Tcl_Interp *interp, int objc,
  3582   3591   			    Tcl_Obj *const objv[]);
................................................................................
  4678   4687    *----------------------------------------------------------------
  4679   4688    */
  4680   4689   
  4681   4690   MODULE_SCOPE int	TclIsPureByteArray(Tcl_Obj *objPtr);
  4682   4691   #define TclIsPureDict(objPtr) \
  4683   4692   	(((objPtr)->bytes==NULL) && ((objPtr)->typePtr==&tclDictType))
  4684   4693   #define TclHasIntRep(objPtr, type) \
  4685         -	((objPtr)->typePtr == (type)) 
         4694  +	((objPtr)->typePtr == (type))
  4686   4695   #define TclFetchIntRep(objPtr, type) \
  4687   4696   	(TclHasIntRep((objPtr), (type)) ? &((objPtr)->internalRep) : NULL)
  4688   4697   
  4689   4698   
  4690   4699   /*
  4691   4700    *----------------------------------------------------------------
  4692   4701    * Macro used by the Tcl core to compare Unicode strings. On big-endian

Changes to generic/tclLink.c.

   731    731    * (upper- and lowercase) and sequences like "1e-". See bug [39f6304c2e].
   732    732    */
   733    733   int
   734    734   GetInvalidDoubleFromObj(Tcl_Obj *objPtr, double *doublePtr)
   735    735   {
   736    736       int intValue;
   737    737   
   738         -    if (objPtr->typePtr == &invalidRealType) {
          738  +    if (TclHasIntRep(objPtr, &invalidRealType)) {
   739    739   	goto gotdouble;
   740    740       }
   741    741       if (GetInvalidIntFromObj(objPtr, &intValue) == TCL_OK) {
   742    742   	*doublePtr = (double) intValue;
   743    743   	return TCL_OK;
   744    744       }
   745    745       if (SetInvalidRealFromAny(NULL, objPtr) == TCL_OK) {

Changes to generic/tclLiteral.c.

   913    913       Namespace *nsPtr)		/* The namespace for which to lookup and
   914    914   				 * invalidate a cmd literal. */
   915    915   {
   916    916       Interp *iPtr = (Interp *) interp;
   917    917       Tcl_Obj *literalObjPtr = CreateLiteral(iPtr, name, strlen(name),
   918    918   	    NULL, nsPtr, 0, NULL);
   919    919   
   920         -    if (literalObjPtr && (literalObjPtr->typePtr == &tclCmdNameType)) {
          920  +    if (literalObjPtr && TclHasIntRep(literalObjPtr, &tclCmdNameType)) {
   921    921   	TclFreeIntRep(literalObjPtr);
   922    922       }
   923    923   }
   924    924   
   925    925   #ifdef TCL_COMPILE_STATS
   926    926   /*
   927    927    *----------------------------------------------------------------------

Changes to generic/tclObj.c.

  2707   2707   	     * Must check for those bignum values that can fit in a long, even
  2708   2708   	     * when auto-narrowing is enabled. Only those values in the signed
  2709   2709   	     * long range get auto-narrowed to tclIntType, while all the
  2710   2710   	     * values in the unsigned long range will fit in a long.
  2711   2711   	     */
  2712   2712   
  2713   2713   	    mp_int big;
         2714  +	    unsigned long scratch, value = 0, numBytes = sizeof(unsigned long);
         2715  +	    unsigned char *bytes = (unsigned char *) &scratch;
  2714   2716   
  2715   2717   	    UNPACK_BIGNUM(objPtr, big);
  2716         -	    if ((size_t) big.used <= (CHAR_BIT * sizeof(unsigned long) + DIGIT_BIT - 1)
  2717         -		    / DIGIT_BIT) {
  2718         -		unsigned long scratch, value = 0, numBytes = sizeof(unsigned long);
  2719         -		unsigned char *bytes = (unsigned char *) &scratch;
  2720         -
  2721         -		if (mp_to_unsigned_bin_n(&big, bytes, &numBytes) == MP_OKAY) {
  2722         -		    while (numBytes-- > 0) {
         2718  +	    if (mp_to_unsigned_bin_n(&big, bytes, &numBytes) == MP_OKAY) {
         2719  +		while (numBytes-- > 0) {
  2723   2720   			value = (value << CHAR_BIT) | *bytes++;
         2721  +		}
         2722  +		if (big.sign) {
         2723  +		    if (value <= 1 + (unsigned long)LONG_MAX) {
         2724  +			*longPtr = - (long) value;
         2725  +			return TCL_OK;
  2724   2726   		    }
  2725         -		    if (big.sign) {
  2726         -			if (value <= 1 + (unsigned long)LONG_MAX) {
  2727         -			    *longPtr = - (long) value;
  2728         -			    return TCL_OK;
  2729         -			}
  2730         -		    } else {
  2731         -			if (value <= (unsigned long)ULONG_MAX) {
  2732         -			    *longPtr = (long) value;
  2733         -			    return TCL_OK;
  2734         -			}
         2727  +		} else {
         2728  +		    if (value <= (unsigned long)ULONG_MAX) {
         2729  +			*longPtr = (long) value;
         2730  +			return TCL_OK;
  2735   2731   		    }
  2736   2732   		}
  2737   2733   	    }
  2738   2734   #ifndef TCL_WIDE_INT_IS_LONG
  2739   2735   	tooLarge:
  2740   2736   #endif
  2741   2737   	    if (interp != NULL) {
................................................................................
  2949   2945   	if (objPtr->typePtr == &tclBignumType) {
  2950   2946   	    /*
  2951   2947   	     * Must check for those bignum values that can fit in a
  2952   2948   	     * Tcl_WideInt, even when auto-narrowing is enabled.
  2953   2949   	     */
  2954   2950   
  2955   2951   	    mp_int big;
         2952  +	    Tcl_WideUInt value = 0;
         2953  +	    unsigned long numBytes = sizeof(Tcl_WideInt);
         2954  +	    Tcl_WideInt scratch;
         2955  +	    unsigned char *bytes = (unsigned char *) &scratch;
  2956   2956   
  2957   2957   	    UNPACK_BIGNUM(objPtr, big);
  2958         -	    if ((size_t) big.used <= (CHAR_BIT * sizeof(Tcl_WideInt)
  2959         -		     + DIGIT_BIT - 1) / DIGIT_BIT) {
  2960         -		Tcl_WideUInt value = 0;
  2961         -		unsigned long numBytes = sizeof(Tcl_WideInt);
  2962         -		Tcl_WideInt scratch;
  2963         -		unsigned char *bytes = (unsigned char *) &scratch;
  2964         -
  2965         -		if (mp_to_unsigned_bin_n(&big, bytes, &numBytes) == MP_OKAY) {
  2966         -		    while (numBytes-- > 0) {
  2967         -			value = (value << CHAR_BIT) | *bytes++;
         2958  +	    if (mp_to_unsigned_bin_n(&big, bytes, &numBytes) == MP_OKAY) {
         2959  +		while (numBytes-- > 0) {
         2960  +		    value = (value << CHAR_BIT) | *bytes++;
         2961  +		}
         2962  +		if (big.sign) {
         2963  +		    if (value <= 1 + ~(Tcl_WideUInt)WIDE_MIN) {
         2964  +			*wideIntPtr = - (Tcl_WideInt) value;
         2965  +			return TCL_OK;
  2968   2966   		    }
  2969         -		    if (big.sign) {
  2970         -			if (value <= 1 + ~(Tcl_WideUInt)WIDE_MIN) {
  2971         -			    *wideIntPtr = - (Tcl_WideInt) value;
  2972         -			    return TCL_OK;
  2973         -			}
  2974         -		    } else {
  2975         -			if (value <= (Tcl_WideUInt)WIDE_MAX) {
  2976         -			    *wideIntPtr = (Tcl_WideInt) value;
  2977         -			    return TCL_OK;
  2978         -			}
         2967  +		} else {
         2968  +		    if (value <= (Tcl_WideUInt)WIDE_MAX) {
         2969  +			*wideIntPtr = (Tcl_WideInt) value;
         2970  +			return TCL_OK;
  2979   2971   		    }
  2980   2972   		}
  2981   2973   	    }
  2982   2974   	    if (interp != NULL) {
  2983   2975   		const char *s = "integer value too large to represent";
  2984   2976   		Tcl_Obj *msg = Tcl_NewStringObj(s, -1);
  2985   2977   
................................................................................
  3408   3400    */
  3409   3401   
  3410   3402   void
  3411   3403   Tcl_SetBignumObj(
  3412   3404       Tcl_Obj *objPtr,		/* Object to set */
  3413   3405       mp_int *bignumValue)	/* Value to store */
  3414   3406   {
         3407  +    Tcl_WideUInt value = 0;
         3408  +    unsigned long numBytes = sizeof(Tcl_WideUInt);
         3409  +    Tcl_WideUInt scratch;
         3410  +    unsigned char *bytes = (unsigned char *) &scratch;
         3411  +
  3415   3412       if (Tcl_IsShared(objPtr)) {
  3416   3413   	Tcl_Panic("%s called with shared object", "Tcl_SetBignumObj");
  3417   3414       }
  3418         -    if ((size_t) bignumValue->used
  3419         -	    <= (CHAR_BIT * sizeof(Tcl_WideUInt) + DIGIT_BIT - 1) / DIGIT_BIT) {
  3420         -	Tcl_WideUInt value = 0;
  3421         -	unsigned long numBytes = sizeof(Tcl_WideUInt);
  3422         -	Tcl_WideUInt scratch;
  3423         -	unsigned char *bytes = (unsigned char *) &scratch;
  3424         -
  3425         -	if (mp_to_unsigned_bin_n(bignumValue, bytes, &numBytes) != MP_OKAY) {
  3426         -	    goto tooLargeForWide;
  3427         -	}
  3428         -	while (numBytes-- > 0) {
  3429         -	    value = (value << CHAR_BIT) | *bytes++;
  3430         -	}
  3431         -	if (value > ((Tcl_WideUInt)WIDE_MAX + bignumValue->sign)) {
  3432         -	    goto tooLargeForWide;
  3433         -	}
  3434         -	if (bignumValue->sign) {
  3435         -	    TclSetIntObj(objPtr, -(Tcl_WideInt)value);
  3436         -	} else {
  3437         -	    TclSetIntObj(objPtr, (Tcl_WideInt)value);
  3438         -	}
  3439         -	mp_clear(bignumValue);
  3440         -	return;
         3415  +    if (mp_to_unsigned_bin_n(bignumValue, bytes, &numBytes) != MP_OKAY) {
         3416  +	goto tooLargeForWide;
  3441   3417       }
         3418  +    while (numBytes-- > 0) {
         3419  +	value = (value << CHAR_BIT) | *bytes++;
         3420  +    }
         3421  +    if (value > ((Tcl_WideUInt)WIDE_MAX + bignumValue->sign)) {
         3422  +	goto tooLargeForWide;
         3423  +    }
         3424  +    if (bignumValue->sign) {
         3425  +	TclSetIntObj(objPtr, -(Tcl_WideInt)value);
         3426  +    } else {
         3427  +	TclSetIntObj(objPtr, (Tcl_WideInt)value);
         3428  +    }
         3429  +    mp_clear(bignumValue);
         3430  +    return;
  3442   3431     tooLargeForWide:
  3443   3432       TclInvalidateStringRep(objPtr);
  3444   3433       TclFreeIntRep(objPtr);
  3445   3434       TclSetBignumIntRep(objPtr, bignumValue);
  3446   3435   }
  3447   3436   
  3448   3437   /*

Changes to generic/tclPkg.c.

    52     52    * For each package that is known in any way to an interpreter, there is one
    53     53    * record of the following type. These records are stored in the
    54     54    * "packageTable" hash table in the interpreter, keyed by package name such as
    55     55    * "Tk" (no version number).
    56     56    */
    57     57   
    58     58   typedef struct {
    59         -    char *version;		/* Version that has been supplied in this
    60         -				 * interpreter via "package provide"
    61         -				 * (malloc'ed). NULL means the package doesn't
    62         -				 * exist in this interpreter yet. */
           59  +    Tcl_Obj *version;
    63     60       PkgAvail *availPtr;		/* First in list of all available versions of
    64     61   				 * this package. */
    65     62       const void *clientData;	/* Client data. */
    66     63   } Package;
    67     64   
    68     65   typedef struct Require {
    69     66       void * clientDataPtr;
................................................................................
   162    159   {
   163    160       Package *pkgPtr;
   164    161       char *pvi, *vi;
   165    162       int res;
   166    163   
   167    164       pkgPtr = FindPackage(interp, name);
   168    165       if (pkgPtr->version == NULL) {
   169         -	DupString(pkgPtr->version, version);
          166  +	pkgPtr->version = Tcl_NewStringObj(version, -1);
          167  +	Tcl_IncrRefCount(pkgPtr->version);
   170    168   	pkgPtr->clientData = clientData;
   171    169   	return TCL_OK;
   172    170       }
   173    171   
   174         -    if (CheckVersionAndConvert(interp, pkgPtr->version, &pvi,
          172  +    if (CheckVersionAndConvert(interp, Tcl_GetString(pkgPtr->version), &pvi,
   175    173   	    NULL) != TCL_OK) {
   176    174   	return TCL_ERROR;
   177    175       } else if (CheckVersionAndConvert(interp, version, &vi, NULL) != TCL_OK) {
   178    176   	Tcl_Free(pvi);
   179    177   	return TCL_ERROR;
   180    178       }
   181    179   
................................................................................
   187    185   	if (clientData != NULL) {
   188    186   	    pkgPtr->clientData = clientData;
   189    187   	}
   190    188   	return TCL_OK;
   191    189       }
   192    190       Tcl_SetObjResult(interp, Tcl_ObjPrintf(
   193    191   	    "conflicting versions provided for package \"%s\": %s, then %s",
   194         -	    name, pkgPtr->version, version));
          192  +	    name, Tcl_GetString(pkgPtr->version), version));
   195    193       Tcl_SetErrorCode(interp, "TCL", "PACKAGE", "VERSIONCONFLICT", NULL);
   196    194       return TCL_ERROR;
   197    195   }
   198    196   
   199    197   /*
   200    198    *----------------------------------------------------------------------
   201    199    *
................................................................................
   380    378   
   381    379       /*
   382    380        * Translate between old and new API, and defer to the new function.
   383    381        */
   384    382   
   385    383       if (version == NULL) {
   386    384   	if (Tcl_PkgRequireProc(interp, name, 0, NULL, clientDataPtr) == TCL_OK) {
   387         -	    result = Tcl_GetStringResult(interp);
          385  +	    result = Tcl_GetString(Tcl_GetObjResult(interp));
   388    386   	    Tcl_ResetResult(interp);
   389    387   	}
   390    388       } else {
   391    389   	if (exact && TCL_OK
   392    390   		!= CheckVersionAndConvert(interp, version, NULL, NULL)) {
   393    391   	    return NULL;
   394    392   	}
   395    393   	ov = Tcl_NewStringObj(version, -1);
   396    394   	if (exact) {
   397    395   	    Tcl_AppendStringsToObj(ov, "-", version, NULL);
   398    396   	}
   399    397   	Tcl_IncrRefCount(ov);
   400    398   	if (Tcl_PkgRequireProc(interp, name, 1, &ov, clientDataPtr) == TCL_OK) {
   401         -	    result = Tcl_GetStringResult(interp);
          399  +	    result = Tcl_GetString(Tcl_GetObjResult(interp));
   402    400   	    Tcl_ResetResult(interp);
   403    401   	}
   404    402   	TclDecrRefCount(ov);
   405    403       }
   406    404       return result;
   407    405   }
   408    406   
................................................................................
   536    534       }
   537    535   
   538    536       /*
   539    537        * Ensure that the provided version meets the current requirements.
   540    538        */
   541    539   
   542    540       if (reqc != 0) {
   543         -	CheckVersionAndConvert(interp, reqPtr->pkgPtr->version, &pkgVersionI, NULL);
          541  +	CheckVersionAndConvert(interp, Tcl_GetString(reqPtr->pkgPtr->version),
          542  +		&pkgVersionI, NULL);
   544    543   	satisfies = SomeRequirementSatisfied(pkgVersionI, reqc, reqv);
   545    544   
   546    545   	Tcl_Free(pkgVersionI);
   547    546   
   548    547   	if (!satisfies) {
   549    548   	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
   550    549   		    "version conflict for package \"%s\": have %s, need",
   551         -		    name, reqPtr->pkgPtr->version));
          550  +		    name, Tcl_GetString(reqPtr->pkgPtr->version)));
   552    551   	    Tcl_SetErrorCode(interp, "TCL", "PACKAGE", "VERSIONCONFLICT",
   553    552   		    NULL);
   554    553   	    AddRequirementsToResult(interp, reqc, reqv);
   555    554   	    return TCL_ERROR;
   556    555   	}
   557    556       }
   558    557   
   559    558       if (clientDataPtr) {
   560    559   	const void **ptr = (const void **) clientDataPtr;
   561    560   
   562    561   	*ptr = reqPtr->pkgPtr->clientData;
   563    562       }
   564         -    Tcl_SetObjResult(interp, Tcl_NewStringObj(reqPtr->pkgPtr->version, -1));
          563  +    Tcl_SetObjResult(interp, reqPtr->pkgPtr->version);
   565    564       return TCL_OK;
   566    565   }
   567    566   
   568    567   static int
   569    568   PkgRequireCoreCleanup(ClientData data[], Tcl_Interp *interp, int result) {
   570    569       Tcl_Free(data[0]);
   571    570       return result;
................................................................................
   774    773   		    " no version of package %s provided",
   775    774   		    name, versionToProvide, name));
   776    775   	    Tcl_SetErrorCode(interp, "TCL", "PACKAGE", "UNPROVIDED",
   777    776   		    NULL);
   778    777   	} else {
   779    778   	    char *pvi, *vi;
   780    779   
   781         -	    if (CheckVersionAndConvert(interp, reqPtr->pkgPtr->version, &pvi,
   782         -		    NULL) != TCL_OK) {
          780  +	    if (TCL_OK != CheckVersionAndConvert(interp,
          781  +		    Tcl_GetString(reqPtr->pkgPtr->version), &pvi, NULL)) {
   783    782   		result = TCL_ERROR;
   784    783   	    } else if (CheckVersionAndConvert(interp,
   785    784   		    versionToProvide, &vi, NULL) != TCL_OK) {
   786    785   		Tcl_Free(pvi);
   787    786   		result = TCL_ERROR;
   788    787   	    } else {
   789    788   		int res = CompareVersions(pvi, vi, NULL);
................................................................................
   792    791   		Tcl_Free(vi);
   793    792   		if (res != 0) {
   794    793   		    result = TCL_ERROR;
   795    794   		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
   796    795   			    "attempt to provide package %s %s failed:"
   797    796   			    " package %s %s provided instead",
   798    797   			    name, versionToProvide,
   799         -			    name, reqPtr->pkgPtr->version));
          798  +			    name, Tcl_GetString(reqPtr->pkgPtr->version)));
   800    799   		    Tcl_SetErrorCode(interp, "TCL", "PACKAGE",
   801    800   			    "WRONGPROVIDE", NULL);
   802    801   		}
   803    802   	    }
   804    803   	}
   805    804       } else if (result != TCL_ERROR) {
   806    805   	Tcl_Obj *codePtr = Tcl_NewIntObj(result);
................................................................................
   830    829   	 * This is consistent with our returning NULL. If we're not
   831    830   	 * willing to tell our caller we got a particular version, we
   832    831   	 * shouldn't store that version for telling future callers
   833    832   	 * either.
   834    833   	 */
   835    834   
   836    835   	if (reqPtr->pkgPtr->version != NULL) {
   837         -	    Tcl_Free(reqPtr->pkgPtr->version);
          836  +	    Tcl_DecrRefCount(reqPtr->pkgPtr->version);
   838    837   	    reqPtr->pkgPtr->version = NULL;
   839    838   	}
   840    839   	reqPtr->pkgPtr->clientData = NULL;
   841    840   	return result;
   842    841       }
   843    842   
   844    843       Tcl_NRAddCallback(interp, data[3], reqPtr, INT2PTR(reqc), (void *)reqv, NULL);
................................................................................
  1032   1031   	    hPtr = Tcl_FindHashEntry(&iPtr->packageTable, keyString);
  1033   1032   	    if (hPtr == NULL) {
  1034   1033   		continue;
  1035   1034   	    }
  1036   1035   	    pkgPtr = Tcl_GetHashValue(hPtr);
  1037   1036   	    Tcl_DeleteHashEntry(hPtr);
  1038   1037   	    if (pkgPtr->version != NULL) {
  1039         -		Tcl_Free(pkgPtr->version);
         1038  +		Tcl_DecrRefCount(pkgPtr->version);
  1040   1039   	    }
  1041   1040   	    while (pkgPtr->availPtr != NULL) {
  1042   1041   		availPtr = pkgPtr->availPtr;
  1043   1042   		pkgPtr->availPtr = availPtr->nextPtr;
  1044   1043   		Tcl_EventuallyFree(availPtr->version, TCL_DYNAMIC);
  1045   1044   		Tcl_EventuallyFree(availPtr->script, TCL_DYNAMIC);
  1046   1045   		if (availPtr->pkgIndex) {
................................................................................
  1204   1203   	}
  1205   1204   	argv2 = TclGetString(objv[2]);
  1206   1205   	if (objc == 3) {
  1207   1206   	    hPtr = Tcl_FindHashEntry(&iPtr->packageTable, argv2);
  1208   1207   	    if (hPtr != NULL) {
  1209   1208   		pkgPtr = Tcl_GetHashValue(hPtr);
  1210   1209   		if (pkgPtr->version != NULL) {
  1211         -		    Tcl_SetObjResult(interp,
  1212         -			    Tcl_NewStringObj(pkgPtr->version, -1));
         1210  +		    Tcl_SetObjResult(interp, pkgPtr->version);
  1213   1211   		}
  1214   1212   	    }
  1215   1213   	    return TCL_OK;
  1216   1214   	}
  1217   1215   	argv3 = TclGetString(objv[3]);
  1218   1216   	if (CheckVersionAndConvert(interp, argv3, NULL, NULL) != TCL_OK) {
  1219   1217   	    return TCL_ERROR;
................................................................................
  1498   1496       Tcl_HashEntry *hPtr;
  1499   1497       PkgAvail *availPtr;
  1500   1498   
  1501   1499       for (hPtr = Tcl_FirstHashEntry(&iPtr->packageTable, &search);
  1502   1500   	    hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
  1503   1501   	pkgPtr = Tcl_GetHashValue(hPtr);
  1504   1502   	if (pkgPtr->version != NULL) {
  1505         -	    Tcl_Free(pkgPtr->version);
         1503  +	    Tcl_DecrRefCount(pkgPtr->version);
  1506   1504   	}
  1507   1505   	while (pkgPtr->availPtr != NULL) {
  1508   1506   	    availPtr = pkgPtr->availPtr;
  1509   1507   	    pkgPtr->availPtr = availPtr->nextPtr;
  1510   1508   	    Tcl_EventuallyFree(availPtr->version, TCL_DYNAMIC);
  1511   1509   	    Tcl_EventuallyFree(availPtr->script, TCL_DYNAMIC);
  1512   1510   	    if (availPtr->pkgIndex) {

Changes to generic/tclScan.c.

   877    877   	case 'c':
   878    878   	    /*
   879    879   	     * Scan a single Unicode character.
   880    880   	     */
   881    881   
   882    882   	    offset = TclUtfToUniChar(string, &sch);
   883    883   	    i = (int)sch;
   884         -#if TCL_UTF_MAX == 4
   885         -	    if (((sch & 0xFC00) == 0xD800) && (offset < 3)) {
          884  +#if TCL_UTF_MAX <= 4
          885  +	    if ((sch >= 0xD800) && (offset < 3)) {
   886    886   		offset += TclUtfToUniChar(string+offset, &sch);
   887    887   		i = (((i<<10) & 0x0FFC00) + 0x10000) + (sch & 0x3FF);
   888    888   	    }
   889    889   #endif
   890    890   	    string += offset;
   891    891   	    if (!(flags & SCAN_SUPPRESS)) {
   892    892   		objPtr = Tcl_NewWideIntObj(i);

Changes to generic/tclStrToD.c.

   316    316   static char *		ShorteningQuickFormat(double, int, int, double,
   317    317   			    char *, int *);
   318    318   static char *		StrictQuickFormat(double, int, int, double,
   319    319   			    char *, int *);
   320    320   static char *		QuickConversion(double, int, int, int, int, int, int,
   321    321   			    int *, char **);
   322    322   static void		CastOutPowersOf2(int *, int *, int *);
   323         -static char *		ShorteningInt64Conversion(Double *, int, Tcl_WideUInt,
          323  +static char *		ShorteningInt64Conversion(Double *, Tcl_WideUInt,
   324    324   			    int, int, int, int, int, int, int, int, int,
   325    325   			    int, int, int *, char **);
   326         -static char *		StrictInt64Conversion(Double *, int, Tcl_WideUInt,
          326  +static char *		StrictInt64Conversion(Double *, Tcl_WideUInt,
   327    327   			    int, int, int, int, int, int,
   328    328   			    int, int, int *, char **);
   329    329   static int		ShouldBankerRoundUpPowD(mp_int *, int, int);
   330    330   static int		ShouldBankerRoundUpToNextPowD(mp_int *, mp_int *,
   331         -			    int, int, int, mp_int *);
          331  +			    int, int, mp_int *);
   332    332   static char *		ShorteningBignumConversionPowD(Double *dPtr,
   333         -			    int convType, Tcl_WideUInt bw, int b2, int b5,
          333  +			    Tcl_WideUInt bw, int b2, int b5,
   334    334   			    int m2plus, int m2minus, int m5,
   335    335   			    int sd, int k, int len,
   336    336   			    int ilim, int ilim1, int *decpt,
   337    337   			    char **endPtr);
   338         -static char *		StrictBignumConversionPowD(Double *dPtr, int convType,
          338  +static char *		StrictBignumConversionPowD(Double *dPtr,
   339    339   			    Tcl_WideUInt bw, int b2, int b5,
   340    340   			    int sd, int k, int len,
   341    341   			    int ilim, int ilim1, int *decpt,
   342    342   			    char **endPtr);
   343    343   static int		ShouldBankerRoundUp(mp_int *, mp_int *, int);
   344    344   static int		ShouldBankerRoundUpToNext(mp_int *, mp_int *,
   345         -			    mp_int *, int, int, mp_int *);
   346         -static char *		ShorteningBignumConversion(Double *dPtr, int convType,
          345  +			    mp_int *, int);
          346  +static char *		ShorteningBignumConversion(Double *dPtr,
   347    347   			    Tcl_WideUInt bw, int b2,
   348    348   			    int m2plus, int m2minus,
   349    349   			    int s2, int s5, int k, int len,
   350    350   			    int ilim, int ilim1, int *decpt,
   351    351   			    char **endPtr);
   352         -static char *		StrictBignumConversion(Double *dPtr, int convType,
          352  +static char *		StrictBignumConversion(Double *dPtr,
   353    353   			    Tcl_WideUInt bw, int b2,
   354    354   			    int s2, int s5, int k, int len,
   355    355   			    int ilim, int ilim1, int *decpt,
   356    356   			    char **endPtr);
   357    357   static double		BignumToBiasedFrExp(const mp_int *big, int *machexp);
   358    358   static double		Pow10TimesFrExp(int exponent, double fraction,
   359    359   			    int *machexp);
................................................................................
   535    535       /*
   536    536        * Initialize bytes to start of the object's string rep if the caller
   537    537        * didn't pass anything else.
   538    538        */
   539    539   
   540    540       if (bytes == NULL) {
   541    541   	if (interp == NULL && endPtrPtr == NULL) {
   542         -	    if (objPtr->typePtr == &tclDictType) {
          542  +	    if (TclHasIntRep(objPtr, &tclDictType)) {
   543    543   		/* A dict can never be a (single) number */
   544    544   		return TCL_ERROR;
   545    545   	    }
   546         -	    if (objPtr->typePtr == &tclListType) {
          546  +	    if (TclHasIntRep(objPtr, &tclListType)) {
   547    547   		int length;
   548    548   		/* A list can only be a (single) number if its length == 1 */
   549    549   		TclListObjLength(NULL, objPtr, &length);
   550    550   		if (length != 1) {
   551    551   		    return TCL_ERROR;
   552    552   		}
   553    553   	    }
................................................................................
  2351   2351    *	one too high.
  2352   2352    *
  2353   2353    *----------------------------------------------------------------------
  2354   2354    */
  2355   2355   
  2356   2356   static inline void
  2357   2357   SetPrecisionLimits(
  2358         -    int convType,		/* Type of conversion: TCL_DD_SHORTEST,
  2359         -				 * TCL_DD_STEELE0, TCL_DD_E_FMT,
  2360         -				 * TCL_DD_F_FMT. */
         2358  +    int flags,		/* Type of conversion: TCL_DD_SHORTEST,
         2359  +				 * TCL_DD_E_FMT, TCL_DD_F_FMT. */
  2361   2360       int k,			/* Floor(log10(number to convert)) */
  2362   2361       int *ndigitsPtr,		/* IN/OUT: Number of digits requested (will be
  2363   2362   				 *         adjusted if needed). */
  2364   2363       int *iPtr,			/* OUT: Maximum number of digits to return. */
  2365   2364       int *iLimPtr,		/* OUT: Number of digits of significance if
  2366   2365   				 *      the bignum method is used.*/
  2367   2366       int *iLim1Ptr)		/* OUT: Number of digits of significance if
  2368   2367   				 *      the quick method is used. */
  2369   2368   {
  2370         -    switch (convType) {
  2371         -    case TCL_DD_SHORTEST0:
  2372         -    case TCL_DD_STEELE0:
  2373         -	*iLimPtr = *iLim1Ptr = -1;
  2374         -	*iPtr = 18;
  2375         -	*ndigitsPtr = 0;
  2376         -	break;
         2369  +    switch (flags & TCL_DD_CONVERSION_TYPE_MASK) {
  2377   2370       case TCL_DD_E_FORMAT:
  2378   2371   	if (*ndigitsPtr <= 0) {
  2379   2372   	    *ndigitsPtr = 1;
  2380   2373   	}
  2381   2374   	*iLimPtr = *iLim1Ptr = *iPtr = *ndigitsPtr;
  2382   2375   	break;
  2383   2376       case TCL_DD_F_FORMAT:
................................................................................
  2385   2378   	*iLimPtr = *iPtr;
  2386   2379   	*iLim1Ptr = *iPtr - 1;
  2387   2380   	if (*iPtr <= 0) {
  2388   2381   	    *iPtr = 1;
  2389   2382   	}
  2390   2383   	break;
  2391   2384       default:
  2392         -	*iPtr = -1;
  2393         -	*iLimPtr = -1;
  2394         -	*iLim1Ptr = -1;
  2395         -	Tcl_Panic("impossible conversion type in TclDoubleDigits");
         2385  +	*iLimPtr = *iLim1Ptr = -1;
         2386  +	*iPtr = 18;
         2387  +	*ndigitsPtr = 0;
         2388  +	break;
  2396   2389       }
  2397   2390   }
  2398   2391   
  2399   2392   /*
  2400   2393    *----------------------------------------------------------------------
  2401   2394    *
  2402   2395    * BumpUp --
................................................................................
  2818   2811    *
  2819   2812    *----------------------------------------------------------------------
  2820   2813    */
  2821   2814   
  2822   2815   static inline char *
  2823   2816   ShorteningInt64Conversion(
  2824   2817       Double *dPtr,		/* Original number to convert. */
  2825         -    int convType,		/* Type of conversion (shortest, Steele,
  2826         -				 * E format, F format). */
  2827   2818       Tcl_WideUInt bw,		/* Integer significand. */
  2828   2819       int b2, int b5,		/* Scale factor for the significand in the
  2829   2820   				 * numerator. */
  2830   2821       int m2plus, int m2minus, int m5,
  2831   2822   				/* Scale factors for 1/2 ulp in the numerator
  2832   2823   				 * (will be different if bw == 1. */
  2833   2824       int s2, int s5,		/* Scale factors for the denominator. */
................................................................................
  2886   2877   
  2887   2878   	/*
  2888   2879   	 * Does the current digit put us on the low side of the exact value
  2889   2880   	 * but within within roundoff of being exact?
  2890   2881   	 */
  2891   2882   
  2892   2883   	if (b < mplus || (b == mplus
  2893         -		&& convType != TCL_DD_STEELE0 && (dPtr->w.word1 & 1) == 0)) {
         2884  +		&& (dPtr->w.word1 & 1) == 0)) {
  2894   2885   	    /*
  2895   2886   	     * Make sure we shouldn't be rounding *up* instead, in case the
  2896   2887   	     * next number above is closer.
  2897   2888   	     */
  2898   2889   
  2899   2890   	    if (2 * b > S || (2 * b == S && (digit & 1) != 0)) {
  2900   2891   		++digit;
................................................................................
  2915   2906   
  2916   2907   	/*
  2917   2908   	 * Does one plus the current digit put us within roundoff of the
  2918   2909   	 * number?
  2919   2910   	 */
  2920   2911   
  2921   2912   	if (b > S - mminus || (b == S - mminus
  2922         -		&& convType != TCL_DD_STEELE0 && (dPtr->w.word1 & 1) == 0)) {
         2913  +		&& (dPtr->w.word1 & 1) == 0)) {
  2923   2914   	    if (digit == 9) {
  2924   2915   		*s++ = '9';
  2925   2916   		s = BumpUp(s, retval, &k);
  2926   2917   		break;
  2927   2918   	    }
  2928   2919   	    ++digit;
  2929   2920   	    *s++ = '0' + digit;
................................................................................
  2987   2978    *
  2988   2979    *----------------------------------------------------------------------
  2989   2980    */
  2990   2981   
  2991   2982   static inline char *
  2992   2983   StrictInt64Conversion(
  2993   2984       Double *dPtr,		/* Original number to convert. */
  2994         -    int convType,		/* Type of conversion (shortest, Steele,
  2995         -				 * E format, F format). */
  2996   2985       Tcl_WideUInt bw,		/* Integer significand. */
  2997   2986       int b2, int b5,		/* Scale factor for the significand in the
  2998   2987   				 * numerator. */
  2999   2988       int s2, int s5,		/* Scale factors for the denominator. */
  3000   2989       int k,			/* Number of output digits before the decimal
  3001   2990   				 * point. */
  3002   2991       int len,			/* Number of digits to allocate. */
................................................................................
  3097   3086   static inline int
  3098   3087   ShouldBankerRoundUpPowD(
  3099   3088       mp_int *b,			/* Numerator of the fraction. */
  3100   3089       int sd,			/* Denominator is 2**(sd*DIGIT_BIT). */
  3101   3090       int isodd)			/* 1 if the digit is odd, 0 if even. */
  3102   3091   {
  3103   3092       int i;
  3104         -    static const mp_digit topbit = 1 << (DIGIT_BIT - 1);
         3093  +    static const mp_digit topbit = ((mp_digit)1) << (DIGIT_BIT - 1);
  3105   3094   
  3106   3095       if (b->used < sd || (b->dp[sd-1] & topbit) == 0) {
  3107   3096   	return 0;
  3108   3097       }
  3109   3098       if (b->dp[sd-1] != topbit) {
  3110   3099   	return 1;
  3111   3100       }
................................................................................
  3133   3122    */
  3134   3123   
  3135   3124   static inline int
  3136   3125   ShouldBankerRoundUpToNextPowD(
  3137   3126       mp_int *b,			/* Numerator of the fraction. */
  3138   3127       mp_int *m,			/* Numerator of the rounding tolerance. */
  3139   3128       int sd,			/* Common denominator is 2**(sd*DIGIT_BIT). */
  3140         -    int convType,		/* Conversion type: STEELE defeats
  3141         -				 * round-to-even (not sure why one wants to do
  3142         -				 * this; I copied it from Gay). FIXME */
  3143   3129       int isodd,			/* 1 if the integer significand is odd. */
  3144   3130       mp_int *temp)		/* Work area for the calculation. */
  3145   3131   {
  3146   3132       int i;
  3147   3133   
  3148   3134       /*
  3149   3135        * Compare B and S-m - which is the same as comparing B+m and S - which we
................................................................................
  3161   3147       }
  3162   3148       for (i = sd-1; i >= 0; --i) {
  3163   3149   				/* Check for ==s */
  3164   3150   	if (temp->dp[i] != 0) {	/* > s */
  3165   3151   	    return 1;
  3166   3152   	}
  3167   3153       }
  3168         -    if (convType == TCL_DD_STEELE0) {
  3169         -				/* Biased rounding. */
  3170         -	return 0;
  3171         -    }
  3172   3154       return isodd;
  3173   3155   }
  3174   3156   
  3175   3157   /*
  3176   3158    *----------------------------------------------------------------------
  3177   3159    *
  3178   3160    * ShorteningBignumConversionPowD --
................................................................................
  3194   3176    *
  3195   3177    *----------------------------------------------------------------------
  3196   3178    */
  3197   3179   
  3198   3180   static inline char *
  3199   3181   ShorteningBignumConversionPowD(
  3200   3182       Double *dPtr,		/* Original number to convert. */
  3201         -    int convType,		/* Type of conversion (shortest, Steele,
  3202         -				 * E format, F format). */
  3203   3183       Tcl_WideUInt bw,		/* Integer significand. */
  3204   3184       int b2, int b5,		/* Scale factor for the significand in the
  3205   3185   				 * numerator. */
  3206   3186       int m2plus, int m2minus, int m5,
  3207   3187   				/* Scale factors for 1/2 ulp in the numerator
  3208   3188   				 * (will be different if bw == 1). */
  3209   3189       int sd,			/* Scale factor for the denominator. */
................................................................................
  3281   3261   	/*
  3282   3262   	 * Does the current digit put us on the low side of the exact value
  3283   3263   	 * but within within roundoff of being exact?
  3284   3264   	 */
  3285   3265   
  3286   3266   	r1 = mp_cmp_mag(&b, (m2plus > m2minus)? &mplus : &mminus);
  3287   3267   	if (r1 == MP_LT || (r1 == MP_EQ
  3288         -		&& convType != TCL_DD_STEELE0 && (dPtr->w.word1 & 1) == 0)) {
         3268  +		&& (dPtr->w.word1 & 1) == 0)) {
  3289   3269   	    /*
  3290   3270   	     * Make sure we shouldn't be rounding *up* instead, in case the
  3291   3271   	     * next number above is closer.
  3292   3272   	     */
  3293   3273   
  3294   3274   	    if (ShouldBankerRoundUpPowD(&b, sd, digit&1)) {
  3295   3275   		++digit;
................................................................................
  3309   3289   	}
  3310   3290   
  3311   3291   	/*
  3312   3292   	 * Does one plus the current digit put us within roundoff of the
  3313   3293   	 * number?
  3314   3294   	 */
  3315   3295   
  3316         -	if (ShouldBankerRoundUpToNextPowD(&b, &mminus, sd, convType,
         3296  +	if (ShouldBankerRoundUpToNextPowD(&b, &mminus, sd,
  3317   3297   		dPtr->w.word1 & 1, &temp)) {
  3318   3298   	    if (digit == 9) {
  3319   3299   		*s++ = '9';
  3320   3300   		s = BumpUp(s, retval, &k);
  3321   3301   		break;
  3322   3302   	    }
  3323   3303   	    ++digit;
................................................................................
  3387   3367    *
  3388   3368    *----------------------------------------------------------------------
  3389   3369    */
  3390   3370   
  3391   3371   static inline char *
  3392   3372   StrictBignumConversionPowD(
  3393   3373       Double *dPtr,		/* Original number to convert. */
  3394         -    int convType,		/* Type of conversion (shortest, Steele,
  3395         -				 * E format, F format). */
  3396   3374       Tcl_WideUInt bw,		/* Integer significand. */
  3397   3375       int b2, int b5,		/* Scale factor for the significand in the
  3398   3376   				 * numerator. */
  3399   3377       int sd,			/* Scale factor for the denominator. */
  3400   3378       int k,			/* Number of output digits before the decimal
  3401   3379   				 * point. */
  3402   3380       int len,			/* Number of digits to allocate. */
................................................................................
  3409   3387       char *retval = Tcl_Alloc(len + 1);
  3410   3388   				/* Output buffer. */
  3411   3389       mp_int b;			/* Numerator of the fraction being
  3412   3390   				 * converted. */
  3413   3391       mp_digit digit;		/* Current output digit. */
  3414   3392       char *s = retval;		/* Cursor in the output buffer. */
  3415   3393       int i;			/* Index in the output buffer. */
  3416         -    mp_int temp;
  3417   3394   
  3418   3395       /*
  3419   3396        * b = bw * 2**b2 * 5**b5
  3420   3397        */
  3421   3398   
  3422   3399       TclInitBignumFromWideUInt(&b, bw);
  3423   3400       MulPow5(&b, b5, &b);
................................................................................
  3428   3405        */
  3429   3406   
  3430   3407       if (b.used <= sd) {
  3431   3408   	mp_mul_d(&b, 10, &b);
  3432   3409   	ilim = ilim1;
  3433   3410   	--k;
  3434   3411       }
  3435         -    mp_init(&temp);
  3436   3412   
  3437   3413       /*
  3438   3414        * Loop through the digits. Do division and mod by s == 2**(sd*DIGIT_BIT)
  3439   3415        * by mp_digit extraction.
  3440   3416        */
  3441   3417   
  3442   3418       i = 1;
................................................................................
  3477   3453       }
  3478   3454   
  3479   3455       /*
  3480   3456        * Endgame - store the location of the decimal point and the end of the
  3481   3457        * string.
  3482   3458        */
  3483   3459   
  3484         -    mp_clear_multi(&b, &temp, NULL);
         3460  +    mp_clear(&b);
  3485   3461       *s = '\0';
  3486   3462       *decpt = k;
  3487   3463       if (endPtr) {
  3488   3464   	*endPtr = s;
  3489   3465       }
  3490   3466       return retval;
  3491   3467   }
................................................................................
  3541   3517   
  3542   3518   static inline int
  3543   3519   ShouldBankerRoundUpToNext(
  3544   3520       mp_int *b,			/* Remainder from the division that produced
  3545   3521   				 * the last digit. */
  3546   3522       mp_int *m,			/* Numerator of the rounding tolerance. */
  3547   3523       mp_int *S,			/* Denominator. */
  3548         -    int convType,		/* Conversion type: STEELE0 defeats
  3549         -				 * round-to-even. (Not sure why one would want
  3550         -				 * this; I coped it from Gay). FIXME */
  3551         -    int isodd,			/* 1 if the integer significand is odd. */
  3552         -    mp_int *temp)		/* Work area needed for the calculation. */
         3524  +    int isodd)			/* 1 if the integer significand is odd. */
  3553   3525   {
  3554   3526       int r;
         3527  +    mp_int temp;
  3555   3528   
  3556   3529       /*
  3557   3530        * Compare b and S-m: this is the same as comparing B+m and S.
  3558   3531        */
  3559   3532   
  3560         -    mp_add(b, m, temp);
  3561         -    r = mp_cmp_mag(temp, S);
         3533  +    mp_init(&temp);
         3534  +    mp_add(b, m, &temp);
         3535  +    r = mp_cmp_mag(&temp, S);
         3536  +    mp_clear(&temp);
  3562   3537       switch(r) {
  3563   3538       case MP_LT:
  3564   3539   	return 0;
  3565   3540       case MP_EQ:
  3566         -	if (convType == TCL_DD_STEELE0) {
  3567         -	    return 0;
  3568         -	} else {
  3569         -	    return isodd;
  3570         -	}
         3541  +	return isodd;
  3571   3542       case MP_GT:
  3572   3543   	return 1;
  3573   3544       }
  3574   3545       Tcl_Panic("in ShouldBankerRoundUpToNext, trichotomy fails!");
  3575   3546       return 0;
  3576   3547   }
  3577   3548   
................................................................................
  3592   3563    *
  3593   3564    *----------------------------------------------------------------------
  3594   3565    */
  3595   3566   
  3596   3567   static inline char *
  3597   3568   ShorteningBignumConversion(
  3598   3569       Double *dPtr,		/* Original number being converted. */
  3599         -    int convType,		/* Conversion type. */
  3600   3570       Tcl_WideUInt bw,		/* Integer significand and exponent. */
  3601   3571       int b2,			/* Scale factor for the significand. */
  3602   3572       int m2plus, int m2minus,	/* Scale factors for 1/2 ulp in numerator. */
  3603   3573       int s2, int s5,		/* Scale factors for denominator. */
  3604   3574       int k,			/* Guessed position of the decimal point. */
  3605   3575       int len,			/* Size of the digit buffer to allocate. */
  3606   3576       int ilim,			/* Number of digits to convert if b >= s */
................................................................................
  3613   3583       char *s = retval;		/* Cursor in the return value. */
  3614   3584       mp_int b;			/* Numerator of the result. */
  3615   3585       mp_int mminus;		/* 1/2 ulp below the result. */
  3616   3586       mp_int mplus;		/* 1/2 ulp above the result. */
  3617   3587       mp_int S;			/* Denominator of the result. */
  3618   3588       mp_int dig;			/* Current digit of the result. */
  3619   3589       int digit;			/* Current digit of the result. */
  3620         -    mp_int temp;		/* Work area. */
  3621   3590       int minit = 1;		/* Fudge factor for when we misguess k. */
  3622   3591       int i;
  3623   3592       int r1;
  3624   3593   
  3625   3594       /*
  3626   3595        * b = bw * 2**b2 * 5**b5
  3627   3596        * S = 2**s2 * 5*s5
................................................................................
  3649   3618   
  3650   3619       mp_init_set_int(&mminus, minit);
  3651   3620       mp_mul_2d(&mminus, m2minus, &mminus);
  3652   3621       if (m2plus > m2minus) {
  3653   3622   	mp_init_copy(&mplus, &mminus);
  3654   3623   	mp_mul_2d(&mplus, m2plus-m2minus, &mplus);
  3655   3624       }
  3656         -    mp_init(&temp);
  3657   3625   
  3658   3626       /*
  3659   3627        * Loop through the digits.
  3660   3628        */
  3661   3629   
  3662   3630       mp_init(&dig);
  3663   3631       i = 1;
................................................................................
  3670   3638   
  3671   3639   	/*
  3672   3640   	 * Does the current digit leave us with a remainder small enough to
  3673   3641   	 * round to it?
  3674   3642   	 */
  3675   3643   
  3676   3644   	r1 = mp_cmp_mag(&b, (m2plus > m2minus)? &mplus : &mminus);
  3677         -	if (r1 == MP_LT || (r1 == MP_EQ
  3678         -		&& convType != TCL_DD_STEELE0 && (dPtr->w.word1 & 1) == 0)) {
         3645  +	if (r1 == MP_LT || (r1 == MP_EQ && (dPtr->w.word1 & 1) == 0)) {
  3679   3646   	    mp_mul_2d(&b, 1, &b);
  3680   3647   	    if (ShouldBankerRoundUp(&b, &S, digit&1)) {
  3681   3648   		++digit;
  3682   3649   		if (digit == 10) {
  3683   3650   		    *s++ = '9';
  3684   3651   		    s = BumpUp(s, retval, &k);
  3685   3652   		    break;
................................................................................
  3690   3657   	}
  3691   3658   
  3692   3659   	/*
  3693   3660   	 * Does the current digit leave us with a remainder large enough to
  3694   3661   	 * commit to rounding up to the next higher digit?
  3695   3662   	 */
  3696   3663   
  3697         -	if (ShouldBankerRoundUpToNext(&b, &mminus, &S, convType,
  3698         -		dPtr->w.word1 & 1, &temp)) {
         3664  +	if (ShouldBankerRoundUpToNext(&b, &mminus, &S,
         3665  +		dPtr->w.word1 & 1)) {
  3699   3666   	    ++digit;
  3700   3667   	    if (digit == 10) {
  3701   3668   		*s++ = '9';
  3702   3669   		s = BumpUp(s, retval, &k);
  3703   3670   		break;
  3704   3671   	    }
  3705   3672   	    *s++ = '0' + digit;
................................................................................
  3778   3745        * Endgame - store the location of the decimal point and the end of the
  3779   3746        * string.
  3780   3747        */
  3781   3748   
  3782   3749       if (m2plus > m2minus) {
  3783   3750   	mp_clear(&mplus);
  3784   3751       }
  3785         -    mp_clear_multi(&b, &mminus, &temp, &dig, &S, NULL);
         3752  +    mp_clear_multi(&b, &mminus, &dig, &S, NULL);
  3786   3753       *s = '\0';
  3787   3754       *decpt = k;
  3788   3755       if (endPtr) {
  3789   3756   	*endPtr = s;
  3790   3757       }
  3791   3758       return retval;
  3792   3759   }
................................................................................
  3808   3775    *
  3809   3776    *----------------------------------------------------------------------
  3810   3777    */
  3811   3778   
  3812   3779   static inline char *
  3813   3780   StrictBignumConversion(
  3814   3781       Double *dPtr,		/* Original number being converted. */
  3815         -    int convType,		/* Conversion type. */
  3816   3782       Tcl_WideUInt bw,		/* Integer significand and exponent. */
  3817   3783       int b2,			/* Scale factor for the significand. */
  3818   3784       int s2, int s5,		/* Scale factors for denominator. */
  3819   3785       int k,			/* Guessed position of the decimal point. */
  3820   3786       int len,			/* Size of the digit buffer to allocate. */
  3821   3787       int ilim,			/* Number of digits to convert if b >= s */
  3822   3788       int ilim1,			/* Number of digits to convert if b < s */
................................................................................
  3826   3792       char *retval = Tcl_Alloc(len+1);
  3827   3793   				/* Buffer of digits to return. */
  3828   3794       char *s = retval;		/* Cursor in the return value. */
  3829   3795       mp_int b;			/* Numerator of the result. */
  3830   3796       mp_int S;			/* Denominator of the result. */
  3831   3797       mp_int dig;			/* Current digit of the result. */
  3832   3798       int digit;			/* Current digit of the result. */
  3833         -    mp_int temp;		/* Work area. */
  3834   3799       int g;			/* Size of the current digit ground. */
  3835   3800       int i, j;
  3836   3801   
  3837   3802       /*
  3838   3803        * b = bw * 2**b2 * 5**b5
  3839   3804        * S = 2**s2 * 5*s5
  3840   3805        */
  3841   3806   
  3842         -    mp_init_multi(&temp, &dig, NULL);
         3807  +    mp_init_multi(&dig, NULL);
  3843   3808       TclInitBignumFromWideUInt(&b, bw);
  3844   3809       mp_mul_2d(&b, b2, &b);
  3845   3810       mp_init_set_int(&S, 1);
  3846   3811       MulPow5(&S, s5, &S); mp_mul_2d(&S, s2, &S);
  3847   3812   
  3848   3813       /*
  3849   3814        * Handle the case where we guess the position of the decimal point wrong.
................................................................................
  3942   3907       ++s;
  3943   3908   
  3944   3909       /*
  3945   3910        * Endgame - store the location of the decimal point and the end of the
  3946   3911        * string.
  3947   3912        */
  3948   3913   
  3949         -    mp_clear_multi(&b, &S, &temp, &dig, NULL);
         3914  +    mp_clear_multi(&b, &S, &dig, NULL);
  3950   3915       *s = '\0';
  3951   3916       *decpt = k;
  3952   3917       if (endPtr) {
  3953   3918   	*endPtr = s;
  3954   3919       }
  3955   3920       return retval;
  3956   3921   }
................................................................................
  3978   3943    * according to the 'flags' argument. Valid values for 'flags' include:
  3979   3944    *	TCL_DD_SHORTEST - This is the default for floating point conversion.
  3980   3945    *		It constructs the shortest string of
  3981   3946    *		digits that will reconvert to the given number when scanned.
  3982   3947    *		For floating point numbers that are exactly between two
  3983   3948    *		decimal numbers, it resolves using the 'round to even' rule.
  3984   3949    *		With this value, the 'ndigits' parameter is ignored.
  3985         - *	TCL_DD_STEELE - This value is not recommended and may be removed in
  3986         - *		the future. It follows the conversion algorithm outlined in
  3987         - *		"How to Print Floating-Point Numbers Accurately" by Guy
  3988         - *		L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90,
  3989         - *		pp. 112-126]. This rule has the effect of rendering 1e23 as
  3990         - *		9.9999999999999999e22 - which is a 'better' approximation in
  3991         - *		the sense that it will reconvert correctly even if a
  3992         - *		subsequent input conversion is 'round up' or 'round down'
  3993         - *		rather than 'round to nearest', but is surprising otherwise.
  3994   3950    *	TCL_DD_E_FORMAT - This value is used to prepare numbers for %e format
  3995   3951    *		conversion. It constructs a string of at most 'ndigits' digits,
  3996   3952    *		choosing the one that is closest to the given number (and
  3997   3953    *		resolving ties with 'round to even').  It is allowed to return
  3998   3954    *		fewer than 'ndigits' if the number converts exactly; if the
  3999   3955    *		TCL_DD_E_FORMAT|TCL_DD_SHORTEN_FLAG is supplied instead, it
  4000   3956    *		also returns fewer digits if the shorter string will still
................................................................................
  4036   3992       int flags,			/* Conversion flags. */
  4037   3993       int *decpt,			/* OUTPUT: Position of the decimal point. */
  4038   3994       int *sign,			/* OUTPUT: 1 if the result is negative. */
  4039   3995       char **endPtr)		/* OUTPUT: If not NULL, receives a pointer to
  4040   3996   				 *	   one character beyond the end of the
  4041   3997   				 *	   returned string. */
  4042   3998   {
  4043         -    int convType = (flags & TCL_DD_CONVERSION_TYPE_MASK);
  4044         -				/* Type of conversion being performed:
  4045         -				 * TCL_DD_SHORTEST0, TCL_DD_STEELE0,
  4046         -				 * TCL_DD_E_FORMAT, or TCL_DD_F_FORMAT. */
  4047   3999       Double d;			/* Union for deconstructing doubles. */
  4048   4000       Tcl_WideUInt bw;		/* Integer significand. */
  4049   4001       int be;			/* Power of 2 by which b must be multiplied */
  4050   4002       int bbits;			/* Number of bits needed to represent b. */
  4051   4003       int denorm;			/* Flag == 1 iff the input number was
  4052   4004   				 * denormalized. */
  4053   4005       int k;			/* Estimate of floor(log10(d)). */
................................................................................
  4107   4059   
  4108   4060       ComputeScale(be, k, &b2, &b5, &s2, &s5);
  4109   4061   
  4110   4062       /*
  4111   4063        * Correct an incorrect caller-supplied 'ndigits'.  Also determine:
  4112   4064        *	i = The maximum number of decimal digits that will be returned in the
  4113   4065        *      formatted string.  This is k + 1 + ndigits for F format, 18 for
  4114         -     *      shortest and Steele, and ndigits for E format.
         4066  +     *      shortest, and ndigits for E format.
  4115   4067        *  ilim = The number of significant digits to convert if k has been
  4116         -     *         guessed correctly. This is -1 for shortest and Steele (which
         4068  +     *         guessed correctly. This is -1 for shortest (which
  4117   4069        *         stop when all significance has been lost), 'ndigits' for E
  4118   4070        *         format, and 'k + 1 + ndigits' for F format.
  4119   4071        *  ilim1 = The minimum number of significant digits to convert if k has
  4120         -     *	        been guessed 1 too high. This, too, is -1 for shortest and
  4121         -     *	        Steele, and 'ndigits' for E format, but it's 'ndigits-1' for F
         4072  +     *	        been guessed 1 too high. This, too, is -1 for shortest,
         4073  +     *	        and 'ndigits' for E format, but it's 'ndigits-1' for F
  4122   4074        *	        format.
  4123   4075        */
  4124   4076   
  4125         -    SetPrecisionLimits(convType, k, &ndigits, &i, &ilim, &ilim1);
         4077  +    SetPrecisionLimits(flags, k, &ndigits, &i, &ilim, &ilim1);
  4126   4078   
  4127   4079       /*
  4128   4080        * Try to do low-precision conversion in floating point rather than
  4129   4081        * resorting to expensive multiprecision arithmetic.
  4130   4082        */
  4131   4083   
  4132   4084       if (ilim >= 0 && ilim <= QUICK_MAX && !(flags & TCL_DD_NO_QUICK)) {
................................................................................
  4191   4143   	     * If 10*2**s2*5**s5 == 2**(s2+1)+5**(s5+1) fits in a 64-bit word,
  4192   4144   	     * then all our intermediate calculations can be done using exact
  4193   4145   	     * 64-bit arithmetic with no need for expensive multiprecision
  4194   4146   	     * operations. (This will be true for all numbers in the range
  4195   4147   	     * [1.0e-3 .. 1.0e+24]).
  4196   4148   	     */
  4197   4149   
  4198         -	    return ShorteningInt64Conversion(&d, convType, bw, b2, b5, m2plus,
         4150  +	    return ShorteningInt64Conversion(&d, bw, b2, b5, m2plus,
  4199   4151   		    m2minus, m5, s2, s5, k, len, ilim, ilim1, decpt, endPtr);
  4200   4152   	} else if (s5 == 0) {
  4201   4153   	    /*
  4202   4154   	     * The denominator is a power of 2, so we can replace division by
  4203   4155   	     * digit shifts. First we round up s2 to a multiple of DIGIT_BIT,
  4204   4156   	     * and adjust m2 and b2 accordingly. Then we launch into a version
  4205   4157   	     * of the comparison that's specialized for the 'power of mp_digit
................................................................................
  4210   4162   		int delta = DIGIT_BIT - (s2 % DIGIT_BIT);
  4211   4163   
  4212   4164   		b2 += delta;
  4213   4165   		m2plus += delta;
  4214   4166   		m2minus += delta;
  4215   4167   		s2 += delta;
  4216   4168   	    }
  4217         -	    return ShorteningBignumConversionPowD(&d, convType, bw, b2, b5,
         4169  +	    return ShorteningBignumConversionPowD(&d, bw, b2, b5,
  4218   4170   		    m2plus, m2minus, m5, s2/DIGIT_BIT, k, len, ilim, ilim1,
  4219   4171   		    decpt, endPtr);
  4220   4172   	} else {
  4221   4173   	    /*
  4222   4174   	     * Alas, there's no helpful special case; use full-up bignum
  4223   4175   	     * arithmetic for the conversion.
  4224   4176   	     */
  4225   4177   
  4226         -	    return ShorteningBignumConversion(&d, convType, bw, b2, m2plus,
         4178  +	    return ShorteningBignumConversion(&d, bw, b2, m2plus,
  4227   4179   		    m2minus, s2, s5, k, len, ilim, ilim1, decpt, endPtr);
  4228   4180   	}
  4229   4181       } else {
  4230   4182   	/*
  4231   4183   	 * Non-shortening conversion.
  4232   4184   	 */
  4233   4185   
................................................................................
  4247   4199   	    /*
  4248   4200   	     * If 10*2**s2*5**s5 == 2**(s2+1)+5**(s5+1) fits in a 64-bit word,
  4249   4201   	     * then all our intermediate calculations can be done using exact
  4250   4202   	     * 64-bit arithmetic with no need for expensive multiprecision
  4251   4203   	     * operations.
  4252   4204   	     */
  4253   4205   
  4254         -	    return StrictInt64Conversion(&d, convType, bw, b2, b5, s2, s5, k,
         4206  +	    return StrictInt64Conversion(&d, bw, b2, b5, s2, s5, k,
  4255   4207   		    len, ilim, ilim1, decpt, endPtr);
  4256   4208   	} else if (s5 == 0) {
  4257   4209   	    /*
  4258   4210   	     * The denominator is a power of 2, so we can replace division by
  4259   4211   	     * digit shifts. First we round up s2 to a multiple of DIGIT_BIT,
  4260   4212   	     * and adjust m2 and b2 accordingly. Then we launch into a version
  4261   4213   	     * of the comparison that's specialized for the 'power of mp_digit
................................................................................
  4264   4216   
  4265   4217   	    if (s2 % DIGIT_BIT != 0) {
  4266   4218   		int delta = DIGIT_BIT - (s2 % DIGIT_BIT);
  4267   4219   
  4268   4220   		b2 += delta;
  4269   4221   		s2 += delta;
  4270   4222   	    }
  4271         -	    return StrictBignumConversionPowD(&d, convType, bw, b2, b5,
         4223  +	    return StrictBignumConversionPowD(&d, bw, b2, b5,
  4272   4224   		    s2/DIGIT_BIT, k, len, ilim, ilim1, decpt, endPtr);
  4273   4225   	} else {
  4274   4226   	    /*
  4275   4227   	     * There are no helpful special cases, but at least we know in
  4276   4228   	     * advance how many digits we will convert. We can run the
  4277   4229   	     * conversion in steps of DIGIT_GROUP digits, so as to have many
  4278   4230   	     * fewer mp_int divisions.
  4279   4231   	     */
  4280   4232   
  4281         -	    return StrictBignumConversion(&d, convType, bw, b2, s2, s5, k,
         4233  +	    return StrictBignumConversion(&d, bw, b2, s2, s5, k,
  4282   4234   		    len, ilim, ilim1, decpt, endPtr);
  4283   4235   	}
  4284   4236       }
  4285   4237   }
  4286   4238   
  4287   4239   /*
  4288   4240    *----------------------------------------------------------------------

Changes to generic/tclStringObj.c.

  1319   1319        */
  1320   1320   
  1321   1321       if (stringPtr->hasUnicode) {
  1322   1322   	/*
  1323   1323   	 * If appendObjPtr is not of the "String" type, don't convert it.
  1324   1324   	 */
  1325   1325   
  1326         -	if (appendObjPtr->typePtr == &tclStringType) {
         1326  +	if (TclHasIntRep(appendObjPtr, &tclStringType)) {
  1327   1327   	    Tcl_UniChar *unicode =
  1328   1328   		    TclGetUnicodeFromObj(appendObjPtr, &numChars);
  1329   1329   
  1330   1330   	    AppendUnicodeToUnicodeRep(objPtr, unicode, numChars);
  1331   1331   	} else {
  1332   1332   	    bytes = TclGetStringFromObj(appendObjPtr, &length);
  1333   1333   	    AppendUtfToUnicodeRep(objPtr, bytes, length);
................................................................................
  1340   1340        * in both objects before appending, then set the combined number of
  1341   1341        * characters in the final (appended-to) object.
  1342   1342        */
  1343   1343   
  1344   1344       bytes = TclGetStringFromObj(appendObjPtr, &length);
  1345   1345   
  1346   1346       numChars = stringPtr->numChars;
  1347         -    if ((numChars != TCL_AUTO_LENGTH) && (appendObjPtr->typePtr == &tclStringType)) {
         1347  +    if ((numChars != TCL_AUTO_LENGTH) && TclHasIntRep(appendObjPtr, &tclStringType)) {
  1348   1348   	String *appendStringPtr = GET_STRING(appendObjPtr);
  1349   1349   
  1350   1350   	appendNumChars = appendStringPtr->numChars;
  1351   1351       }
  1352   1352   
  1353   1353       AppendUtfToUtfRep(objPtr, bytes, length);
  1354   1354   
................................................................................
  2704   2704   char *
  2705   2705   TclGetStringStorage(
  2706   2706       Tcl_Obj *objPtr,
  2707   2707       size_t *sizePtr)
  2708   2708   {
  2709   2709       String *stringPtr;
  2710   2710   
  2711         -    if (objPtr->typePtr != &tclStringType || objPtr->bytes == NULL) {
         2711  +    if (!TclHasIntRep(objPtr, &tclStringType) || objPtr->bytes == NULL) {
  2712   2712   	return TclGetStringFromObj(objPtr, sizePtr);
  2713   2713       }
  2714   2714   
  2715   2715       stringPtr = GET_STRING(objPtr);
  2716   2716       *sizePtr = stringPtr->allocated;
  2717   2717       return objPtr->bytes;
  2718   2718   }
................................................................................
  2752   2752        * Analyze to determine what representation result should be.
  2753   2753        * GOALS:	Avoid shimmering & string rep generation.
  2754   2754        * 		Produce pure bytearray when possible.
  2755   2755        * 		Error on overflow.
  2756   2756        */
  2757   2757   
  2758   2758       if (!binary) {
  2759         -	if (objPtr->typePtr == &tclStringType) {
         2759  +	if (TclHasIntRep(objPtr, &tclStringType)) {
  2760   2760   	    String *stringPtr = GET_STRING(objPtr);
  2761   2761   	    if (stringPtr->hasUnicode) {
  2762   2762   		unichar = 1;
  2763   2763   	    }
  2764   2764   	}
  2765   2765       }
  2766   2766   
................................................................................
  2930   2930   		    /* Prevent shimmer of non-string types. */
  2931   2931   		    allowUniChar = 0;
  2932   2932   		}
  2933   2933   	    }
  2934   2934   	} else {
  2935   2935   	    /* assert (objPtr->typePtr != NULL) -- stork! */
  2936   2936   	    binary = 0;
  2937         -	    if (objPtr->typePtr == &tclStringType) {
         2937  +	    if (TclHasIntRep(objPtr, &tclStringType)) {
  2938   2938   		/* Have a pure Unicode value; ask to preserve it */
  2939   2939   		requestUniChar = 1;
  2940   2940   	    } else {
  2941   2941   		/* Have another type; prevent shimmer */
  2942   2942   		allowUniChar = 0;
  2943   2943   	    }
  2944   2944   	}
................................................................................
  3281   3281   	     * case-sensitive (which is all that really makes sense with byte
  3282   3282   	     * arrays anyway, and we have no memcasecmp() for some reason... :^)
  3283   3283   	     */
  3284   3284   
  3285   3285   	    s1 = (char *) TclGetByteArrayFromObj(value1Ptr, &s1len);
  3286   3286   	    s2 = (char *) TclGetByteArrayFromObj(value2Ptr, &s2len);
  3287   3287   	    memCmpFn = memcmp;
  3288         -	} else if ((value1Ptr->typePtr == &tclStringType)
  3289         -		&& (value2Ptr->typePtr == &tclStringType)) {
         3288  +	} else if (TclHasIntRep(value1Ptr, &tclStringType)
         3289  +		&& TclHasIntRep(value2Ptr, &tclStringType)) {
  3290   3290   	    /*
  3291   3291   	     * Do a unicode-specific comparison if both of the args are of
  3292   3292   	     * String type. If the char length == byte length, we can do a
  3293   3293   	     * memcmp. In benchmark testing this proved the most efficient
  3294   3294   	     * check between the unicode and string comparison operations.
  3295   3295   	     */
  3296   3296   
................................................................................
  4052   4052    */
  4053   4053   
  4054   4054   static int
  4055   4055   SetStringFromAny(
  4056   4056       Tcl_Interp *interp,		/* Used for error reporting if not NULL. */
  4057   4057       Tcl_Obj *objPtr)		/* The object to convert. */
  4058   4058   {
  4059         -    if (objPtr->typePtr != &tclStringType) {
         4059  +    if (!TclHasIntRep(objPtr, &tclStringType)) {
  4060   4060   	String *stringPtr = stringAlloc(0);
  4061   4061   
  4062   4062   	/*
  4063   4063   	 * Convert whatever we have into an untyped value. Just A String.
  4064   4064   	 */
  4065   4065   
  4066   4066   	(void) TclGetString(objPtr);

Changes to generic/tclStubInit.c.

   212    212       for (w = (wchar_t *)string; w < wEnd; ) {
   213    213   	if (!blen && ((*w & 0xFC00) != 0xDC00)) {
   214    214   	    /* Special case for handling high surrogates. */
   215    215   	    p += Tcl_UniCharToUtf(-1, p);
   216    216   	}
   217    217   	blen = Tcl_UniCharToUtf(*w, p);
   218    218   	p += blen;
          219  +	if ((*w >= 0xD800) && (blen < 3)) {
          220  +	    /* Indication that high surrogate is handled */
          221  +	    blen = 0;
          222  +	}
   219    223   	w++;
   220    224       }
   221    225       if (!blen) {
   222    226   	/* Special case for handling high surrogates. */
   223    227   	p += Tcl_UniCharToUtf(-1, p);
   224    228       }
   225    229       Tcl_DStringSetLength(dsPtr, oldLength + (p - result));

Changes to generic/tclTest.c.

  1702   1702    *
  1703   1703    * Usage:
  1704   1704    *	testdoubledigits fpval ndigits type ?shorten"
  1705   1705    *
  1706   1706    * Parameters:
  1707   1707    *	fpval - Floating-point value to format.
  1708   1708    *	ndigits - Digit count to request from Tcl_DoubleDigits
  1709         - *	type - One of 'shortest', 'Steele', 'e', 'f'
         1709  + *	type - One of 'shortest', 'e', 'f'
  1710   1710    *	shorten - Indicates that the 'shorten' flag should be passed in.
  1711   1711    *
  1712   1712    *-----------------------------------------------------------------------------
  1713   1713    */
  1714   1714   
  1715   1715   static int
  1716   1716   TestdoubledigitsObjCmd(void *unused,
................................................................................
  1720   1720   		       int objc,
  1721   1721   				/* Parameter count */
  1722   1722   		       Tcl_Obj* const objv[])
  1723   1723   				/* Parameter vector */
  1724   1724   {
  1725   1725       static const char* options[] = {
  1726   1726   	"shortest",
  1727         -	"Steele",
  1728   1727   	"e",
  1729   1728   	"f",
  1730   1729   	NULL
  1731   1730       };
  1732   1731       static const int types[] = {
  1733   1732   	TCL_DD_SHORTEST,
  1734         -	TCL_DD_STEELE,
  1735   1733   	TCL_DD_E_FORMAT,
  1736   1734   	TCL_DD_F_FORMAT
  1737   1735       };
  1738   1736   
  1739   1737       const Tcl_ObjType* doubleType;
  1740   1738       double d;
  1741   1739       int status;
................................................................................
  1751   1749       if (objc < 4 || objc > 5) {
  1752   1750   	Tcl_WrongNumArgs(interp, 1, objv, "fpval ndigits type ?shorten?");
  1753   1751   	return TCL_ERROR;
  1754   1752       }
  1755   1753       status = Tcl_GetDoubleFromObj(interp, objv[1], &d);
  1756   1754       if (status != TCL_OK) {
  1757   1755   	doubleType = Tcl_GetObjType("double");
  1758         -	if (objv[1]->typePtr == doubleType
  1759         -	    || TclIsNaN(objv[1]->internalRep.doubleValue)) {
         1756  +	if (Tcl_FetchIntRep(objv[1], doubleType)
         1757  +	    && TclIsNaN(objv[1]->internalRep.doubleValue)) {
  1760   1758   	    status = TCL_OK;
  1761   1759   	    memcpy(&d, &(objv[1]->internalRep.doubleValue), sizeof(double));
  1762   1760   	}
  1763   1761       }
  1764   1762       if (status != TCL_OK
  1765   1763   	|| Tcl_GetIntFromObj(interp, objv[2], &ndigits) != TCL_OK
  1766   1764   	|| Tcl_GetIndexFromObj(interp, objv[3], options, "conversion type",

Changes to generic/tclTestProcBodyObj.c.

    17     17   #include "tclInt.h"
    18     18   
    19     19   /*
    20     20    * name and version of this package
    21     21    */
    22     22   
    23     23   static const char packageName[] = "procbodytest";
    24         -static const char packageVersion[] = "1.0";
           24  +static const char packageVersion[] = "1.1";
    25     25   
    26     26   /*
    27     27    * Name of the commands exported by this package
    28     28    */
    29     29   
    30     30   static const char procCommand[] = "proc";
           31  +static const char checkCommand[] = "check";
    31     32   
    32     33   /*
    33     34    * this struct describes an entry in the table of command names and command
    34     35    * procs
    35     36    */
    36     37   
    37     38   typedef struct {
................................................................................
    41     42   } CmdTable;
    42     43   
    43     44   /*
    44     45    * Declarations for functions defined in this file.
    45     46    */
    46     47   
    47     48   static int	ProcBodyTestProcObjCmd(ClientData dummy,
           49  +			Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);
           50  +static int	ProcBodyTestCheckObjCmd(ClientData dummy,
    48     51   			Tcl_Interp *interp, int objc, Tcl_Obj *const objv[]);
    49     52   static int	ProcBodyTestInitInternal(Tcl_Interp *interp, int isSafe);
    50     53   static int	RegisterCommand(Tcl_Interp* interp,
    51     54   			const char *namespace, const CmdTable *cmdTablePtr);
    52     55   
    53     56   /*
    54     57    * List of commands to create when the package is loaded; must go after the
    55     58    * declarations of the enable command procedure.
    56     59    */
    57     60   
    58     61   static const CmdTable commands[] = {
    59     62       { procCommand,	ProcBodyTestProcObjCmd,	1 },
           63  +    { checkCommand,	ProcBodyTestCheckObjCmd,	1 },
    60     64       { 0, 0, 0 }
    61     65   };
    62     66   
    63     67   static const CmdTable safeCommands[] = {
    64     68       { procCommand,	ProcBodyTestProcObjCmd,	1 },
           69  +    { checkCommand,	ProcBodyTestCheckObjCmd,	1 },
    65     70       { 0, 0, 0 }
    66     71   };
    67     72   
    68     73   /*
    69     74    *----------------------------------------------------------------------
    70     75    *
    71     76    * Procbodytest_Init --
................................................................................
   295    300       myobjv[4] = NULL;
   296    301   
   297    302       result = Tcl_ProcObjCmd(NULL, interp, objc, myobjv);
   298    303       Tcl_DecrRefCount(bodyObjPtr);
   299    304   
   300    305       return result;
   301    306   }
          307  +
          308  +/*
          309  + *----------------------------------------------------------------------
          310  + *
          311  + * ProcBodyTestCheckObjCmd --
          312  + *
          313  + *  Implements the "procbodytest::check" command. Here is the command
          314  + *  description:
          315  + *	procbodytest::check
          316  + *
          317  + *  Performs an internal check that the Tcl_PkgPresent() command returns
          318  + *  the same version number as was registered when the procbodytest package
          319  + *  was provided.  Places a boolean in the interp result indicating the
          320  + *  test outcome.
          321  + *
          322  + * Results:
          323  + *  Returns a standard Tcl code.
          324  + *
          325  + *----------------------------------------------------------------------
          326  + */
          327  +
          328  +static int
          329  +ProcBodyTestCheckObjCmd(
          330  +    ClientData dummy,		/* context; not used */
          331  +    Tcl_Interp *interp,		/* the current interpreter */
          332  +    int objc,			/* argument count */
          333  +    Tcl_Obj *const objv[])	/* arguments */
          334  +{
          335  +    const char *version;
          336  +
          337  +    if (objc != 1) {
          338  +	Tcl_WrongNumArgs(interp, 1, objv, "");
          339  +	return TCL_ERROR;
          340  +    }
          341  +
          342  +    version = Tcl_PkgPresent(interp, packageName, packageVersion, 1);
          343  +    Tcl_SetObjResult(interp, Tcl_NewBooleanObj(
          344  +	    strcmp(version, packageVersion) == 0));
          345  +    return TCL_OK;
          346  +}
   302    347   
   303    348   /*
   304    349    * Local Variables:
   305    350    * mode: c
   306    351    * c-basic-offset: 4
   307    352    * fill-column: 78
   308    353    * End:
   309    354    */

Changes to generic/tclUniData.c.

    48     48       6144, 6176, 6208, 6240, 6272, 6304, 6336, 6368, 6400, 6432, 6464, 6496,
    49     49       6528, 6560, 6560, 6560, 6560, 6560, 6560, 6560, 6560, 6592, 6624, 4928,
    50     50       6656, 6688, 6720, 6752, 6784, 4928, 6816, 6848, 6880, 6912, 6944, 6976,
    51     51       7008, 4928, 4928, 4928, 4928, 4928, 7040, 7072, 7104, 4928, 4928, 4928,
    52     52       7136, 4928, 4928, 4928, 4928, 4928, 4928, 4928, 7168, 7200, 4928, 7232,
    53     53       7264, 4928, 4928, 4928, 4928, 4928, 4928, 4928, 4928, 6560, 6560, 6560,
    54     54       6560, 7296, 6560, 7328, 7360, 6560, 6560, 6560, 6560, 6560, 6560, 6560,
    55         -    6560, 4928, 7392, 7424, 7456, 7488, 4928, 7520, 7552, 7584, 7616, 7648,
    56         -    7680, 224, 224, 224, 7712, 7744, 7776, 1344, 7808, 7840, 7872, 7872,
    57         -    704, 7904, 7936, 7968, 1824, 8000, 4928, 4928, 8032, 4928, 4928, 4928,
    58         -    4928, 4928, 4928, 8064, 8096, 8128, 8160, 3232, 1344, 8192, 4192, 1344,
    59         -    8224, 8256, 8288, 1344, 1344, 8320, 8352, 4928, 8384, 7552, 8416, 8448,
    60         -    4928, 8416, 8480, 4928, 7552, 4928, 4928, 4928, 4928, 4928, 4928, 4928,
           55  +    6560, 4928, 7392, 7424, 7456, 7488, 4928, 4928, 4928, 7520, 7552, 7584,
           56  +    7616, 224, 224, 224, 7648, 7680, 7712, 1344, 7744, 7776, 7808, 7808,
           57  +    704, 7840, 7872, 7904, 1824, 7936, 4928, 4928, 7968, 4928, 4928, 4928,
           58  +    4928, 4928, 4928, 8000, 8032, 8064, 8096, 3232, 1344, 8128, 4192, 1344,
           59  +    8160, 8192, 8224, 1344, 1344, 8256, 8288, 4928, 8320, 8352, 8384, 8416,
           60  +    4928, 8384, 8448, 4928, 8352, 4928, 4928, 4928, 4928, 4928, 4928, 4928,
    61     61       4928, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
    62     62       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
    63     63       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
    64     64       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
    65     65       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
    66     66       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
    67     67       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
................................................................................
   126    126       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   127    127       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   128    128       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   129    129       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   130    130       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   131    131       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   132    132       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   133         -    8512, 8544, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          133  +    8480, 8512, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   134    134       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   135    135       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   136         -    1344, 8576, 4928, 8608, 5408, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   137         -    1344, 8640, 8672, 224, 8704, 8736, 1344, 1344, 8768, 8800, 8832, 224,
   138         -    8864, 8896, 8928, 1824, 8960, 8992, 9024, 1344, 9056, 9088, 9120, 9152,
          136  +    1344, 8544, 4928, 8576, 5408, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          137  +    1344, 8608, 8640, 224, 8672, 8704, 1344, 1344, 8736, 8768, 8800, 224,
          138  +    8832, 8864, 8896, 8928, 8960, 8992, 9024, 1344, 9056, 9088, 9120, 9152,
   139    139       9184, 1632, 9216, 9248, 9280, 1952, 9312, 9344, 9376, 1344, 9408, 9440,
   140    140       9472, 1344, 9504, 9536, 9568, 9600, 9632, 9664, 9696, 9728, 9728, 1344,
   141    141       9760, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   142    142       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   143    143       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   144    144       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   145    145       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
................................................................................
   192    192       9920, 9920, 9920, 9920, 9920, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   193    193       1344, 1344, 1344, 1344, 9952, 1344, 1344, 9984, 1824, 10016, 10048,
   194    194       10080, 1344, 1344, 10112, 10144, 1344, 1344, 1344, 1344, 1344, 1344,
   195    195       1344, 1344, 1344, 1344, 10176, 10208, 1344, 10240, 1344, 10272, 10304,
   196    196       10336, 10368, 10400, 10432, 1344, 1344, 1344, 10464, 10496, 64, 10528,
   197    197       10560, 10592, 4736, 10624, 10656
   198    198   #if TCL_UTF_MAX > 3
   199         -    ,10688, 10720, 10752, 1824, 1344, 1344, 1344, 8352, 10784, 10816, 10848,
          199  +    ,10688, 10720, 10752, 1824, 1344, 1344, 1344, 8288, 10784, 10816, 10848,
   200    200       10880, 10912, 10944, 10976, 11008, 1824, 1824, 1824, 1824, 9280, 1344,
   201    201       11040, 11072, 1344, 11104, 11136, 11168, 11200, 1344, 11232, 1824,
   202    202       11264, 11296, 11328, 1344, 11360, 11392, 11424, 11456, 1344, 11488,
   203    203       1344, 11520, 1824, 1824, 1824, 1824, 1344, 1344, 1344, 1344, 1344,
   204         -    1344, 1344, 1344, 1344, 7840, 4704, 10272, 1824, 1824, 1824, 1824,
          204  +    1344, 1344, 1344, 1344, 7776, 4704, 10272, 1824, 1824, 1824, 1824,
   205    205       11552, 11584, 11616, 11648, 4736, 11680, 1824, 11712, 11744, 11776,
   206    206       1824, 1824, 1344, 11808, 11840, 6880, 11872, 11904, 11936, 11968, 12000,
   207    207       1824, 12032, 12064, 1344, 12096, 12128, 12160, 12192, 12224, 1824,
   208    208       1824, 1344, 1344, 12256, 1824, 12288, 12320, 12352, 12384, 1344, 12416,
   209    209       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 12448, 1824,
   210         -    1824, 1824, 1824, 12000, 12480, 12512, 1824, 1824, 1824, 1824, 1824,
          210  +    1824, 1824, 1824, 12000, 12480, 12512, 1824, 1824, 1824, 1824, 7776,
   211    211       12544, 12576, 12608, 12640, 5248, 12672, 12704, 12736, 12768, 12800,
   212    212       12832, 12864, 5248, 12896, 12928, 12960, 12992, 13024, 1824, 1824,
   213    213       13056, 13088, 13120, 13152, 13184, 13216, 13248, 13280, 1824, 1824,
   214    214       1824, 1824, 1344, 13312, 13344, 1824, 1344, 13376, 13408, 1824, 1824,
   215    215       1824, 1824, 1824, 1344, 13440, 13472, 1824, 1344, 13504, 13536, 13568,
   216    216       1344, 13600, 13632, 1824, 4032, 13664, 1824, 1824, 1824, 1824, 1824,
   217    217       1824, 1344, 13696, 1824, 1824, 1824, 13728, 13760, 13792, 1824, 1824,
   218         -    1824, 1824, 1824, 1824, 1824, 1824, 13824, 13856, 13888, 1344, 13920,
   219         -    13952, 1344, 4608, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   220         -    13984, 14016, 14048, 14080, 14112, 14144, 1824, 1824, 14176, 14208,
   221         -    14240, 14272, 14304, 13632, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   222         -    1824, 1824, 14336, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
          218  +    1824, 1824, 1824, 13824, 13856, 13888, 13920, 13952, 13984, 1344, 14016,
          219  +    14048, 1344, 4608, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
          220  +    14080, 14112, 14144, 14176, 14208, 14240, 1824, 1824, 14272, 14304,
          221  +    14336, 14368, 14400, 13632, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
          222  +    1824, 1824, 14432, 1824, 1824, 1824, 1824, 1824, 1824, 14464, 14496,
   223    223       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   224    224       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   225    225       1344, 1344, 1344, 1344, 9984, 1824, 1824, 1824, 10848, 10848, 10848,
   226         -    14368, 1344, 1344, 1344, 1344, 1344, 1344, 14400, 1824, 1824, 1824,
          226  +    14528, 1344, 1344, 1344, 1344, 1344, 1344, 14560, 1824, 1824, 1824,
   227    227       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   228    228       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   229    229       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   230    230       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   231    231       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   232    232       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   233    233       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1344, 1344,
   234    234       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   235    235       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   236         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 14432, 1824, 1824, 1824,
          236  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 14592, 1824, 1824, 1824,
   237    237       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   238    238       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   239    239       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   240    240       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   241    241       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   242    242       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   243    243       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   244    244       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   245    245       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   246    246       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   247    247       1824, 1824, 1824, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   248         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 14464, 1824,
          248  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 14624, 1824,
   249    249       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   250    250       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   251    251       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   252    252       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   253    253       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   254    254       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   255    255       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
................................................................................
   265    265       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   266    266       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   267    267       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   268    268       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   269    269       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   270    270       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   271    271       1824, 1824, 1824, 1824, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   272         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 4608, 4736, 14496,
   273         -    1824, 1824, 10208, 14528, 1344, 14560, 14592, 14624, 8512, 1824, 1824,
   274         -    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   275         -    1824, 1824, 1824, 1824, 1824, 1824, 1824, 13728, 13760, 14656, 1824,
   276         -    1824, 1824, 1344, 1344, 14688, 14720, 14752, 1824, 1824, 14784, 1344,
   277         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   278         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   279         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   280         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   281         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   282         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   283         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   284         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   285         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   286         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   287         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   288         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   289         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   290         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   291         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   292         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 14816,
   293         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   294         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 14848,
          272  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 4608, 4736, 14656,
          273  +    1824, 1824, 10208, 14688, 1344, 14720, 14752, 14784, 8480, 1824, 1824,
          274  +    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
          275  +    1824, 1824, 1824, 1824, 1824, 1824, 1824, 13728, 13760, 14816, 1824,
          276  +    1824, 1824, 1344, 1344, 14848, 14880, 14912, 1824, 1824, 14944, 1344,
          277  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          278  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          279  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          280  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          281  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          282  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          283  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          284  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          285  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          286  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          287  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          288  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          289  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          290  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          291  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          292  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 14976,
          293  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          294  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 15008,
   295    295       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   296    296       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   297    297       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   298    298       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   299    299       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   300    300       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   301    301       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
................................................................................
   313    313       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   314    314       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   315    315       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   316    316       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   317    317       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   318    318       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   319    319       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1344, 1344, 1344, 1344,
   320         -    1344, 1344, 1344, 1344, 4736, 1824, 1824, 10208, 1344, 1344, 1344,
          320  +    1344, 1344, 1344, 1344, 4736, 1824, 15040, 15072, 1344, 1344, 1344,
   321    321       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 9856, 1824, 1824, 1824,
   322    322       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   323    323       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   324    324       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   325    325       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   326    326       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   327    327       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1344, 1344, 1344,
   328         -    14880, 14912, 14944, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
          328  +    15104, 15136, 15168, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   329    329       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   330    330       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   331    331       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   332    332       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   333    333       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   334    334       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   335    335       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   336    336       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   337    337       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
          338  +    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
          339  +    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
          340  +    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
          341  +    1824, 1824, 4928, 4928, 4928, 4928, 4928, 4928, 4928, 8000, 4928, 15200,
          342  +    4928, 15232, 15264, 15296, 4928, 15328, 4928, 4928, 15360, 1824, 1824,
          343  +    1824, 1824, 15392, 4928, 4928, 15424, 15456, 1824, 1824, 1824, 1824,
          344  +    15488, 15520, 15552, 15584, 15616, 15648, 15680, 15712, 15744, 15776,
          345  +    15808, 15840, 15872, 15488, 15520, 15904, 15584, 15936, 15968, 16000,
          346  +    15712, 16032, 16064, 16096, 16128, 16160, 16192, 16224, 16256, 16288,
          347  +    16320, 16352, 4928, 4928, 4928, 4928, 4928, 4928, 4928, 4928, 4928,
          348  +    4928, 4928, 4928, 4928, 4928, 4928, 4928, 704, 16384, 704, 16416, 16448,
          349  +    16480, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
          350  +    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
          351  +    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
          352  +    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 16512, 16544, 1824,
          353  +    1824, 1824, 1824, 1824, 1824, 1344, 16576, 16608, 1824, 1824, 1824,
          354  +    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1344, 16640, 1824,
   338    355       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   339    356       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   340    357       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   341         -    1824, 1824, 4928, 4928, 4928, 4928, 4928, 4928, 4928, 8064, 4928, 14976,
   342         -    4928, 15008, 15040, 15072, 4928, 15104, 4928, 4928, 15136, 1824, 1824,
   343         -    1824, 1824, 15168, 4928, 4928, 15200, 15232, 1824, 1824, 1824, 1824,
   344         -    15264, 15296, 15328, 15360, 15392, 15424, 15456, 15488, 15520, 15552,
   345         -    15584, 15616, 15648, 15264, 15296, 15680, 15360, 15712, 15744, 15776,
   346         -    15488, 15808, 15840, 15872, 15904, 15936, 15968, 16000, 16032, 16064,
   347         -    16096, 16128, 4928, 4928, 4928, 4928, 4928, 4928, 4928, 4928, 4928,
   348         -    4928, 4928, 4928, 4928, 4928, 4928, 4928, 704, 16160, 704, 16192, 16224,
   349         -    16256, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
          358  +    1824, 1824, 1824, 1344, 1344, 1344, 1344, 1344, 1344, 16672, 1824,
          359  +    16704, 16736, 16768, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   350    360       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   351         -    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   352         -    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 16288, 16320, 1824,
   353         -    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   354         -    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   355         -    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   356         -    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   357         -    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   358         -    1824, 1344, 1344, 1344, 1344, 1344, 1344, 16352, 1824, 16384, 16416,
   359         -    16448, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   360         -    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   361         -    1824, 1824, 16480, 6880, 16512, 1824, 1824, 1824, 1824, 1824, 1824,
   362         -    1824, 1824, 1824, 1824, 16544, 16576, 16608, 16640, 16672, 16704, 1824,
   363         -    16736, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 4928, 16768,
   364         -    4928, 4928, 8032, 16800, 16832, 8064, 16864, 4928, 4928, 16768, 4928,
   365         -    16896, 1824, 16928, 16960, 16992, 17024, 17056, 1824, 1824, 1824, 1824,
   366         -    4928, 4928, 4928, 4928, 4928, 4928, 4928, 17088, 4928, 4928, 4928,
          361  +    1824, 1824, 1824, 1824, 16800, 6880, 16832, 1824, 1824, 16864, 16896,
          362  +    1824, 1824, 1824, 1824, 1824, 1824, 16928, 16960, 16992, 17024, 17056,
          363  +    17088, 1824, 17120, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
          364  +    4928, 17152, 4928, 4928, 7968, 17184, 17216, 8000, 17248, 4928, 4928,
          365  +    17280, 4928, 17312, 1824, 17344, 17376, 17408, 17440, 17472, 1824,
          366  +    1824, 1824, 1824, 4928, 4928, 4928, 4928, 4928, 4928, 4928, 17504,
   367    367       4928, 4928, 4928, 4928, 4928, 4928, 4928, 4928, 4928, 4928, 4928, 4928,
   368         -    4928, 4928, 4928, 4928, 4928, 4928, 4928, 17120, 17152, 4928, 4928,
   369         -    4928, 8032, 4928, 4928, 17184, 1824, 16768, 4928, 17216, 4928, 17248,
   370         -    17280, 1824, 1824, 16768, 7552, 4928, 17312, 4928, 17344, 16960, 4928,
   371         -    1824, 1824, 1824, 17280, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
          368  +    4928, 4928, 4928, 4928, 4928, 4928, 4928, 4928, 4928, 4928, 8000, 17536,
          369  +    4928, 4928, 4928, 7968, 4928, 4928, 17568, 17600, 17152, 4928, 17632,
          370  +    4928, 17664, 17696, 1824, 1824, 17728, 4928, 4928, 17760, 4928, 17792,
          371  +    17824, 4928, 4928, 4928, 7968, 17856, 17888, 1824, 1824, 1824, 1824,
   372    372       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   373    373       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   374    374       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   375         -    1824, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   376         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   377         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   378         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   379         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   380         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   381         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   382         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   383         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   384         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   385         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   386         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   387         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   388         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   389         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   390         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   391         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   392         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   393         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   394         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   395         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   396         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   397         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   398         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   399         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   400         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   401         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   402         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   403         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   404         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   405         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   406         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   407         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   408         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   409         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   410         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   411         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   412         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   413         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   414         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   415         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   416         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          375  +    1824, 1824, 1824, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          376  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          377  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          378  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          379  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          380  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          381  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          382  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          383  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          384  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          385  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          386  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          387  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          388  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          389  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          390  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          391  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          392  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          393  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          394  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          395  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          396  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          397  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          398  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          399  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          400  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          401  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          402  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          403  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          404  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          405  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          406  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          407  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          408  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          409  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          410  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          411  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          412  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          413  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          414  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          415  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          416  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          417  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          418  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          419  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          420  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          421  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          422  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          423  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          424  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          425  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          426  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          427  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          428  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          429  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          430  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          431  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          432  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          433  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          434  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          435  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          436  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          437  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          438  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          439  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          440  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          441  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          442  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          443  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          444  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          445  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          446  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          447  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          448  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          449  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          450  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          451  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          452  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          453  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          454  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          455  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          456  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          457  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          458  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          459  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          460  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          461  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          462  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          463  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          464  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          465  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          466  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          467  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          468  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          469  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          470  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          471  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          472  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          473  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          474  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          475  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          476  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          477  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          478  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          479  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          480  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          481  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          482  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          483  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          484  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          485  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          486  +    1344, 1344, 1344, 1344, 1344, 7776, 1824, 1344, 1344, 1344, 1344, 1344,
          487  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          488  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          489  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          490  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          491  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          492  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          493  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          494  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          495  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          496  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          497  +    1344, 1344, 1344, 1344, 17920, 1344, 1344, 1344, 1344, 1344, 1344,
          498  +    11360, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          499  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          500  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          501  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          502  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          503  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          504  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          505  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          506  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          507  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          508  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          509  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          510  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          511  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          512  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          513  +    1344, 1344, 17952, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   417    514       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   418    515       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   419    516       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   420    517       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   421    518       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   422    519       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   423    520       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
................................................................................
   428    525       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   429    526       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   430    527       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   431    528       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   432    529       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   433    530       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   434    531       1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   435         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   436         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   437         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   438         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   439         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   440         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   441         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   442         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   443         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   444         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   445         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   446         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   447         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   448         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   449         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   450         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   451         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   452         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   453         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   454         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   455         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   456         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   457         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   458         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   459         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   460         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   461         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   462         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   463         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   464         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   465         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   466         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   467         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   468         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   469         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   470         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   471         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   472         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   473         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   474         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   475         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   476         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   477         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   478         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   479         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   480         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   481         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   482         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   483         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   484         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   485         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   486         -    1344, 1344, 1344, 7840, 1824, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   487         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   488         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   489         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   490         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   491         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   492         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   493         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   494         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   495         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   496         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   497         -    1344, 1344, 17376, 1344, 1344, 1344, 1344, 1344, 1344, 11360, 1344,
   498         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   499         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   500         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   501         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   502         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   503         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   504         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   505         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   506         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   507         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   508         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   509         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   510         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   511         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   512         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 17408,
   513         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   514         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   515         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   516         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   517         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   518         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   519         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   520         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   521         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   522         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   523         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   524         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   525         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   526         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   527         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   528         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   529         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   530         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   531         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
   532         -    1344, 1344, 1344, 1344, 1344, 17440, 1824, 1824, 1824, 1824, 1824,
          532  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 17984, 1824,
   533    533       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   534    534       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   535    535       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   536    536       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   537    537       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   538    538       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   539    539       1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824,
   540         -    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1344, 1344, 1344, 1344, 1344,
   541         -    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 11360
          540  +    1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1824, 1344,
          541  +    1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 1344,
          542  +    1344, 1344, 1344, 11360
   542    543   #endif /* TCL_UTF_MAX > 3 */
   543    544   };
   544    545   
   545    546   /*
   546    547    * The groupMap is indexed by combining the alternate page number with
   547    548    * the page offset and returns a group number that identifies a unique
   548    549    * set of character attributes.
................................................................................
   577    578       24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24,
   578    579       21, 48, 49, 50, 23, 24, 52, 53, 23, 24, 23, 24, 23, 24, 23, 24, 54,
   579    580       21, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24,
   580    581       23, 24, 21, 21, 21, 21, 21, 21, 55, 23, 24, 56, 57, 58, 58, 23, 24,
   581    582       59, 60, 61, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 62, 63, 64, 65,
   582    583       66, 21, 67, 67, 21, 68, 21, 69, 70, 21, 21, 21, 67, 71, 21, 72, 21,
   583    584       73, 74, 21, 75, 76, 74, 77, 78, 21, 21, 76, 21, 79, 80, 21, 21, 81,
   584         -    21, 21, 21, 21, 21, 21, 21, 82, 21, 21, 83, 21, 21, 83, 21, 21, 21,
   585         -    84, 83, 85, 86, 86, 87, 21, 21, 21, 21, 21, 88, 21, 15, 21, 21, 21,
   586         -    21, 21, 21, 21, 21, 89, 90, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
   587         -    21, 21, 21, 21, 21, 21, 21, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
   588         -    91, 91, 91, 91, 91, 91, 91, 91, 11, 11, 11, 11, 91, 91, 91, 91, 91,
   589         -    91, 91, 91, 91, 91, 91, 91, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
   590         -    11, 11, 11, 11, 91, 91, 91, 91, 91, 11, 11, 11, 11, 11, 11, 11, 91,
   591         -    11, 91, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
   592         -    11, 11, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
   593         -    92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
   594         -    92, 92, 92, 92, 92, 93, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
   595         -    92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
   596         -    92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 23, 24, 23,
   597         -    24, 91, 11, 23, 24, 0, 0, 91, 42, 42, 42, 3, 94, 0, 0, 0, 0, 11, 11,
   598         -    95, 3, 96, 96, 96, 0, 97, 0, 98, 98, 21, 10, 10, 10, 10, 10, 10, 10,
          585  +    21, 21, 21, 21, 21, 21, 21, 82, 21, 21, 83, 21, 84, 83, 21, 21, 21,
          586  +    85, 83, 86, 87, 87, 88, 21, 21, 21, 21, 21, 89, 21, 15, 21, 21, 21,
          587  +    21, 21, 21, 21, 21, 90, 91, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
          588  +    21, 21, 21, 21, 21, 21, 21, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
          589  +    92, 92, 92, 92, 92, 92, 92, 92, 11, 11, 11, 11, 92, 92, 92, 92, 92,
          590  +    92, 92, 92, 92, 92, 92, 92, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
          591  +    11, 11, 11, 11, 92, 92, 92, 92, 92, 11, 11, 11, 11, 11, 11, 11, 92,
          592  +    11, 92, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
          593  +    11, 11, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
          594  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
          595  +    93, 93, 93, 93, 93, 94, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
          596  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
          597  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 23, 24, 23,
          598  +    24, 92, 11, 23, 24, 0, 0, 92, 42, 42, 42, 3, 95, 0, 0, 0, 0, 11, 11,
          599  +    96, 3, 97, 97, 97, 0, 98, 0, 99, 99, 21, 10, 10, 10, 10, 10, 10, 10,
   599    600       10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 10, 10, 10, 10, 10, 10,
   600         -    10, 10, 10, 99, 100, 100, 100, 21, 13, 13, 13, 13, 13, 13, 13, 13,
   601         -    13, 13, 13, 13, 13, 13, 13, 13, 13, 101, 13, 13, 13, 13, 13, 13, 13,
   602         -    13, 13, 102, 103, 103, 104, 105, 106, 107, 107, 107, 108, 109, 110,
          601  +    10, 10, 10, 100, 101, 101, 101, 21, 13, 13, 13, 13, 13, 13, 13, 13,
          602  +    13, 13, 13, 13, 13, 13, 13, 13, 13, 102, 13, 13, 13, 13, 13, 13, 13,
          603  +    13, 13, 103, 104, 104, 105, 106, 107, 108, 108, 108, 109, 110, 111,
   603    604       23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23,
   604         -    24, 23, 24, 23, 24, 23, 24, 111, 112, 113, 114, 115, 116, 7, 23, 24,
   605         -    117, 23, 24, 21, 54, 54, 54, 118, 118, 118, 118, 118, 118, 118, 118,
   606         -    118, 118, 118, 118, 118, 118, 118, 118, 10, 10, 10, 10, 10, 10, 10,
          605  +    24, 23, 24, 23, 24, 23, 24, 112, 113, 114, 115, 116, 117, 7, 23, 24,
          606  +    118, 23, 24, 21, 54, 54, 54, 119, 119, 119, 119, 119, 119, 119, 119,
          607  +    119, 119, 119, 119, 119, 119, 119, 119, 10, 10, 10, 10, 10, 10, 10,
   607    608       10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
   608    609       10, 10, 10, 10, 10, 10, 10, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13,
   609    610       13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
   610         -    13, 13, 13, 13, 13, 13, 112, 112, 112, 112, 112, 112, 112, 112, 112,
   611         -    112, 112, 112, 112, 112, 112, 112, 23, 24, 14, 92, 92, 92, 92, 92,
   612         -    119, 119, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23,
   613         -    24, 23, 24, 23, 24, 23, 24, 120, 23, 24, 23, 24, 23, 24, 23, 24, 23,
   614         -    24, 23, 24, 23, 24, 121, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23,
          611  +    13, 13, 13, 13, 13, 13, 113, 113, 113, 113, 113, 113, 113, 113, 113,
          612  +    113, 113, 113, 113, 113, 113, 113, 23, 24, 14, 93, 93, 93, 93, 93,
          613  +    120, 120, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23,
          614  +    24, 23, 24, 23, 24, 23, 24, 121, 23, 24, 23, 24, 23, 24, 23, 24, 23,
          615  +    24, 23, 24, 23, 24, 122, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23,
   615    616       24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24,
   616         -    23, 24, 23, 24, 0, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
   617         -    122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
   618         -    122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
   619         -    0, 0, 91, 3, 3, 3, 3, 3, 3, 21, 123, 123, 123, 123, 123, 123, 123,
          617  +    23, 24, 23, 24, 0, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
   620    618       123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
   621    619       123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
   622         -    123, 123, 123, 21, 21, 3, 8, 0, 0, 14, 14, 4, 0, 92, 92, 92, 92, 92,
   623         -    92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
   624         -    92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
   625         -    92, 92, 92, 92, 92, 92, 8, 92, 3, 92, 92, 3, 92, 92, 3, 92, 0, 0, 0,
          620  +    0, 0, 92, 3, 3, 3, 3, 3, 3, 21, 124, 124, 124, 124, 124, 124, 124,
          621  +    124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124,
          622  +    124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124,
          623  +    124, 124, 124, 21, 21, 3, 8, 0, 0, 14, 14, 4, 0, 93, 93, 93, 93, 93,
          624  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
          625  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
          626  +    93, 93, 93, 93, 93, 93, 8, 93, 3, 93, 93, 3, 93, 93, 3, 93, 0, 0, 0,
   626    627       0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   627    628       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0,
   628    629       15, 15, 15, 15, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 17, 17,
   629         -    17, 17, 17, 7, 7, 7, 3, 3, 4, 3, 3, 14, 14, 92, 92, 92, 92, 92, 92,
   630         -    92, 92, 92, 92, 92, 3, 17, 0, 3, 3, 15, 15, 15, 15, 15, 15, 15, 15,
          630  +    17, 17, 17, 7, 7, 7, 3, 3, 4, 3, 3, 14, 14, 93, 93, 93, 93, 93, 93,
          631  +    93, 93, 93, 93, 93, 3, 17, 0, 3, 3, 15, 15, 15, 15, 15, 15, 15, 15,
   631    632       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   632         -    15, 15, 15, 15, 15, 15, 15, 91, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   633         -    15, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
   634         -    92, 92, 92, 92, 92, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 3, 3, 3, 15, 15,
   635         -    92, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          633  +    15, 15, 15, 15, 15, 15, 15, 92, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          634  +    15, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
          635  +    93, 93, 93, 93, 93, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 3, 3, 3, 15, 15,
          636  +    93, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   636    637       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   637         -    15, 15, 3, 15, 92, 92, 92, 92, 92, 92, 92, 17, 14, 92, 92, 92, 92,
   638         -    92, 92, 91, 91, 92, 92, 14, 92, 92, 92, 92, 15, 15, 9, 9, 9, 9, 9,
          638  +    15, 15, 3, 15, 93, 93, 93, 93, 93, 93, 93, 17, 14, 93, 93, 93, 93,
          639  +    93, 93, 92, 92, 93, 93, 14, 93, 93, 93, 93, 15, 15, 9, 9, 9, 9, 9,
   639    640       9, 9, 9, 9, 9, 15, 15, 15, 14, 14, 15, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   640         -    3, 3, 3, 3, 0, 17, 15, 92, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          641  +    3, 3, 3, 3, 0, 17, 15, 93, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   641    642       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   642         -    15, 15, 15, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
   643         -    92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 0, 0, 15, 15, 15,
          643  +    15, 15, 15, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
          644  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 0, 0, 15, 15, 15,
   644    645       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   645         -    15, 15, 15, 15, 15, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 15,
          646  +    15, 15, 15, 15, 15, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 15,
   646    647       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9,
   647    648       9, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   648    649       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   649         -    92, 92, 92, 92, 92, 92, 92, 92, 92, 91, 91, 14, 3, 3, 3, 91, 0, 0,
   650         -    92, 4, 4, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   651         -    15, 15, 15, 15, 15, 15, 15, 92, 92, 92, 92, 91, 92, 92, 92, 92, 92,
   652         -    92, 92, 92, 92, 91, 92, 92, 92, 91, 92, 92, 92, 92, 92, 0, 0, 3, 3,
          650  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 92, 92, 14, 3, 3, 3, 92, 0, 0,
          651  +    93, 4, 4, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          652  +    15, 15, 15, 15, 15, 15, 15, 93, 93, 93, 93, 92, 93, 93, 93, 93, 93,
          653  +    93, 93, 93, 93, 92, 93, 93, 93, 92, 93, 93, 93, 93, 93, 0, 0, 3, 3,
   653    654       3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 15, 15, 15, 15, 15, 15, 15,
   654    655       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   655         -    15, 92, 92, 92, 0, 0, 3, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          656  +    15, 93, 93, 93, 0, 0, 3, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   656    657       15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   657    658       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   658    659       0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   659    660       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15,
   660    661       15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   661         -    0, 0, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 17,
   662         -    92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
   663         -    92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 124, 15,
          662  +    0, 0, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 17,
          663  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
          664  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 125, 15,
   664    665       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   665    666       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   666    667       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   667         -    15, 15, 92, 124, 92, 15, 124, 124, 124, 92, 92, 92, 92, 92, 92, 92,
   668         -    92, 124, 124, 124, 124, 92, 124, 124, 15, 92, 92, 92, 92, 92, 92, 92,
   669         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 92, 92, 3, 3, 9, 9, 9, 9, 9,
   670         -    9, 9, 9, 9, 9, 3, 91, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   671         -    15, 15, 15, 92, 124, 124, 0, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0,
          668  +    15, 15, 93, 125, 93, 15, 125, 125, 125, 93, 93, 93, 93, 93, 93, 93,
          669  +    93, 125, 125, 125, 125, 93, 125, 125, 15, 93, 93, 93, 93, 93, 93, 93,
          670  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 93, 93, 3, 3, 9, 9, 9, 9, 9,
          671  +    9, 9, 9, 9, 9, 3, 92, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          672  +    15, 15, 15, 93, 125, 125, 0, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0,
   672    673       15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   673    674       15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 0, 15,
   674         -    0, 0, 0, 15, 15, 15, 15, 0, 0, 92, 15, 124, 124, 124, 92, 92, 92, 92,
   675         -    0, 0, 124, 124, 0, 0, 124, 124, 92, 15, 0, 0, 0, 0, 0, 0, 0, 0, 124,
   676         -    0, 0, 0, 0, 15, 15, 0, 15, 15, 15, 92, 92, 0, 0, 9, 9, 9, 9, 9, 9,
   677         -    9, 9, 9, 9, 15, 15, 4, 4, 18, 18, 18, 18, 18, 18, 14, 4, 15, 3, 92,
   678         -    0, 0, 92, 92, 124, 0, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 15, 15, 0,
          675  +    0, 0, 0, 15, 15, 15, 15, 0, 0, 93, 15, 125, 125, 125, 93, 93, 93, 93,
          676  +    0, 0, 125, 125, 0, 0, 125, 125, 93, 15, 0, 0, 0, 0, 0, 0, 0, 0, 125,
          677  +    0, 0, 0, 0, 15, 15, 0, 15, 15, 15, 93, 93, 0, 0, 9, 9, 9, 9, 9, 9,
          678  +    9, 9, 9, 9, 15, 15, 4, 4, 18, 18, 18, 18, 18, 18, 14, 4, 15, 3, 93,
          679  +    0, 0, 93, 93, 125, 0, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 15, 15, 0,
   679    680       0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   680    681       15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 0,
   681         -    15, 15, 0, 15, 15, 0, 0, 92, 0, 124, 124, 124, 92, 92, 0, 0, 0, 0,
   682         -    92, 92, 0, 0, 92, 92, 92, 0, 0, 0, 92, 0, 0, 0, 0, 0, 0, 0, 15, 15,
   683         -    15, 15, 0, 15, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 92,
   684         -    92, 15, 15, 15, 92, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 92, 92, 124, 0,
          682  +    15, 15, 0, 15, 15, 0, 0, 93, 0, 125, 125, 125, 93, 93, 0, 0, 0, 0,
          683  +    93, 93, 0, 0, 93, 93, 93, 0, 0, 0, 93, 0, 0, 0, 0, 0, 0, 0, 15, 15,
          684  +    15, 15, 0, 15, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 93,
          685  +    93, 15, 15, 15, 93, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 93, 93, 125, 0,
   685    686       15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 0, 15, 15, 15, 15,
   686    687       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   687    688       15, 0, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 0, 15, 15, 15, 15, 15,
   688         -    0, 0, 92, 15, 124, 124, 124, 92, 92, 92, 92, 92, 0, 92, 92, 124, 0,
   689         -    124, 124, 92, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   690         -    15, 15, 92, 92, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 4, 0, 0, 0,
   691         -    0, 0, 0, 0, 15, 92, 92, 92, 92, 92, 92, 0, 92, 124, 124, 0, 15, 15,
          689  +    0, 0, 93, 15, 125, 125, 125, 93, 93, 93, 93, 93, 0, 93, 93, 125, 0,
          690  +    125, 125, 93, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          691  +    15, 15, 93, 93, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 4, 0, 0, 0,
          692  +    0, 0, 0, 0, 15, 93, 93, 93, 93, 93, 93, 0, 93, 125, 125, 0, 15, 15,
   692    693       15, 15, 15, 15, 15, 15, 0, 0, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15,
   693    694       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0,
   694    695       15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 0, 15, 15, 15, 15, 15, 0, 0,
   695         -    92, 15, 124, 92, 124, 92, 92, 92, 92, 0, 0, 124, 124, 0, 0, 124, 124,
   696         -    92, 0, 0, 0, 0, 0, 0, 0, 0, 92, 124, 0, 0, 0, 0, 15, 15, 0, 15, 15,
   697         -    15, 92, 92, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 14, 15, 18, 18, 18,
   698         -    18, 18, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 92, 15, 0, 15, 15, 15, 15,
          696  +    93, 15, 125, 93, 125, 93, 93, 93, 93, 0, 0, 125, 125, 0, 0, 125, 125,
          697  +    93, 0, 0, 0, 0, 0, 0, 0, 0, 93, 125, 0, 0, 0, 0, 15, 15, 0, 15, 15,
          698  +    15, 93, 93, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 14, 15, 18, 18, 18,
          699  +    18, 18, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 93, 15, 0, 15, 15, 15, 15,
   699    700       15, 15, 0, 0, 0, 15, 15, 15, 0, 15, 15, 15, 15, 0, 0, 0, 15, 15, 0,
   700    701       15, 0, 15, 15, 0, 0, 0, 15, 15, 0, 0, 0, 15, 15, 15, 0, 0, 0, 15, 15,
   701         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 124, 124, 92, 124,
   702         -    124, 0, 0, 0, 124, 124, 124, 0, 124, 124, 124, 92, 0, 0, 15, 0, 0,
   703         -    0, 0, 0, 0, 124, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9,
          702  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 125, 125, 93, 125,
          703  +    125, 0, 0, 0, 125, 125, 125, 0, 125, 125, 125, 93, 0, 0, 15, 0, 0,
          704  +    0, 0, 0, 0, 125, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9,
   704    705       9, 9, 9, 9, 9, 9, 9, 18, 18, 18, 14, 14, 14, 14, 14, 14, 4, 14, 0,
   705         -    0, 0, 0, 0, 92, 124, 124, 124, 92, 15, 15, 15, 15, 15, 15, 15, 15,
          706  +    0, 0, 0, 0, 93, 125, 125, 125, 93, 15, 15, 15, 15, 15, 15, 15, 15,
   706    707       0, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   707    708       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15,
   708         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 15, 92, 92, 92, 124,
   709         -    124, 124, 124, 0, 92, 92, 92, 0, 92, 92, 92, 92, 0, 0, 0, 0, 0, 0,
   710         -    0, 92, 92, 0, 15, 15, 15, 0, 0, 0, 0, 0, 15, 15, 92, 92, 0, 0, 9, 9,
   711         -    9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 18, 18, 18, 18, 18,
   712         -    18, 18, 14, 15, 92, 124, 124, 3, 15, 15, 15, 15, 15, 15, 15, 15, 0,
          709  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 15, 93, 93, 93, 125,
          710  +    125, 125, 125, 0, 93, 93, 93, 0, 93, 93, 93, 93, 0, 0, 0, 0, 0, 0,
          711  +    0, 93, 93, 0, 15, 15, 15, 0, 0, 0, 0, 0, 15, 15, 93, 93, 0, 0, 9, 9,
          712  +    9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 3, 18, 18, 18, 18, 18,
          713  +    18, 18, 14, 15, 93, 125, 125, 3, 15, 15, 15, 15, 15, 15, 15, 15, 0,
   713    714       15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   714    715       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15,
   715         -    15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 0, 0, 92, 15, 124, 92, 124,
   716         -    124, 124, 124, 124, 0, 92, 124, 124, 0, 124, 124, 92, 92, 0, 0, 0,
   717         -    0, 0, 0, 0, 124, 124, 0, 0, 0, 0, 0, 0, 0, 15, 0, 15, 15, 92, 92, 0,
          716  +    15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 0, 0, 93, 15, 125, 93, 125,
          717  +    125, 125, 125, 125, 0, 93, 125, 125, 0, 125, 125, 93, 93, 0, 0, 0,
          718  +    0, 0, 0, 0, 125, 125, 0, 0, 0, 0, 0, 0, 0, 15, 0, 15, 15, 93, 93, 0,
   718    719       0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0,
   719         -    0, 0, 0, 0, 0, 92, 92, 124, 124, 0, 15, 15, 15, 15, 15, 15, 15, 15,
          720  +    0, 0, 0, 0, 0, 93, 93, 125, 125, 0, 15, 15, 15, 15, 15, 15, 15, 15,
   720    721       0, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   721    722       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   722         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 92, 92, 15, 124, 124, 124,
   723         -    92, 92, 92, 92, 0, 124, 124, 124, 0, 124, 124, 124, 92, 15, 14, 0,
   724         -    0, 0, 0, 15, 15, 15, 124, 18, 18, 18, 18, 18, 18, 18, 15, 15, 15, 92,
   725         -    92, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 18, 18, 18, 18, 18, 18, 18,
   726         -    18, 18, 14, 15, 15, 15, 15, 15, 15, 0, 0, 124, 124, 0, 15, 15, 15,
          723  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 93, 93, 15, 125, 125, 125,
          724  +    93, 93, 93, 93, 0, 125, 125, 125, 0, 125, 125, 125, 93, 15, 14, 0,
          725  +    0, 0, 0, 15, 15, 15, 125, 18, 18, 18, 18, 18, 18, 18, 15, 15, 15, 93,
          726  +    93, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 18, 18, 18, 18, 18, 18, 18,
          727  +    18, 18, 14, 15, 15, 15, 15, 15, 15, 0, 0, 125, 125, 0, 15, 15, 15,
   727    728       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0,
   728    729       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   729    730       15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   730         -    0, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 92, 0, 0, 0, 0, 124,
   731         -    124, 124, 92, 92, 92, 0, 92, 0, 124, 124, 124, 124, 124, 124, 124,
   732         -    124, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 124, 124,
          731  +    0, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 93, 0, 0, 0, 0, 125,
          732  +    125, 125, 93, 93, 93, 0, 93, 0, 125, 125, 125, 125, 125, 125, 125,
          733  +    125, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 125, 125,
   733    734       3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15,
   734    735       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   735    736       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   736         -    15, 15, 15, 15, 15, 15, 15, 92, 15, 15, 92, 92, 92, 92, 92, 92, 92,
   737         -    0, 0, 0, 0, 4, 15, 15, 15, 15, 15, 15, 91, 92, 92, 92, 92, 92, 92,
   738         -    92, 92, 3, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 3, 0, 0, 0, 0, 0, 15, 15,
   739         -    0, 15, 0, 0, 15, 15, 0, 15, 0, 0, 15, 0, 0, 0, 0, 0, 0, 15, 15, 15,
   740         -    15, 0, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 0, 15, 0, 15, 0,
   741         -    0, 15, 15, 0, 15, 15, 15, 15, 92, 15, 15, 92, 92, 92, 92, 92, 92, 0,
   742         -    92, 92, 15, 0, 0, 15, 15, 15, 15, 15, 0, 91, 0, 92, 92, 92, 92, 92,
   743         -    92, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 15, 15, 15, 15, 15, 14,
   744         -    14, 14, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 14, 3, 14, 14,
   745         -    14, 92, 92, 14, 14, 14, 14, 14, 14, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 18,
   746         -    18, 18, 18, 18, 18, 18, 18, 18, 18, 14, 92, 14, 92, 14, 92, 5, 6, 5,
   747         -    6, 124, 124, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15,
   748         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   749         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0,
   750         -    92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 124, 92, 92,
   751         -    92, 92, 92, 3, 92, 92, 15, 15, 15, 15, 15, 92, 92, 92, 92, 92, 92,
   752         -    92, 92, 92, 92, 92, 0, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
   753         -    92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
   754         -    92, 92, 92, 92, 92, 92, 92, 92, 0, 14, 14, 14, 14, 14, 14, 14, 14,
   755         -    92, 14, 14, 14, 14, 14, 14, 0, 14, 14, 3, 3, 3, 3, 3, 14, 14, 14, 14,
   756         -    3, 3, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 124,
   757         -    124, 92, 92, 92, 92, 124, 92, 92, 92, 92, 92, 92, 124, 92, 92, 124,
   758         -    124, 92, 92, 15, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 3, 3, 3, 3, 3, 15,
   759         -    15, 15, 15, 15, 15, 124, 124, 92, 92, 15, 15, 15, 15, 92, 92, 92, 15,
   760         -    124, 124, 124, 15, 15, 124, 124, 124, 124, 124, 124, 124, 15, 15, 15,
   761         -    92, 92, 92, 92, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   762         -    92, 124, 124, 92, 92, 124, 124, 124, 124, 124, 124, 92, 15, 124, 9,
   763         -    9, 9, 9, 9, 9, 9, 9, 9, 9, 124, 124, 124, 92, 14, 14, 125, 125, 125,
   764         -    125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125,
   765         -    125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125,
   766         -    125, 125, 125, 125, 125, 125, 125, 0, 125, 0, 0, 0, 0, 0, 125, 0, 0,
          737  +    15, 15, 15, 15, 15, 15, 15, 93, 15, 15, 93, 93, 93, 93, 93, 93, 93,
          738  +    0, 0, 0, 0, 4, 15, 15, 15, 15, 15, 15, 92, 93, 93, 93, 93, 93, 93,
          739  +    93, 93, 3, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 3, 0, 0, 0, 0, 0, 15, 15,
          740  +    0, 15, 0, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          741  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15,
          742  +    0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 93, 15, 15, 93, 93, 93,
          743  +    93, 93, 93, 93, 93, 93, 15, 0, 0, 15, 15, 15, 15, 15, 0, 92, 0, 93,
          744  +    93, 93, 93, 93, 93, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 15, 15,
          745  +    15, 15, 15, 14, 14, 14, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
          746  +    14, 3, 14, 14, 14, 93, 93, 14, 14, 14, 14, 14, 14, 9, 9, 9, 9, 9, 9,
          747  +    9, 9, 9, 9, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 14, 93, 14, 93,
          748  +    14, 93, 5, 6, 5, 6, 125, 125, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15,
          749  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          750  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          751  +    15, 0, 0, 0, 0, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
          752  +    93, 125, 93, 93, 93, 93, 93, 3, 93, 93, 15, 15, 15, 15, 15, 93, 93,
          753  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 0, 93, 93, 93, 93, 93, 93, 93,
          754  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
          755  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 0, 14, 14, 14, 14,
          756  +    14, 14, 14, 14, 93, 14, 14, 14, 14, 14, 14, 0, 14, 14, 3, 3, 3, 3,
          757  +    3, 14, 14, 14, 14, 3, 3, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15,
          758  +    15, 15, 15, 15, 125, 125, 93, 93, 93, 93, 125, 93, 93, 93, 93, 93,
          759  +    93, 125, 93, 93, 125, 125, 93, 93, 15, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
          760  +    3, 3, 3, 3, 3, 3, 15, 15, 15, 15, 15, 15, 125, 125, 93, 93, 15, 15,
          761  +    15, 15, 93, 93, 93, 15, 125, 125, 125, 15, 15, 125, 125, 125, 125,
          762  +    125, 125, 125, 15, 15, 15, 93, 93, 93, 93, 15, 15, 15, 15, 15, 15,
          763  +    15, 15, 15, 15, 15, 15, 15, 93, 125, 125, 93, 93, 125, 125, 125, 125,
          764  +    125, 125, 93, 15, 125, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 125, 125, 125,
          765  +    93, 14, 14, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
   767    766       126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
   768         -    126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
   769         -    126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
   770         -    126, 3, 91, 126, 126, 126, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15,
   771         -    15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15, 0, 15, 0, 15, 15, 15,
   772         -    15, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 0,
   773         -    0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   774         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   775         -    0, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15, 0, 15, 0, 15,
   776         -    15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   777         -    15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   778         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 0, 0,
   779         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   780         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   781         -    15, 0, 0, 92, 92, 92, 3, 3, 3, 3, 3, 3, 3, 3, 3, 18, 18, 18, 18, 18,
   782         -    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0,
   783         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 14,
   784         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 127, 127, 127,
          767  +    126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, 0,
          768  +    126, 0, 0, 0, 0, 0, 126, 0, 0, 127, 127, 127, 127, 127, 127, 127, 127,
   785    769       127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
   786    770       127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
   787         -    127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
   788         -    127, 127, 127, 104, 104, 104, 104, 104, 104, 0, 0, 110, 110, 110, 110,
   789         -    110, 110, 0, 0, 8, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   790         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   791         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 3, 3, 15,
   792         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 2,
   793         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   794         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 5, 6, 0, 0, 0, 15, 15, 15, 15,
   795         -    15, 15, 15, 15, 15, 15, 15, 3, 3, 3, 128, 128, 128, 15, 15, 15, 15,
   796         -    15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15,
   797         -    15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 92, 92, 92, 0, 0, 0, 0, 0, 0,
   798         -    0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   799         -    15, 15, 15, 15, 15, 92, 92, 92, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15,
   800         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   801         -    92, 92, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15,
   802         -    15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 0, 92, 92, 0, 0, 0, 0, 0,
   803         -    0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   804         -    15, 15, 15, 15, 15, 15, 15, 15, 92, 92, 124, 92, 92, 92, 92, 92, 92,
   805         -    92, 124, 124, 124, 124, 124, 124, 124, 124, 92, 124, 124, 92, 92, 92,
   806         -    92, 92, 92, 92, 92, 92, 92, 92, 3, 3, 3, 91, 3, 3, 3, 4, 15, 92, 0,
   807         -    0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 18, 18, 18, 18,
   808         -    18, 18, 18, 18, 18, 18, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 8, 3, 3,
   809         -    3, 3, 92, 92, 92, 17, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0,
   810         -    0, 0, 15, 15, 15, 91, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   811         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   812         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   813         -    15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15,
   814         -    92, 92, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   815         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   816         -    15, 15, 92, 15, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   817         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   818         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0,
   819         -    0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          771  +    127, 127, 127, 127, 127, 127, 127, 3, 92, 127, 127, 127, 15, 15, 15,
          772  +    15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15, 15,
          773  +    15, 15, 0, 15, 0, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15,
          774  +    15, 15, 0, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          775  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          776  +    15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15,
          777  +    15, 15, 15, 0, 15, 0, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15,
          778  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15,
          779  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          780  +    15, 0, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          781  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          782  +    15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 93, 93, 93, 3, 3, 3, 3, 3, 3,
          783  +    3, 3, 3, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
          784  +    18, 18, 18, 18, 18, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          785  +    15, 15, 15, 15, 15, 15, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0,
          786  +    0, 0, 0, 0, 0, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
          787  +    128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
          788  +    128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
          789  +    128, 128, 128, 128, 128, 128, 128, 128, 128, 105, 105, 105, 105, 105,
          790  +    105, 0, 0, 111, 111, 111, 111, 111, 111, 0, 0, 8, 15, 15, 15, 15, 15,
          791  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          792  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          793  +    15, 15, 15, 15, 15, 14, 3, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          794  +    15, 15, 15, 15, 15, 15, 15, 2, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          795  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          796  +    5, 6, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 3, 3, 3,
          797  +    129, 129, 129, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0,
          798  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15,
          799  +    15, 93, 93, 93, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15,
          800  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 93, 93, 93, 3,
          801  +    3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          802  +    15, 15, 15, 15, 15, 15, 15, 15, 93, 93, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          803  +    0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15,
          804  +    15, 15, 0, 93, 93, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15,
          805  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          806  +    93, 93, 125, 93, 93, 93, 93, 93, 93, 93, 125, 125, 125, 125, 125, 125,
          807  +    125, 125, 93, 125, 125, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
          808  +    3, 3, 3, 92, 3, 3, 3, 4, 15, 93, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
          809  +    0, 0, 0, 0, 0, 0, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0,
          810  +    0, 0, 0, 3, 3, 3, 3, 3, 3, 8, 3, 3, 3, 3, 93, 93, 93, 17, 0, 9, 9,
          811  +    9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 15, 15, 15, 92, 15, 15, 15,
          812  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          813  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   820    814       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0,
   821         -    92, 92, 92, 124, 124, 124, 124, 92, 92, 124, 124, 124, 0, 0, 0, 0,
   822         -    124, 124, 92, 124, 124, 124, 124, 124, 124, 92, 92, 92, 0, 0, 0, 0,
   823         -    14, 0, 0, 0, 3, 3, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 15, 15, 15, 15, 15,
   824         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   825         -    15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 0, 0, 0,
   826         -    0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   827         -    15, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   828         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0,
   829         -    0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 18, 0, 0, 0, 14, 14, 14, 14, 14, 14,
   830         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   831         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15,
   832         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   833         -    92, 92, 124, 124, 92, 0, 0, 3, 3, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   834         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 124, 92, 124, 92, 92,
   835         -    92, 92, 92, 92, 92, 0, 92, 124, 92, 124, 124, 92, 92, 92, 92, 92, 92,
   836         -    92, 92, 124, 124, 124, 124, 124, 124, 92, 92, 92, 92, 92, 92, 92, 92,
   837         -    92, 92, 0, 0, 92, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 9,
   838         -    9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 91,
   839         -    3, 3, 3, 3, 3, 3, 0, 0, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
   840         -    92, 92, 92, 119, 0, 92, 92, 92, 92, 124, 15, 15, 15, 15, 15, 15, 15,
   841         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   842         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   843         -    15, 15, 15, 15, 15, 15, 92, 124, 92, 92, 92, 92, 92, 124, 92, 124,
   844         -    124, 124, 124, 124, 92, 124, 124, 15, 15, 15, 15, 15, 15, 15, 0, 0,
   845         -    0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 3, 3, 3, 3, 3, 3, 14, 14, 14,
   846         -    14, 14, 14, 14, 14, 14, 14, 92, 92, 92, 92, 92, 92, 92, 92, 92, 14,
   847         -    14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 92, 92, 124, 15, 15, 15, 15,
   848         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   849         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 124, 92, 92, 92, 92, 124, 124,
   850         -    92, 92, 124, 92, 92, 92, 15, 15, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 15,
   851         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 92, 124, 92, 92, 124, 124,
   852         -    124, 92, 124, 92, 92, 92, 124, 124, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3,
   853         -    3, 15, 15, 15, 15, 124, 124, 124, 124, 124, 124, 124, 124, 92, 92,
   854         -    92, 92, 92, 92, 92, 92, 124, 124, 92, 92, 0, 0, 0, 3, 3, 3, 3, 3, 9,
   855         -    9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 15, 15, 15, 9, 9, 9, 9, 9, 9, 9,
   856         -    9, 9, 9, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   857         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 91, 91,
   858         -    91, 91, 91, 91, 3, 3, 129, 130, 131, 132, 132, 133, 134, 135, 136,
   859         -    0, 0, 0, 0, 0, 0, 0, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
   860         -    137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
   861         -    137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137, 137,
   862         -    137, 137, 137, 137, 137, 0, 0, 137, 137, 137, 3, 3, 3, 3, 3, 3, 3,
   863         -    3, 0, 0, 0, 0, 0, 0, 0, 0, 92, 92, 92, 3, 92, 92, 92, 92, 92, 92, 92,
   864         -    92, 92, 92, 92, 92, 92, 124, 92, 92, 92, 92, 92, 92, 92, 15, 15, 15,
   865         -    15, 92, 15, 15, 15, 15, 124, 124, 92, 15, 15, 124, 92, 92, 0, 0, 0,
   866         -    0, 0, 0, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
          815  +    0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 93, 93, 15, 15, 15, 15, 15, 15,
          816  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          817  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 93, 15, 0, 0, 0, 0, 0,
          818  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          819  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          820  +    15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15,
          821  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          822  +    15, 15, 15, 15, 15, 15, 15, 15, 0, 93, 93, 93, 125, 125, 125, 125,
          823  +    93, 93, 125, 125, 125, 0, 0, 0, 0, 125, 125, 93, 125, 125, 125, 125,
          824  +    125, 125, 93, 93, 93, 0, 0, 0, 0, 14, 0, 0, 0, 3, 3, 9, 9, 9, 9, 9,
          825  +    9, 9, 9, 9, 9, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          826  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          827  +    0, 0, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15,
          828  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 15, 15, 15, 15,
          829  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          830  +    15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
          831  +    18, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          832  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          833  +    14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          834  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 93, 93, 125, 125, 93, 0, 0, 3,
          835  +    3, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          836  +    15, 15, 15, 15, 15, 125, 93, 125, 93, 93, 93, 93, 93, 93, 93, 0, 93,
          837  +    125, 93, 125, 125, 93, 93, 93, 93, 93, 93, 93, 93, 125, 125, 125, 125,
          838  +    125, 125, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 0, 0, 93, 9, 9, 9,
          839  +    9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
          840  +    0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 92, 3, 3, 3, 3, 3, 3, 0, 0,
          841  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 120, 0, 93,
          842  +    93, 93, 93, 125, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          843  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          844  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          845  +    93, 125, 93, 93, 93, 93, 93, 125, 93, 125, 125, 125, 125, 125, 93,
          846  +    125, 125, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9,
          847  +    9, 9, 9, 9, 3, 3, 3, 3, 3, 3, 3, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          848  +    14, 93, 93, 93, 93, 93, 93, 93, 93, 93, 14, 14, 14, 14, 14, 14, 14,
          849  +    14, 14, 0, 0, 0, 93, 93, 125, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          850  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          851  +    15, 15, 15, 125, 93, 93, 93, 93, 125, 125, 93, 93, 125, 93, 93, 93,
          852  +    15, 15, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 15, 15, 15, 15, 15, 15, 15, 15,
          853  +    15, 15, 15, 15, 93, 125, 93, 93, 125, 125, 125, 93, 125, 93, 93, 93,
          854  +    125, 125, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 15, 15, 15, 15, 125,
          855  +    125, 125, 125, 125, 125, 125, 125, 93, 93, 93, 93, 93, 93, 93, 93,
          856  +    125, 125, 93, 93, 0, 0, 0, 3, 3, 3, 3, 3, 9, 9, 9, 9, 9, 9, 9, 9, 9,
          857  +    9, 0, 0, 0, 15, 15, 15, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 15, 15, 15, 15,
          858  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          859  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 92, 92, 92, 92, 92, 92, 3, 3, 130,
          860  +    131, 132, 133, 133, 134, 135, 136, 137, 0, 0, 0, 0, 0, 0, 0, 138, 138,
          861  +    138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
          862  +    138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138,
          863  +    138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 0,
          864  +    0, 138, 138, 138, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 93,
          865  +    93, 93, 3, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 125,
          866  +    93, 93, 93, 93, 93, 93, 93, 15, 15, 15, 15, 93, 15, 15, 15, 15, 15,
          867  +    15, 93, 15, 15, 125, 93, 93, 15, 0, 0, 0, 0, 0, 21, 21, 21, 21, 21,
          868  +    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
   867    869       21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
   868         -    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 91, 91, 91, 91, 91,
   869         -    91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
   870         -    91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
   871         -    91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
   872         -    91, 91, 91, 91, 91, 91, 91, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
   873         -    21, 21, 21, 91, 138, 21, 21, 21, 139, 21, 21, 21, 21, 21, 21, 21, 21,
   874         -    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
   875         -    21, 21, 21, 21, 91, 91, 91, 91, 91, 92, 92, 92, 92, 92, 92, 92, 92,
          870  +    21, 21, 21, 21, 21, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
          871  +    92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
          872  +    92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
   876    873       92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
   877         -    92, 0, 92, 92, 92, 92, 92, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24,
   878         -    23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 21, 21, 21, 21, 21,
   879         -    140, 21, 21, 141, 21, 142, 142, 142, 142, 142, 142, 142, 142, 143,
   880         -    143, 143, 143, 143, 143, 143, 143, 142, 142, 142, 142, 142, 142, 0,
   881         -    0, 143, 143, 143, 143, 143, 143, 0, 0, 142, 142, 142, 142, 142, 142,
   882         -    142, 142, 143, 143, 143, 143, 143, 143, 143, 143, 142, 142, 142, 142,
   883         -    142, 142, 142, 142, 143, 143, 143, 143, 143, 143, 143, 143, 142, 142,
   884         -    142, 142, 142, 142, 0, 0, 143, 143, 143, 143, 143, 143, 0, 0, 21, 142,
   885         -    21, 142, 21, 142, 21, 142, 0, 143, 0, 143, 0, 143, 0, 143, 142, 142,
   886         -    142, 142, 142, 142, 142, 142, 143, 143, 143, 143, 143, 143, 143, 143,
   887         -    144, 144, 145, 145, 145, 145, 146, 146, 147, 147, 148, 148, 149, 149,
   888         -    0, 0, 142, 142, 142, 142, 142, 142, 142, 142, 150, 150, 150, 150, 150,
   889         -    150, 150, 150, 142, 142, 142, 142, 142, 142, 142, 142, 150, 150, 150,
   890         -    150, 150, 150, 150, 150, 142, 142, 142, 142, 142, 142, 142, 142, 150,
   891         -    150, 150, 150, 150, 150, 150, 150, 142, 142, 21, 151, 21, 0, 21, 21,
   892         -    143, 143, 152, 152, 153, 11, 154, 11, 11, 11, 21, 151, 21, 0, 21, 21,
   893         -    155, 155, 155, 155, 153, 11, 11, 11, 142, 142, 21, 21, 0, 0, 21, 21,
   894         -    143, 143, 156, 156, 0, 11, 11, 11, 142, 142, 21, 21, 21, 113, 21, 21,
   895         -    143, 143, 157, 157, 117, 11, 11, 11, 0, 0, 21, 151, 21, 0, 21, 21,
   896         -    158, 158, 159, 159, 153, 11, 11, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   897         -    17, 17, 17, 17, 17, 8, 8, 8, 8, 8, 8, 3, 3, 16, 20, 5, 16, 16, 20,
   898         -    5, 16, 3, 3, 3, 3, 3, 3, 3, 3, 160, 161, 17, 17, 17, 17, 17, 2, 3,
   899         -    3, 3, 3, 3, 3, 3, 3, 3, 16, 20, 3, 3, 3, 3, 12, 12, 3, 3, 3, 7, 5,
   900         -    6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 3, 12, 3, 3, 3, 3, 3, 3, 3,
   901         -    3, 3, 3, 2, 17, 17, 17, 17, 17, 0, 17, 17, 17, 17, 17, 17, 17, 17,
   902         -    17, 17, 18, 91, 0, 0, 18, 18, 18, 18, 18, 18, 7, 7, 7, 5, 6, 91, 18,
   903         -    18, 18, 18, 18, 18, 18, 18, 18, 18, 7, 7, 7, 5, 6, 0, 91, 91, 91, 91,
   904         -    91, 91, 91, 91, 91, 91, 91, 91, 91, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4,
   905         -    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
   906         -    4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 92, 92, 92, 92,
   907         -    92, 92, 92, 92, 92, 92, 92, 92, 92, 119, 119, 119, 119, 92, 119, 119,
   908         -    119, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 0, 0, 0, 0, 0,
   909         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 107, 14, 14, 14, 14, 107, 14,
   910         -    14, 21, 107, 107, 107, 21, 21, 107, 107, 107, 21, 14, 107, 14, 14,
   911         -    7, 107, 107, 107, 107, 107, 14, 14, 14, 14, 14, 14, 107, 14, 162, 14,
   912         -    107, 14, 163, 164, 107, 107, 14, 21, 107, 107, 165, 107, 21, 15, 15,
   913         -    15, 15, 21, 14, 14, 21, 21, 107, 107, 7, 7, 7, 7, 7, 107, 21, 21, 21,
   914         -    21, 14, 7, 14, 14, 166, 14, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
   915         -    18, 18, 18, 18, 18, 18, 167, 167, 167, 167, 167, 167, 167, 167, 167,
   916         -    167, 167, 167, 167, 167, 167, 167, 168, 168, 168, 168, 168, 168, 168,
   917         -    168, 168, 168, 168, 168, 168, 168, 168, 168, 128, 128, 128, 23, 24,
   918         -    128, 128, 128, 128, 18, 14, 14, 0, 0, 0, 0, 7, 7, 7, 7, 7, 14, 14,
   919         -    14, 14, 14, 7, 7, 14, 14, 14, 14, 7, 14, 14, 7, 14, 14, 7, 14, 14,
   920         -    14, 14, 14, 14, 14, 7, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   921         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   922         -    14, 14, 14, 7, 7, 14, 14, 7, 14, 7, 14, 14, 14, 14, 14, 14, 14, 14,
   923         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   924         -    14, 14, 14, 14, 14, 14, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
          874  +    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 92, 139, 21, 21,
          875  +    21, 140, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
          876  +    21, 141, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 92, 92, 92,
          877  +    92, 92, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
          878  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 0, 93, 93, 93, 93, 93,
          879  +    23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23,
          880  +    24, 23, 24, 23, 24, 21, 21, 21, 21, 21, 142, 21, 21, 143, 21, 144,
          881  +    144, 144, 144, 144, 144, 144, 144, 145, 145, 145, 145, 145, 145, 145,
          882  +    145, 144, 144, 144, 144, 144, 144, 0, 0, 145, 145, 145, 145, 145, 145,
          883  +    0, 0, 144, 144, 144, 144, 144, 144, 144, 144, 145, 145, 145, 145, 145,
          884  +    145, 145, 145, 144, 144, 144, 144, 144, 144, 144, 144, 145, 145, 145,
          885  +    145, 145, 145, 145, 145, 144, 144, 144, 144, 144, 144, 0, 0, 145, 145,
          886  +    145, 145, 145, 145, 0, 0, 21, 144, 21, 144, 21, 144, 21, 144, 0, 145,
          887  +    0, 145, 0, 145, 0, 145, 144, 144, 144, 144, 144, 144, 144, 144, 145,
          888  +    145, 145, 145, 145, 145, 145, 145, 146, 146, 147, 147, 147, 147, 148,
          889  +    148, 149, 149, 150, 150, 151, 151, 0, 0, 144, 144, 144, 144, 144, 144,
          890  +    144, 144, 152, 152, 152, 152, 152, 152, 152, 152, 144, 144, 144, 144,
          891  +    144, 144, 144, 144, 152, 152, 152, 152, 152, 152, 152, 152, 144, 144,
          892  +    144, 144, 144, 144, 144, 144, 152, 152, 152, 152, 152, 152, 152, 152,
          893  +    144, 144, 21, 153, 21, 0, 21, 21, 145, 145, 154, 154, 155, 11, 156,
          894  +    11, 11, 11, 21, 153, 21, 0, 21, 21, 157, 157, 157, 157, 155, 11, 11,
          895  +    11, 144, 144, 21, 21, 0, 0, 21, 21, 145, 145, 158, 158, 0, 11, 11,
          896  +    11, 144, 144, 21, 21, 21, 114, 21, 21, 145, 145, 159, 159, 118, 11,
          897  +    11, 11, 0, 0, 21, 153, 21, 0, 21, 21, 160, 160, 161, 161, 155, 11,
          898  +    11, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 17, 17, 17, 17, 17, 8, 8, 8,
          899  +    8, 8, 8, 3, 3, 16, 20, 5, 16, 16, 20, 5, 16, 3, 3, 3, 3, 3, 3, 3, 3,
          900  +    162, 163, 17, 17, 17, 17, 17, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 16, 20,
          901  +    3, 3, 3, 3, 12, 12, 3, 3, 3, 7, 5, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
          902  +    3, 7, 3, 12, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 17, 17, 17, 17, 17, 0,
          903  +    17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 18, 92, 0, 0, 18, 18, 18, 18,
          904  +    18, 18, 7, 7, 7, 5, 6, 92, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
          905  +    7, 7, 7, 5, 6, 0, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
          906  +    0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
          907  +    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          908  +    0, 0, 0, 0, 0, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
          909  +    120, 120, 120, 120, 93, 120, 120, 120, 93, 93, 93, 93, 93, 93, 93,
          910  +    93, 93, 93, 93, 93, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14,
          911  +    14, 108, 14, 14, 14, 14, 108, 14, 14, 21, 108, 108, 108, 21, 21, 108,
          912  +    108, 108, 21, 14, 108, 14, 14, 7, 108, 108, 108, 108, 108, 14, 14,
          913  +    14, 14, 14, 14, 108, 14, 164, 14, 108, 14, 165, 166, 108, 108, 14,
          914  +    21, 108, 108, 167, 108, 21, 15, 15, 15, 15, 21, 14, 14, 21, 21, 108,
          915  +    108, 7, 7, 7, 7, 7, 108, 21, 21, 21, 21, 14, 7, 14, 14, 168, 14, 18,
          916  +    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 169, 169,
          917  +    169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
          918  +    170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
          919  +    170, 170, 129, 129, 129, 23, 24, 129, 129, 129, 129, 18, 14, 14, 0,
          920  +    0, 0, 0, 7, 7, 7, 7, 7, 14, 14, 14, 14, 14, 7, 7, 14, 14, 14, 14, 7,
          921  +    14, 14, 7, 14, 14, 7, 14, 14, 14, 14, 14, 14, 14, 7, 14, 14, 14, 14,
          922  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          923  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 7, 7, 14, 14, 7, 14, 7, 14,
          924  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          925  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 7, 7, 7, 7, 7,
   925    926       7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
   926         -    7, 7, 7, 7, 7, 7, 14, 14, 14, 14, 14, 14, 14, 14, 5, 6, 5, 6, 14, 14,
          927  +    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 14, 14, 14, 14, 14,
          928  +    14, 14, 14, 5, 6, 5, 6, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          929  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 7, 7, 14, 14, 14, 14, 14, 14, 14,
          930  +    5, 6, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   927    931       14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   928         -    14, 7, 7, 14, 14, 14, 14, 14, 14, 14, 5, 6, 14, 14, 14, 14, 14, 14,
   929         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   930         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   931         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 7, 14, 14, 14, 14, 14, 14, 14,
   932         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   933         -    14, 14, 14, 14, 14, 14, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
   934         -    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          932  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 7,
   935    933       14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   936    934       14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 7, 7, 7, 7, 7,
   937         -    7, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          935  +    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 14, 14,
   938    936       14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   939         -    14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   940         -    0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   941         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18,
   942         -    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
          937  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          938  +    14, 14, 14, 14, 7, 7, 7, 7, 7, 7, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          939  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          940  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0,
          941  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14,
          942  +    14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          943  +    0, 0, 0, 0, 0, 0, 0, 0, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
   943    944       18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
   944    945       18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
   945         -    18, 18, 18, 18, 18, 18, 18, 18, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          946  +    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 14, 14,
   946    947       14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   947         -    169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169,
   948         -    169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, 170, 170,
   949         -    170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
   950         -    170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 18, 18, 18, 18, 18,
   951         -    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
   952         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   953         -    14, 14, 14, 14, 14, 14, 7, 14, 14, 14, 14, 14, 14, 14, 14, 14, 7, 14,
   954         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   955         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   956         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   957         -    14, 14, 7, 7, 7, 7, 7, 7, 7, 7, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          948  +    14, 14, 14, 14, 14, 14, 14, 171, 171, 171, 171, 171, 171, 171, 171,
          949  +    171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
          950  +    171, 171, 171, 171, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
          951  +    172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172,
          952  +    172, 172, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
          953  +    18, 18, 18, 18, 18, 18, 18, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          954  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 7, 14, 14, 14,
   958    955       14, 14, 14, 14, 14, 14, 7, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   959         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 5, 6, 5, 6,
   960         -    5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
          956  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          957  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          958  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 7, 7, 7, 7, 7, 7, 7, 7, 14,
          959  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 7, 14, 14,
          960  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          961  +    14, 14, 14, 14, 14, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 18, 18,
   961    962       18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
   962         -    18, 18, 18, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 7, 7, 7,
   963         -    7, 7, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
   964         -    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 7,
   965         -    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 5, 6, 5, 6, 5,
   966         -    6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 7, 7, 7, 7, 7, 7,
          963  +    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 14, 14, 14, 14, 14, 14,
          964  +    14, 14, 14, 14, 14, 14, 7, 7, 7, 7, 7, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7,
          965  +    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
          966  +    5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
          967  +    7, 7, 7, 7, 7, 7, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5,
          968  +    6, 5, 6, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
          969  +    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 5, 6, 5, 6, 7, 7, 7, 7, 7, 7,
   967    970       7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
   968         -    7, 7, 5, 6, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
   969         -    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 5, 6, 7, 7, 14, 14, 14,
   970         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 7, 7, 7, 7, 7,
   971         -    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 14, 14, 7, 7, 7, 7,
   972         -    7, 7, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          971  +    7, 7, 7, 5, 6, 7, 7, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          972  +    14, 14, 14, 14, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
          973  +    7, 7, 7, 7, 14, 14, 7, 7, 7, 7, 7, 7, 14, 14, 14, 14, 14, 14, 14, 14,
   973    974       14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   974         -    14, 14, 14, 14, 14, 14, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
          975  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 14, 14,
   975    976       14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   976         -    14, 14, 14, 14, 14, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   977         -    14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   978         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   979         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
   980         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 122, 122, 122, 122, 122, 122,
   981         -    122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
   982         -    122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122,
   983         -    122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 122, 0,
          977  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 14, 14, 14,
          978  +    14, 14, 14, 14, 14, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
   984    979       123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
   985    980       123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
   986         -    123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
   987         -    123, 123, 123, 123, 123, 0, 23, 24, 171, 172, 173, 174, 175, 23, 24,
   988         -    23, 24, 23, 24, 176, 177, 178, 179, 21, 23, 24, 21, 23, 24, 21, 21,
   989         -    21, 21, 21, 91, 91, 180, 180, 23, 24, 23, 24, 21, 14, 14, 14, 14, 14,
   990         -    14, 23, 24, 23, 24, 92, 92, 92, 23, 24, 0, 0, 0, 0, 0, 3, 3, 3, 3,
   991         -    18, 3, 3, 181, 181, 181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
   992         -    181, 181, 181, 181, 181, 181, 181, 181, 181, 181, 181, 181, 181, 181,
   993         -    181, 181, 181, 181, 181, 181, 181, 181, 181, 181, 181, 181, 0, 181,
   994         -    0, 0, 0, 0, 0, 181, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   995         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0,
   996         -    0, 0, 91, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 92, 15, 15,
   997         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
   998         -    15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15,
   999         -    15, 0, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 0,
  1000         -    15, 15, 15, 15, 15, 15, 15, 0, 3, 3, 16, 20, 16, 20, 3, 3, 3, 16, 20,
  1001         -    3, 16, 20, 3, 3, 3, 3, 3, 3, 3, 3, 3, 8, 3, 3, 8, 3, 16, 20, 3, 3,
  1002         -    16, 20, 5, 6, 5, 6, 5, 6, 5, 6, 3, 3, 3, 3, 3, 91, 3, 3, 3, 3, 3, 3,
  1003         -    3, 3, 3, 3, 8, 8, 3, 3, 3, 3, 8, 3, 5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  1004         -    3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14,
  1005         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1006         -    14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1007         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0,
  1008         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1009         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0,
  1010         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14,
  1011         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 2, 3, 3, 3, 14, 91,
  1012         -    15, 128, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 14, 14, 5, 6, 5, 6, 5, 6, 5,
  1013         -    6, 8, 5, 6, 6, 14, 128, 128, 128, 128, 128, 128, 128, 128, 128, 92,
  1014         -    92, 92, 92, 124, 124, 8, 91, 91, 91, 91, 91, 14, 14, 128, 128, 128,
  1015         -    91, 15, 3, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1016         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 92, 92, 11, 11, 91,
  1017         -    91, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1018         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 3, 91, 91, 91, 15,
  1019         -    0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1020         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1021         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15,
  1022         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1023         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 14, 14, 18, 18, 18, 18,
  1024         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15,
  1025         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1026         -    15, 15, 15, 0, 0, 0, 0, 0, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0,
  1027         -    0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1028         -    15, 15, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 14, 14, 14, 14, 14,
  1029         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1030         -    14, 14, 14, 14, 14, 14, 14, 14, 18, 18, 18, 18, 18, 18, 18, 18, 14,
  1031         -    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 14, 14,
          981  +    123, 123, 123, 123, 123, 123, 123, 123, 123, 0, 124, 124, 124, 124,
          982  +    124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124,
          983  +    124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124,
          984  +    124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124,
          985  +    124, 0, 23, 24, 173, 174, 175, 176, 177, 23, 24, 23, 24, 23, 24, 178,
          986  +    179, 180, 181, 21, 23, 24, 21, 23, 24, 21, 21, 21, 21, 21, 92, 92,
          987  +    182, 182, 23, 24, 23, 24, 21, 14, 14, 14, 14, 14, 14, 23, 24, 23, 24,
          988  +    93, 93, 93, 23, 24, 0, 0, 0, 0, 0, 3, 3, 3, 3, 18, 3, 3, 183, 183,
          989  +    183, 183, 183, 183, 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
          990  +    183, 183, 183, 183, 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
          991  +    183, 183, 183, 183, 183, 183, 183, 183, 0, 183, 0, 0, 0, 0, 0, 183,
          992  +    0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
          993  +    15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 92, 3, 0, 0, 0,
          994  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 93, 15, 15, 15, 15, 15, 15, 15, 15,
          995  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0,
          996  +    0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15,
          997  +    15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15,
          998  +    0, 3, 3, 16, 20, 16, 20, 3, 3, 3, 16, 20, 3, 16, 20, 3, 3, 3, 3, 3,
          999  +    3, 3, 3, 3, 8, 3, 3, 8, 3, 16, 20, 3, 3, 16, 20, 5, 6, 5, 6, 5, 6,
         1000  +    5, 6, 3, 3, 3, 3, 3, 92, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 8, 8, 3, 3,
         1001  +    3, 3, 8, 3, 5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0,
         1002  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1003  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1004  +    0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1005  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1006  +    0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1007  +    14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1008  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1009  +    14, 14, 14, 0, 0, 0, 0, 2, 3, 3, 3, 14, 92, 15, 129, 5, 6, 5, 6, 5,
         1010  +    6, 5, 6, 5, 6, 14, 14, 5, 6, 5, 6, 5, 6, 5, 6, 8, 5, 6, 6, 14, 129,
         1011  +    129, 129, 129, 129, 129, 129, 129, 129, 93, 93, 93, 93, 125, 125, 8,
         1012  +    92, 92, 92, 92, 92, 14, 14, 129, 129, 129, 92, 15, 3, 14, 14, 15, 15,
         1013  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1014  +    15, 15, 15, 15, 0, 0, 93, 93, 11, 11, 92, 92, 15, 15, 15, 15, 15, 15,
         1015  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1016  +    15, 15, 15, 15, 15, 3, 92, 92, 92, 15, 0, 0, 0, 0, 0, 15, 15, 15, 15,
         1017  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1018  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1019  +    15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1020  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1021  +    15, 15, 0, 14, 14, 18, 18, 18, 18, 14, 14, 14, 14, 14, 14, 14, 14,
         1022  +    14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1023  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 14,
         1024  +    14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15,
         1025  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 14, 14, 14, 14, 14, 14,
         1026  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1027  +    14, 14, 14, 14, 14, 14, 14, 14, 0, 18, 18, 18, 18, 18, 18, 18, 18,
         1028  +    18, 18, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1032   1029       14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 18, 18,
  1033         -    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 15, 15, 15, 15,
  1034         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0,
  1035         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1036         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 91, 15, 15, 15, 15, 15,
         1030  +    18, 18, 18, 18, 18, 18, 14, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
         1031  +    18, 18, 18, 18, 18, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1032  +    14, 14, 14, 14, 14, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
         1033  +    18, 18, 18, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1034  +    15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15,
  1037   1035       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1038         -    15, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1039         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15,
         1036  +    15, 92, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1037  +    15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14,
         1038  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0,
         1039  +    0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1040   1040       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1041         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 91, 3, 3, 3, 15, 15, 15, 15,
  1042         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 9, 9, 9, 9, 9, 9, 9,
  1043         -    9, 9, 9, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1044         -    0, 0, 0, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 15,
  1045         -    92, 119, 119, 119, 3, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 3, 91,
  1046         -    23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23,
  1047         -    24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 91, 91, 92, 92, 15, 15,
  1048         -    15, 15, 15, 15, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 92,
  1049         -    92, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11, 11, 11, 11, 11,
  1050         -    11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
  1051         -    91, 91, 91, 91, 91, 91, 91, 91, 91, 11, 11, 23, 24, 23, 24, 23, 24,
  1052         -    23, 24, 23, 24, 23, 24, 23, 24, 21, 21, 23, 24, 23, 24, 23, 24, 23,
         1041  +    92, 3, 3, 3, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1042  +    15, 15, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 15, 15, 0, 0, 0, 0, 0, 0, 0,
         1043  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 24, 23, 24, 23, 24, 23,
         1044  +    24, 23, 24, 23, 24, 23, 24, 15, 93, 120, 120, 120, 3, 93, 93, 93, 93,
         1045  +    93, 93, 93, 93, 93, 93, 3, 92, 23, 24, 23, 24, 23, 24, 23, 24, 23,
  1053   1046       24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24,
  1054         -    23, 24, 23, 24, 23, 24, 91, 21, 21, 21, 21, 21, 21, 21, 21, 23, 24,
  1055         -    23, 24, 182, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 91, 11, 11, 23,
  1056         -    24, 183, 21, 15, 23, 24, 23, 24, 21, 21, 23, 24, 23, 24, 23, 24, 23,
  1057         -    24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 184, 185, 186,
  1058         -    187, 184, 21, 188, 189, 190, 191, 23, 24, 23, 24, 23, 24, 0, 0, 0,
         1047  +    23, 24, 92, 92, 93, 93, 15, 15, 15, 15, 15, 15, 129, 129, 129, 129,
         1048  +    129, 129, 129, 129, 129, 129, 93, 93, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0,
         1049  +    0, 0, 0, 0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
         1050  +    11, 11, 11, 11, 11, 11, 11, 11, 11, 92, 92, 92, 92, 92, 92, 92, 92,
         1051  +    92, 11, 11, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24,
         1052  +    21, 21, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23,
         1053  +    24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 92, 21,
         1054  +    21, 21, 21, 21, 21, 21, 21, 23, 24, 23, 24, 184, 23, 24, 23, 24, 23,
         1055  +    24, 23, 24, 23, 24, 92, 11, 11, 23, 24, 185, 21, 15, 23, 24, 23, 24,
         1056  +    186, 21, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23,
         1057  +    24, 23, 24, 23, 24, 187, 188, 189, 190, 187, 21, 191, 192, 193, 194,
         1058  +    23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 23, 24, 0, 0, 23, 24, 195,
         1059  +    196, 197, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1059   1060       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1060         -    0, 0, 0, 15, 91, 91, 21, 15, 15, 15, 15, 15, 15, 15, 92, 15, 15, 15,
  1061         -    92, 15, 15, 15, 15, 92, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1062         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 124, 124, 92, 92, 124,
  1063         -    14, 14, 14, 14, 0, 0, 0, 0, 18, 18, 18, 18, 18, 18, 14, 14, 4, 14,
  1064         -    0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1065         -    15, 15, 15, 15, 15, 15, 15, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 124,
  1066         -    124, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1067         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1068         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1069         -    124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124,
  1070         -    124, 124, 92, 92, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 9, 9, 9, 9, 9, 9, 9,
  1071         -    9, 9, 9, 0, 0, 0, 0, 0, 0, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
  1072         -    92, 92, 92, 92, 92, 92, 92, 92, 15, 15, 15, 15, 15, 15, 3, 3, 3, 15,
  1073         -    3, 15, 15, 92, 15, 15, 15, 15, 15, 15, 92, 92, 92, 92, 92, 92, 92,
  1074         -    92, 3, 3, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1075         -    15, 15, 15, 15, 15, 15, 15, 15, 92, 92, 92, 92, 92, 92, 92, 92, 92,
  1076         -    92, 92, 124, 124, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 15, 15, 15, 15,
  1077         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1078         -    15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15,
  1079         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 92, 124, 124, 92, 92,
  1080         -    92, 92, 124, 124, 92, 124, 124, 124, 124, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  1081         -    3, 3, 3, 3, 0, 91, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 3, 3,
  1082         -    15, 15, 15, 15, 15, 92, 91, 15, 15, 15, 15, 15, 15, 15, 15, 15, 9,
  1083         -    9, 9, 9, 9, 9, 9, 9, 9, 9, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15,
  1084         -    15, 15, 15, 15, 92, 92, 92, 92, 92, 92, 124, 124, 92, 92, 124, 124,
  1085         -    92, 92, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 92, 15, 15, 15, 15,
  1086         -    15, 15, 15, 15, 92, 124, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0,
  1087         -    3, 3, 3, 3, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1088         -    15, 15, 91, 15, 15, 15, 15, 15, 15, 14, 14, 14, 15, 124, 92, 124, 15,
  1089         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1090         -    92, 15, 92, 92, 92, 15, 15, 92, 92, 15, 15, 15, 15, 15, 92, 92, 15,
  1091         -    92, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1092         -    0, 0, 0, 0, 15, 15, 91, 3, 3, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1093         -    15, 124, 92, 92, 124, 124, 3, 3, 15, 91, 91, 124, 92, 0, 0, 0, 0, 0,
  1094         -    0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15,
  1095         -    0, 0, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15,
  1096         -    15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 0, 21, 21, 21, 21, 21,
         1061  +    0, 0, 0, 0, 0, 0, 15, 92, 92, 21, 15, 15, 15, 15, 15, 15, 15, 93, 15,
         1062  +    15, 15, 93, 15, 15, 15, 15, 93, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1063  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 125, 125, 93,
         1064  +    93, 125, 14, 14, 14, 14, 0, 0, 0, 0, 18, 18, 18, 18, 18, 18, 14, 14,
         1065  +    4, 14, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1066  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0,
         1067  +    0, 125, 125, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1068  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1069  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1070  +    15, 15, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125,
         1071  +    125, 125, 125, 125, 93, 93, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 9, 9, 9,
         1072  +    9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 93, 93, 93, 93, 93, 93, 93,
         1073  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 15, 15, 15, 15, 15, 15,
         1074  +    3, 3, 3, 15, 3, 15, 15, 93, 15, 15, 15, 15, 15, 15, 93, 93, 93, 93,
         1075  +    93, 93, 93, 93, 3, 3, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1076  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 93, 93, 93, 93, 93, 93,
         1077  +    93, 93, 93, 93, 93, 125, 125, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 15,
         1078  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1079  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 15, 15, 15, 15,
         1080  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 93, 125,
         1081  +    125, 93, 93, 93, 93, 125, 125, 93, 93, 125, 125, 125, 3, 3, 3, 3, 3,
         1082  +    3, 3, 3, 3, 3, 3, 3, 3, 0, 92, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0,
         1083  +    0, 0, 3, 3, 15, 15, 15, 15, 15, 93, 92, 15, 15, 15, 15, 15, 15, 15,
         1084  +    15, 15, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 15, 15, 15, 15, 15, 0, 15, 15,
         1085  +    15, 15, 15, 15, 15, 15, 15, 93, 93, 93, 93, 93, 93, 125, 125, 93, 93,
         1086  +    125, 125, 93, 93, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 93, 15, 15,
         1087  +    15, 15, 15, 15, 15, 15, 93, 125, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
         1088  +    0, 0, 3, 3, 3, 3, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1089  +    15, 15, 15, 92, 15, 15, 15, 15, 15, 15, 14, 14, 14, 15, 125, 93, 125,
         1090  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1091  +    15, 93, 15, 93, 93, 93, 15, 15, 93, 93, 15, 15, 15, 15, 15, 93, 93,
         1092  +    15, 93, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1093  +    0, 0, 0, 0, 0, 15, 15, 92, 3, 3, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1094  +    15, 15, 125, 93, 93, 125, 125, 3, 3, 15, 92, 92, 125, 93, 0, 0, 0,
         1095  +    0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15,
         1096  +    15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15,
         1097  +    15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 0, 21, 21, 21,
  1097   1098       21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
  1098         -    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 192, 21, 21, 21,
  1099         -    21, 21, 21, 21, 11, 91, 91, 91, 91, 21, 21, 21, 21, 21, 21, 0, 0, 0,
  1100         -    0, 0, 0, 0, 0, 0, 0, 193, 193, 193, 193, 193, 193, 193, 193, 193, 193,
  1101         -    193, 193, 193, 193, 193, 193, 193, 193, 193, 193, 193, 193, 193, 193,
  1102         -    193, 193, 193, 193, 193, 193, 193, 193, 193, 193, 193, 193, 193, 193,
  1103         -    193, 193, 193, 193, 193, 193, 193, 193, 193, 193, 15, 15, 15, 124,
  1104         -    124, 92, 124, 124, 92, 124, 124, 3, 124, 92, 0, 0, 9, 9, 9, 9, 9, 9,
  1105         -    9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0,
  1106         -    0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1107         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 15, 15, 15, 15,
  1108         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1109         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1110         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 194, 194, 194,
  1111         -    194, 194, 194, 194, 194, 194, 194, 194, 194, 194, 194, 194, 194, 194,
  1112         -    194, 194, 194, 194, 194, 194, 194, 194, 194, 194, 194, 194, 194, 194,
  1113         -    194, 195, 195, 195, 195, 195, 195, 195, 195, 195, 195, 195, 195, 195,
  1114         -    195, 195, 195, 195, 195, 195, 195, 195, 195, 195, 195, 195, 195, 195,
  1115         -    195, 195, 195, 195, 195, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1116         -    15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1117         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1118         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 21,
  1119         -    21, 21, 21, 21, 21, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 21,
  1120         -    21, 21, 21, 0, 0, 0, 0, 0, 15, 92, 15, 15, 15, 15, 15, 15, 15, 15,
  1121         -    15, 15, 7, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15,
  1122         -    15, 15, 15, 15, 0, 15, 0, 15, 15, 0, 15, 15, 0, 15, 15, 15, 15, 15,
  1123         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1124         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1125         -    15, 15, 15, 15, 15, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
  1126         -    11, 11, 11, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1127         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1128         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1129         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 6, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1130         -    0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1131         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1132         -    15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1133         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1099  +    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 198, 21,
         1100  +    21, 21, 21, 21, 21, 21, 11, 92, 92, 92, 92, 21, 21, 21, 21, 21, 21,
         1101  +    21, 21, 0, 0, 0, 0, 0, 0, 0, 0, 199, 199, 199, 199, 199, 199, 199,
         1102  +    199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
         1103  +    199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
         1104  +    199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 15,
         1105  +    15, 15, 125, 125, 93, 125, 125, 93, 125, 125, 3, 125, 93, 0, 0, 9,
         1106  +    9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 0, 0,
         1107  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1108  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 15,
         1109  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1110  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1111  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0,
         1112  +    200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
         1113  +    200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200,
         1114  +    200, 200, 200, 200, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201,
         1115  +    201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201,
         1116  +    201, 201, 201, 201, 201, 201, 201, 201, 15, 15, 15, 15, 15, 15, 15,
         1117  +    15, 15, 15, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1118  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1119  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0,
         1120  +    0, 0, 0, 0, 0, 21, 21, 21, 21, 21, 21, 21, 0, 0, 0, 0, 0, 0, 0, 0,
         1121  +    0, 0, 0, 0, 21, 21, 21, 21, 21, 0, 0, 0, 0, 0, 15, 93, 15, 15, 15,
         1122  +    15, 15, 15, 15, 15, 15, 15, 7, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1123  +    15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 0, 15, 0, 15, 15, 0, 15, 15,
         1124  +    0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1125  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1126  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 11, 11, 11, 11, 11, 11,
         1127  +    11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1128  +    0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1129  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1130  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 6, 5, 0,
         1131  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15,
         1132  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1133  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15,
         1134  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0,
  1134   1135       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1135         -    0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 4,
  1136         -    14, 0, 0, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
  1137         -    92, 3, 3, 3, 3, 3, 3, 3, 5, 6, 3, 0, 0, 0, 0, 0, 0, 92, 92, 92, 92,
  1138         -    92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 3, 8, 8, 12, 12, 5,
  1139         -    6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 3, 3, 5, 6, 3, 3, 3, 3,
  1140         -    12, 12, 12, 3, 3, 3, 0, 3, 3, 3, 3, 8, 5, 6, 5, 6, 5, 6, 3, 3, 3, 7,
  1141         -    8, 7, 7, 7, 0, 3, 4, 3, 3, 0, 0, 0, 0, 15, 15, 15, 15, 15, 0, 15, 15,
  1142         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1143         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1144         -    15, 15, 15, 0, 0, 17, 0, 3, 3, 3, 4, 3, 3, 3, 5, 6, 3, 7, 3, 8, 3,
  1145         -    3, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 3, 7, 7, 7, 3, 11, 13, 13, 13,
  1146         -    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
  1147         -    13, 13, 13, 13, 13, 13, 5, 7, 6, 7, 5, 6, 3, 5, 6, 3, 3, 15, 15, 15,
  1148         -    15, 15, 15, 15, 15, 15, 15, 91, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1149         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1150         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1151         -    15, 15, 91, 91, 0, 0, 15, 15, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15,
  1152         -    15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 0, 0, 15, 15, 15, 0, 0, 0, 4,
  1153         -    4, 7, 11, 14, 4, 4, 0, 14, 7, 7, 7, 7, 14, 14, 0, 0, 0, 0, 0, 0, 0,
  1154         -    0, 0, 0, 17, 17, 17, 14, 14, 0, 0
         1136  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15,
         1137  +    15, 15, 15, 15, 15, 4, 14, 0, 0, 93, 93, 93, 93, 93, 93, 93, 93, 93,
         1138  +    93, 93, 93, 93, 93, 93, 93, 3, 3, 3, 3, 3, 3, 3, 5, 6, 3, 0, 0, 0,
         1139  +    0, 0, 0, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
         1140  +    93, 3, 8, 8, 12, 12, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6,
         1141  +    3, 3, 5, 6, 3, 3, 3, 3, 12, 12, 12, 3, 3, 3, 0, 3, 3, 3, 3, 8, 5, 6,
         1142  +    5, 6, 5, 6, 3, 3, 3, 7, 8, 7, 7, 7, 0, 3, 4, 3, 3, 0, 0, 0, 0, 15,
         1143  +    15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1144  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1145  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 17, 0, 3, 3, 3, 4, 3,
         1146  +    3, 3, 5, 6, 3, 7, 3, 8, 3, 3, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 3, 7,
         1147  +    7, 7, 3, 11, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
         1148  +    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 5, 7, 6, 7, 5, 6, 3,
         1149  +    5, 6, 3, 3, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 92, 15, 15, 15,
         1150  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1151  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1152  +    15, 15, 15, 15, 15, 15, 15, 15, 92, 92, 0, 0, 15, 15, 15, 15, 15, 15,
         1153  +    0, 0, 15, 15, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 0, 0, 15,
         1154  +    15, 15, 0, 0, 0, 4, 4, 7, 11, 14, 4, 4, 0, 14, 7, 7, 7, 7, 14, 14,
         1155  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 17, 17, 14, 14, 0, 0
  1155   1156   #if TCL_UTF_MAX > 3
  1156   1157       ,15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15,
  1157   1158       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1158   1159       15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1159   1160       15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 0, 15, 15, 15, 15, 15, 15,
  1160   1161       15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15,
  1161   1162       15, 15, 15, 15, 15, 15, 15, 0, 0, 3, 3, 3, 0, 0, 0, 0, 18, 18, 18,
  1162   1163       18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
  1163   1164       18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
  1164   1165       18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14,
  1165         -    14, 14, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  1166         -    128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  1167         -    128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  1168         -    128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 18,
         1166  +    14, 14, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
         1167  +    129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
         1168  +    129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
         1169  +    129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129, 18,
  1169   1170       18, 18, 18, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1170   1171       14, 14, 14, 18, 18, 14, 14, 14, 0, 14, 14, 14, 14, 14, 14, 14, 14,
  1171   1172       14, 14, 14, 14, 0, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1172   1173       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1173   1174       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14,
  1174   1175       14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1175   1176       14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1176         -    14, 14, 14, 92, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1177         -    15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 92,
         1177  +    14, 14, 14, 93, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1178  +    15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 93,
  1178   1179       18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
  1179   1180       18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0, 0, 18, 18, 18, 18,
  1180   1181       0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1181         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 128, 15, 15, 15, 15, 15, 15,
  1182         -    15, 15, 128, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1182  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 129, 15, 15, 15, 15, 15, 15,
         1183  +    15, 15, 129, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1183   1184       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1184         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 92, 92, 92, 92, 92, 0,
         1185  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 93, 93, 93, 93, 93, 0,
  1185   1186       0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1186   1187       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0,
  1187         -    3, 15, 15, 15, 15, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 3, 128,
  1188         -    128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 196, 196, 196, 196,
  1189         -    196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196,
  1190         -    196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196,
  1191         -    196, 196, 196, 196, 196, 196, 196, 196, 197, 197, 197, 197, 197, 197,
  1192         -    197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197,
  1193         -    197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197,
  1194         -    197, 197, 197, 197, 197, 197, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1188  +    3, 15, 15, 15, 15, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 3, 129,
         1189  +    129, 129, 129, 129, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 202, 202, 202, 202,
         1190  +    202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 202,
         1191  +    202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 202,
         1192  +    202, 202, 202, 202, 202, 202, 202, 202, 203, 203, 203, 203, 203, 203,
         1193  +    203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
         1194  +    203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
         1195  +    203, 203, 203, 203, 203, 203, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1195   1196       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1196   1197       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1197         -    15, 15, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 196,
  1198         -    196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196,
  1199         -    196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196, 196,
  1200         -    196, 196, 196, 196, 196, 196, 196, 0, 0, 0, 0, 197, 197, 197, 197,
  1201         -    197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197,
  1202         -    197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197,
  1203         -    197, 197, 197, 197, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 0,
         1198  +    15, 15, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 202,
         1199  +    202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 202,
         1200  +    202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 202, 202,
         1201  +    202, 202, 202, 202, 202, 202, 202, 0, 0, 0, 0, 203, 203, 203, 203,
         1202  +    203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
         1203  +    203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
         1204  +    203, 203, 203, 203, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 0,
  1204   1205       0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1205   1206       15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,
  1206   1207       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15,
  1207   1208       15, 0, 0, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1208   1209       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1209   1210       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15,
  1210   1211       0, 0, 0, 15, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
................................................................................
  1217   1218       0, 0, 18, 18, 18, 18, 18, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1218   1219       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 18, 18, 18, 18, 18, 18,
  1219   1220       0, 0, 0, 3, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1220   1221       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 3, 15,
  1221   1222       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1222   1223       15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 18, 18, 15, 15, 18, 18, 18, 18,
  1223   1224       18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 18, 18, 18, 18,
  1224         -    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 15, 92, 92, 92, 0, 92, 92,
  1225         -    0, 0, 0, 0, 0, 92, 92, 92, 92, 15, 15, 15, 15, 0, 15, 15, 15, 0, 15,
         1225  +    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 15, 93, 93, 93, 0, 93, 93,
         1226  +    0, 0, 0, 0, 0, 93, 93, 93, 93, 15, 15, 15, 15, 0, 15, 15, 15, 0, 15,
  1226   1227       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1227         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 92, 92, 92, 0, 0,
  1228         -    0, 0, 92, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0, 0, 0, 0, 0,
         1228  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 93, 93, 93, 0, 0,
         1229  +    0, 0, 93, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0, 0, 0, 0, 0,
  1229   1230       3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15,
  1230   1231       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1231   1232       15, 15, 15, 15, 15, 15, 15, 18, 18, 3, 15, 15, 15, 15, 15, 15, 15,
  1232   1233       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1233   1234       15, 15, 15, 15, 15, 18, 18, 18, 15, 15, 15, 15, 15, 15, 15, 15, 14,
  1234   1235       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1235         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 92, 92, 0, 0, 0, 0, 18,
         1236  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 93, 93, 0, 0, 0, 0, 18,
  1236   1237       18, 18, 18, 18, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15,
  1237   1238       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1238   1239       15, 15, 15, 15, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 15, 15, 15, 15, 15, 15,
  1239   1240       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0,
  1240   1241       0, 18, 18, 18, 18, 18, 18, 18, 18, 15, 15, 15, 15, 15, 15, 15, 15,
  1241   1242       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 18, 18,
  1242   1243       18, 18, 18, 18, 18, 18, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1243   1244       15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 0, 0,
  1244   1245       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0,
  1245   1246       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15,
  1246   1247       15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1247         -    0, 0, 0, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
  1248         -    97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
  1249         -    97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
  1250         -    97, 97, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 102, 102, 102, 102,
  1251         -    102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102,
  1252         -    102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102,
  1253         -    102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102,
  1254         -    102, 102, 102, 102, 102, 0, 0, 0, 0, 0, 0, 0, 18, 18, 18, 18, 18, 18,
  1255         -    15, 15, 15, 15, 92, 92, 92, 92, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9,
         1248  +    0, 0, 0, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98,
         1249  +    98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98,
         1250  +    98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98,
         1251  +    98, 98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 103, 103, 103, 103,
         1252  +    103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
         1253  +    103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
         1254  +    103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
         1255  +    103, 103, 103, 103, 103, 0, 0, 0, 0, 0, 0, 0, 18, 18, 18, 18, 18, 18,
         1256  +    15, 15, 15, 15, 93, 93, 93, 93, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9,
  1256   1257       9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 18, 18, 18, 18, 18, 18, 18, 18,
  1257   1258       18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
  1258   1259       18, 18, 18, 18, 18, 18, 0, 18, 18, 18, 18, 18, 18, 18, 15, 0, 0, 0,
  1259   1260       0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1260         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 92, 92, 92, 92, 92, 92, 92, 92,
  1261         -    92, 92, 92, 18, 18, 18, 18, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 124, 92,
  1262         -    124, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1261  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 93, 93, 93, 93, 93, 93, 93, 93,
         1262  +    93, 93, 93, 18, 18, 18, 18, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 125, 93,
         1263  +    125, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1263   1264       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1264   1265       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1265         -    15, 15, 15, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
  1266         -    92, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 18, 18, 18, 18, 18, 18, 18, 18,
         1266  +    15, 15, 15, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
         1267  +    93, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 18, 18, 18, 18, 18, 18, 18, 18,
  1267   1268       18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 9, 9, 9, 9, 9, 9, 9,
  1268         -    9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 92, 15, 15, 15,
  1269         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 124, 124, 124,
  1270         -    92, 92, 92, 92, 124, 124, 92, 92, 3, 3, 17, 3, 3, 3, 3, 0, 0, 0, 0,
         1269  +    9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 93, 15, 15, 15,
         1270  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 125, 125, 125,
         1271  +    93, 93, 93, 93, 125, 125, 93, 93, 3, 3, 17, 3, 3, 3, 3, 0, 0, 0, 0,
  1271   1272       0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1272   1273       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0,
  1273         -    0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 92,
  1274         -    92, 92, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1274  +    0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 93,
         1275  +    93, 93, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1275   1276       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1276         -    15, 15, 15, 15, 92, 92, 92, 92, 92, 124, 92, 92, 92, 92, 92, 92, 92,
  1277         -    92, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 3, 3, 3, 15, 124, 124, 0, 0,
         1277  +    15, 15, 15, 15, 93, 93, 93, 93, 93, 125, 93, 93, 93, 93, 93, 93, 93,
         1278  +    93, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 3, 3, 3, 3, 15, 125, 125, 0, 0,
  1278   1279       0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1279   1280       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1280         -    15, 15, 15, 15, 15, 15, 92, 3, 3, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15,
         1281  +    15, 15, 15, 15, 15, 15, 93, 3, 3, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15,
  1281   1282       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1282         -    15, 124, 124, 124, 92, 92, 92, 92, 92, 92, 92, 92, 92, 124, 124, 15,
  1283         -    15, 15, 15, 3, 3, 3, 3, 92, 92, 92, 92, 3, 0, 0, 9, 9, 9, 9, 9, 9,
         1283  +    15, 125, 125, 125, 93, 93, 93, 93, 93, 93, 93, 93, 93, 125, 125, 15,
         1284  +    15, 15, 15, 3, 3, 3, 3, 93, 93, 93, 93, 3, 0, 0, 9, 9, 9, 9, 9, 9,
  1284   1285       9, 9, 9, 9, 15, 3, 15, 3, 3, 3, 0, 18, 18, 18, 18, 18, 18, 18, 18,
  1285   1286       18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0, 0, 0, 0, 0,
  1286   1287       0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1287   1288       15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1288         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 124, 124, 124,
  1289         -    92, 92, 92, 124, 124, 92, 124, 92, 92, 3, 3, 3, 3, 3, 3, 92, 0, 15,
         1289  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 125, 125, 125,
         1290  +    93, 93, 93, 125, 125, 93, 125, 93, 93, 3, 3, 3, 3, 3, 3, 93, 0, 15,
  1290   1291       15, 15, 15, 15, 15, 15, 0, 15, 0, 15, 15, 15, 15, 0, 15, 15, 15, 15,
  1291   1292       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15,
  1292   1293       15, 15, 15, 15, 15, 3, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15,
  1293   1294       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1294   1295       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1295         -    15, 15, 15, 15, 15, 15, 92, 124, 124, 124, 92, 92, 92, 92, 92, 92,
  1296         -    92, 92, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0,
  1297         -    0, 92, 92, 124, 124, 0, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 15, 15,
         1296  +    15, 15, 15, 15, 15, 15, 93, 125, 125, 125, 93, 93, 93, 93, 93, 93,
         1297  +    93, 93, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0,
         1298  +    0, 93, 93, 125, 125, 0, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 15, 15,
  1298   1299       0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1299   1300       15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 0,
  1300         -    15, 15, 15, 15, 15, 0, 92, 92, 15, 124, 124, 92, 124, 124, 124, 124,
  1301         -    0, 0, 124, 124, 0, 0, 124, 124, 124, 0, 0, 15, 0, 0, 0, 0, 0, 0, 124,
  1302         -    0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 124, 124, 0, 0, 92, 92, 92, 92,
  1303         -    92, 92, 92, 0, 0, 0, 92, 92, 92, 92, 92, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1301  +    15, 15, 15, 15, 15, 0, 93, 93, 15, 125, 125, 93, 125, 125, 125, 125,
         1302  +    0, 0, 125, 125, 0, 0, 125, 125, 125, 0, 0, 15, 0, 0, 0, 0, 0, 0, 125,
         1303  +    0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 125, 125, 0, 0, 93, 93, 93, 93,
         1304  +    93, 93, 93, 0, 0, 0, 93, 93, 93, 93, 93, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1304   1305       0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1305         -    15, 15, 15, 15, 15, 124, 124, 124, 92, 92, 92, 92, 92, 92, 92, 92,
  1306         -    124, 124, 92, 92, 92, 124, 92, 15, 15, 15, 15, 3, 3, 3, 3, 3, 9, 9,
  1307         -    9, 9, 9, 9, 9, 9, 9, 9, 0, 3, 0, 3, 92, 0, 15, 15, 15, 15, 15, 15,
  1308         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 124, 124, 124, 92, 92, 92,
  1309         -    92, 92, 92, 124, 92, 124, 124, 124, 124, 92, 92, 124, 92, 92, 15, 15,
         1306  +    15, 15, 15, 15, 15, 125, 125, 125, 93, 93, 93, 93, 93, 93, 93, 93,
         1307  +    125, 125, 93, 93, 93, 125, 93, 15, 15, 15, 15, 3, 3, 3, 3, 3, 9, 9,
         1308  +    9, 9, 9, 9, 9, 9, 9, 9, 0, 3, 0, 3, 93, 15, 15, 15, 15, 15, 15, 15,
         1309  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 125, 125, 125, 93, 93, 93,
         1310  +    93, 93, 93, 125, 93, 125, 125, 125, 125, 93, 93, 125, 93, 93, 15, 15,
  1310   1311       3, 15, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0,
  1311   1312       0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1312         -    15, 124, 124, 124, 92, 92, 92, 92, 0, 0, 124, 124, 124, 124, 92, 92,
  1313         -    124, 92, 92, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  1314         -    3, 3, 3, 3, 3, 15, 15, 15, 15, 92, 92, 0, 0, 15, 15, 15, 15, 15, 15,
  1315         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 124, 124, 124, 92, 92, 92,
  1316         -    92, 92, 92, 92, 92, 124, 124, 92, 124, 92, 92, 3, 3, 3, 15, 0, 0, 0,
         1313  +    15, 125, 125, 125, 93, 93, 93, 93, 0, 0, 125, 125, 125, 125, 93, 93,
         1314  +    125, 93, 93, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
         1315  +    3, 3, 3, 3, 3, 15, 15, 15, 15, 93, 93, 0, 0, 15, 15, 15, 15, 15, 15,
         1316  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 125, 125, 125, 93, 93, 93,
         1317  +    93, 93, 93, 93, 93, 125, 125, 93, 125, 93, 93, 3, 3, 3, 15, 0, 0, 0,
  1317   1318       0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0,
  1318   1319       0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1319   1320       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1320         -    15, 92, 124, 92, 124, 124, 92, 92, 92, 92, 92, 92, 124, 92, 0, 0, 0,
  1321         -    0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0,
  1322         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 124, 124, 92, 92, 92, 92,
  1323         -    124, 92, 92, 92, 92, 92, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
  1324         -    18, 18, 3, 3, 3, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1325         -    124, 124, 124, 92, 92, 92, 92, 92, 92, 92, 92, 92, 124, 92, 92, 3,
  1326         -    0, 0, 0, 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
         1321  +    15, 93, 125, 93, 125, 125, 93, 93, 93, 93, 93, 93, 125, 93, 15, 0,
         1322  +    0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0,
         1323  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 125, 125, 93, 93, 93,
         1324  +    93, 125, 93, 93, 93, 93, 93, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9,
         1325  +    9, 18, 18, 3, 3, 3, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1326  +    15, 125, 125, 125, 93, 93, 93, 93, 93, 93, 93, 93, 93, 125, 93, 93,
         1327  +    3, 0, 0, 0, 0, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
  1327   1328       10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
  1328         -    10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
  1329         -    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 9,
  1330         -    9, 9, 9, 9, 9, 9, 9, 9, 9, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 0,
  1331         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 92, 92, 92, 92, 92, 92, 92, 92,
  1332         -    92, 92, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1329  +    10, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
         1330  +    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
         1331  +    9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0,
         1332  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1333  +    0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1334  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1335  +    15, 15, 15, 15, 15, 15, 125, 125, 125, 93, 93, 93, 93, 0, 0, 93, 93,
         1336  +    125, 125, 125, 125, 93, 15, 3, 15, 125, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1337  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 93, 93, 93,
         1338  +    93, 93, 93, 93, 93, 93, 93, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1339  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1340  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 93, 93, 93, 93,
         1341  +    93, 93, 125, 15, 93, 93, 93, 93, 3, 3, 3, 3, 3, 3, 3, 3, 93, 0, 0,
         1342  +    0, 0, 0, 0, 0, 0, 15, 93, 93, 93, 93, 93, 93, 125, 125, 93, 93, 93,
         1343  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 93, 93, 93,
         1344  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 125, 93, 93, 3, 3, 3, 15, 3,
         1345  +    3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1346  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0,
         1347  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1348  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1349  +    15, 15, 15, 125, 93, 93, 93, 93, 93, 93, 93, 0, 93, 93, 93, 93, 93,
         1350  +    93, 125, 93, 15, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9,
         1351  +    9, 9, 9, 9, 9, 9, 9, 9, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
         1352  +    18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0, 3, 3, 15, 15, 15, 15, 15,
  1333   1353       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1334         -    15, 15, 15, 15, 15, 15, 15, 15, 92, 92, 92, 92, 92, 92, 124, 15, 92,
  1335         -    92, 92, 92, 3, 3, 3, 3, 3, 3, 3, 3, 92, 0, 0, 0, 0, 0, 0, 0, 0, 15,
  1336         -    92, 92, 92, 92, 92, 92, 124, 124, 92, 92, 92, 15, 15, 15, 15, 15, 15,
  1337         -    15, 15, 0, 0, 15, 15, 15, 15, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
  1338         -    92, 92, 92, 124, 92, 92, 3, 3, 3, 15, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0,
  1339         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1340         -    0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15,
         1354  +    15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 93, 93, 93, 93, 93, 93, 93, 93,
         1355  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 0, 125, 93,
         1356  +    93, 93, 93, 93, 93, 93, 125, 93, 93, 125, 93, 93, 0, 0, 0, 0, 0, 0,
         1357  +    0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 0, 15, 15, 15, 15,
         1358  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1341   1359       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1342         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 124, 92, 92, 92,
  1343         -    92, 92, 92, 92, 0, 92, 92, 92, 92, 92, 92, 124, 92, 15, 3, 3, 3, 3,
  1344         -    3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 18,
  1345         -    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
  1346         -    18, 0, 0, 0, 3, 3, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1360  +    93, 93, 93, 93, 93, 93, 0, 0, 0, 93, 0, 93, 93, 0, 93, 93, 93, 93,
         1361  +    93, 93, 93, 15, 93, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9,
         1362  +    9, 9, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 0, 15, 15, 0, 15, 15,
  1347   1363       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1348         -    15, 0, 0, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
  1349         -    92, 92, 92, 92, 92, 92, 92, 0, 124, 92, 92, 92, 92, 92, 92, 92, 124,
  1350         -    92, 92, 124, 92, 92, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15,
  1351         -    15, 15, 0, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1352         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1353         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 92, 92, 92, 92, 92, 92, 0, 0, 0,
  1354         -    92, 0, 92, 92, 0, 92, 92, 92, 92, 92, 92, 92, 15, 92, 0, 0, 0, 0, 0,
  1355         -    0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 0, 15, 15, 15,
  1356         -    15, 15, 15, 0, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1357         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1358         -    15, 15, 15, 15, 124, 124, 124, 124, 124, 0, 92, 92, 0, 124, 124, 92,
  1359         -    124, 92, 15, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1360         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 92, 92, 124, 124, 3, 3, 0,
  1361         -    0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
  1362         -    128, 128, 128, 128, 128, 0, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0,
         1364  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 125, 125, 125,
         1365  +    125, 125, 0, 93, 93, 0, 125, 125, 93, 125, 93, 15, 0, 0, 0, 0, 0, 0,
         1366  +    0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1367  +    15, 15, 15, 93, 93, 125, 125, 3, 3, 0, 0, 0, 0, 0, 0, 0, 18, 18, 18,
         1368  +    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
         1369  +    18, 14, 14, 14, 14, 14, 14, 14, 14, 4, 4, 4, 4, 14, 14, 14, 14, 14,
         1370  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0,
         1371  +    0, 0, 0, 0, 0, 0, 3, 129, 129, 129, 129, 129, 129, 129, 129, 129, 129,
         1372  +    129, 129, 129, 129, 129, 0, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0,
  1363   1373       0, 0, 0, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1364   1374       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15,
  1365         -    15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1366         -    0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0,
  1367         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9,
  1368         -    9, 9, 9, 9, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1369         -    0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0,
  1370         -    0, 92, 92, 92, 92, 92, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15,
  1371         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 92, 92, 92, 92,
  1372         -    92, 92, 92, 3, 3, 3, 3, 3, 14, 14, 14, 14, 91, 91, 91, 91, 3, 14, 0,
  1373         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 18, 18,
  1374         -    18, 18, 18, 18, 18, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1375         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 15, 15, 15,
  1376         -    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
  1377         -    18, 18, 18, 18, 18, 18, 3, 3, 3, 3, 0, 0, 0, 0, 0, 15, 15, 15, 15,
  1378         -    15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 124, 124, 124, 124, 124, 124,
  1379         -    124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124,
  1380         -    124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124,
  1381         -    124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 124, 0, 0, 0,
  1382         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 92, 92, 92, 92, 91, 91, 91,
  1383         -    91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 0, 0, 0, 0, 0, 0, 0,
  1384         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1385         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1386         -    15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15,
  1387         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0,
  1388         -    0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1375  +    15, 15, 15, 15, 15, 15, 15, 15, 0, 17, 17, 17, 17, 17, 17, 17, 17,
         1376  +    17, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0,
         1377  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9,
         1378  +    9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1379  +    0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1380  +    15, 0, 0, 93, 93, 93, 93, 93, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15,
         1381  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 93, 93,
         1382  +    93, 93, 93, 93, 93, 3, 3, 3, 3, 3, 14, 14, 14, 14, 92, 92, 92, 92,
         1383  +    3, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
         1384  +    0, 18, 18, 18, 18, 18, 18, 18, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1385  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 15,
         1386  +    15, 15, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
         1387  +    18, 18, 18, 18, 18, 18, 18, 18, 3, 3, 3, 3, 0, 0, 0, 0, 0, 15, 15,
         1388  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 93, 15, 125, 125, 125,
         1389  +    125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125,
         1390  +    125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125,
         1391  +    125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 125,
         1392  +    125, 125, 125, 125, 125, 125, 125, 125, 125, 125, 0, 0, 0, 0, 0, 0,
         1393  +    0, 93, 93, 93, 93, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
         1394  +    92, 92, 92, 3, 92, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1395  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15,
         1396  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0,
         1397  +    0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1398  +    15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1399  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 0, 0, 0,
         1400  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 0, 0, 0,
  1389   1401       0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1390         -    0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 15,
  1391         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 14, 92, 92, 3, 17, 17, 17,
  1392         -    17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1393         -    0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 0, 0, 14, 14, 14,
         1402  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0,
         1403  +    0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 15,
         1404  +    15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15,
         1405  +    15, 15, 15, 15, 15, 15, 0, 0, 14, 93, 93, 3, 17, 17, 17, 17, 0, 0,
         1406  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1407  +    0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 0, 0, 14, 14, 14, 14, 14, 14,
  1394   1408       14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1395         -    14, 14, 14, 14, 14, 14, 14, 14, 124, 124, 92, 92, 92, 14, 14, 14, 124,
  1396         -    124, 124, 124, 124, 124, 17, 17, 17, 17, 17, 17, 17, 17, 92, 92, 92,
  1397         -    92, 92, 92, 92, 92, 14, 14, 92, 92, 92, 92, 92, 92, 92, 14, 14, 14,
         1409  +    14, 14, 14, 14, 14, 125, 125, 93, 93, 93, 14, 14, 14, 125, 125, 125,
         1410  +    125, 125, 125, 17, 17, 17, 17, 17, 17, 17, 17, 93, 93, 93, 93, 93,
         1411  +    93, 93, 93, 14, 14, 93, 93, 93, 93, 93, 93, 93, 14, 14, 14, 14, 14,
  1398   1412       14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1399         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 92, 92, 92, 92, 14, 14, 14,
  1400         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1401         -    14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1402         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 92, 92, 92, 14, 0, 0, 0, 0, 0,
  1403         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18,
  1404         -    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
  1405         -    18, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14,
         1413  +    14, 14, 14, 14, 14, 14, 14, 14, 93, 93, 93, 93, 14, 14, 14, 14, 14,
  1406   1414       14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1407         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
  1408         -    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0,
  1409         -    0, 0, 0, 0, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
  1410         -    107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
  1411         -    107, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
  1412         -    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 107, 107, 107, 107, 107, 107,
  1413         -    107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
  1414         -    107, 107, 107, 107, 107, 107, 21, 21, 21, 21, 21, 21, 21, 0, 21, 21,
  1415         -    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 107,
  1416         -    107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
  1417         -    107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 21, 21, 21,
         1415  +    14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1416  +    0, 0, 0, 0, 0, 0, 0, 14, 14, 93, 93, 93, 14, 0, 0, 0, 0, 0, 0, 0, 0,
         1417  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 18, 18, 18,
         1418  +    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0,
         1419  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1420  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0,
         1421  +    0, 0, 0, 0, 0, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
         1422  +    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0, 0, 0, 0, 0,
         1423  +    108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
         1424  +    108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 21, 21,
         1425  +    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
         1426  +    21, 21, 21, 21, 21, 21, 21, 108, 108, 108, 108, 108, 108, 108, 108,
         1427  +    108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
         1428  +    108, 108, 108, 108, 21, 21, 21, 21, 21, 21, 21, 0, 21, 21, 21, 21,
         1429  +    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 108, 108, 108,
         1430  +    108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
         1431  +    108, 108, 108, 108, 108, 108, 108, 108, 108, 21, 21, 21, 21, 21, 21,
         1432  +    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
         1433  +    21, 21, 21, 108, 0, 108, 108, 0, 0, 108, 0, 0, 108, 108, 0, 0, 108,
         1434  +    108, 108, 108, 0, 108, 108, 108, 108, 108, 108, 108, 108, 21, 21, 21,
         1435  +    21, 0, 21, 0, 21, 21, 21, 21, 21, 21, 21, 0, 21, 21, 21, 21, 21, 21,
         1436  +    21, 21, 21, 21, 21, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
         1437  +    108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
         1438  +    108, 108, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
         1439  +    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 108, 108, 0, 108, 108,
         1440  +    108, 108, 0, 0, 108, 108, 108, 108, 108, 108, 108, 108, 0, 108, 108,
         1441  +    108, 108, 108, 108, 108, 0, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
         1442  +    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 108,
         1443  +    108, 0, 108, 108, 108, 108, 0, 108, 108, 108, 108, 108, 0, 108, 0,
         1444  +    0, 0, 108, 108, 108, 108, 108, 108, 108, 0, 21, 21, 21, 21, 21, 21,
         1445  +    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
         1446  +    21, 21, 21, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
         1447  +    108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
         1448  +    108, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
         1449  +    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 108, 108, 108, 108, 108, 108,
         1450  +    108, 108, 108, 108, 108, 108, 108, 108, 21, 21, 21, 21, 21, 21, 21,
         1451  +    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 108, 108, 21, 21, 21, 21,
  1418   1452       21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
  1419         -    21, 21, 21, 21, 21, 21, 107, 0, 107, 107, 0, 0, 107, 0, 0, 107, 107,
  1420         -    0, 0, 107, 107, 107, 107, 0, 107, 107, 107, 107, 107, 107, 107, 107,
  1421         -    21, 21, 21, 21, 0, 21, 0, 21, 21, 21, 21, 21, 21, 21, 0, 21, 21, 21,
  1422         -    21, 21, 21, 21, 21, 21, 21, 21, 107, 107, 107, 107, 107, 107, 107,
  1423         -    107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
  1424         -    107, 107, 107, 107, 107, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
  1425         -    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 107, 107,
  1426         -    0, 107, 107, 107, 107, 0, 0, 107, 107, 107, 107, 107, 107, 107, 107,
  1427         -    0, 107, 107, 107, 107, 107, 107, 107, 0, 21, 21, 21, 21, 21, 21, 21,
         1453  +    21, 21, 21, 21, 21, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
         1454  +    108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
         1455  +    108, 108, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
         1456  +    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 108, 108, 108, 108, 108,
         1457  +    108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 21, 21, 21,
         1458  +    21, 21, 21, 0, 0, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
         1459  +    108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
         1460  +    108, 7, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
         1461  +    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 7, 21, 21, 21, 21, 21, 21,
         1462  +    108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
         1463  +    108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 7, 21, 21, 21,
  1428   1464       21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
  1429         -    21, 21, 107, 107, 0, 107, 107, 107, 107, 0, 107, 107, 107, 107, 107,
  1430         -    0, 107, 0, 0, 0, 107, 107, 107, 107, 107, 107, 107, 0, 21, 21, 21,
         1465  +    21, 21, 21, 21, 21, 7, 21, 21, 21, 21, 21, 21, 108, 108, 108, 108,
         1466  +    108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
         1467  +    108, 108, 108, 108, 108, 108, 108, 7, 21, 21, 21, 21, 21, 21, 21, 21,
  1431   1468       21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
  1432         -    21, 21, 21, 21, 21, 21, 107, 107, 107, 107, 107, 107, 107, 107, 107,
  1433         -    107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
  1434         -    107, 107, 107, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
  1435         -    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 107, 107, 107,
  1436         -    107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 21, 21, 21,
  1437         -    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 107, 107,
  1438         -    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
  1439         -    21, 21, 21, 21, 21, 21, 21, 21, 21, 107, 107, 107, 107, 107, 107, 107,
  1440         -    107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
  1441         -    107, 107, 107, 107, 107, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
  1442         -    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 107, 107,
  1443         -    107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
  1444         -    21, 21, 21, 21, 21, 21, 0, 0, 107, 107, 107, 107, 107, 107, 107, 107,
  1445         -    107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
  1446         -    107, 107, 107, 7, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
         1469  +    7, 21, 21, 21, 21, 21, 21, 108, 108, 108, 108, 108, 108, 108, 108,
         1470  +    108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
         1471  +    108, 108, 108, 7, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
  1447   1472       21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 7, 21, 21, 21, 21,
  1448         -    21, 21, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
  1449         -    107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 7,
  1450         -    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
  1451         -    21, 21, 21, 21, 21, 21, 21, 21, 7, 21, 21, 21, 21, 21, 21, 107, 107,
  1452         -    107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
  1453         -    107, 107, 107, 107, 107, 107, 107, 107, 107, 7, 21, 21, 21, 21, 21,
         1473  +    21, 21, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
         1474  +    108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 7,
  1454   1475       21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
  1455         -    21, 21, 21, 7, 21, 21, 21, 21, 21, 21, 107, 107, 107, 107, 107, 107,
  1456         -    107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
  1457         -    107, 107, 107, 107, 107, 7, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
  1458         -    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 7, 21,
  1459         -    21, 21, 21, 21, 21, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
  1460         -    107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
  1461         -    107, 7, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
  1462         -    21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 7, 21, 21, 21, 21, 21, 21,
  1463         -    107, 21, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
         1476  +    21, 21, 21, 21, 21, 21, 21, 21, 7, 21, 21, 21, 21, 21, 21, 108, 21,
         1477  +    0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
  1464   1478       9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
  1465         -    9, 9, 9, 9, 9, 9, 9, 9, 9, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
  1466         -    92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 14, 14, 14, 14,
  1467         -    92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
  1468         -    92, 14, 14, 14, 14, 14, 14, 14, 14, 92, 14, 14, 14, 14, 14, 14, 14,
  1469         -    14, 14, 14, 14, 14, 14, 14, 92, 14, 14, 3, 3, 3, 3, 3, 0, 0, 0, 0,
  1470         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 92, 92, 92, 92, 92, 0, 92, 92, 92,
  1471         -    92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 0, 0, 0, 0, 0, 0, 0,
  1472         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 92, 92, 92, 92, 92, 92, 92, 0, 92, 92, 92,
  1473         -    92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 0, 0, 92, 92,
  1474         -    92, 92, 92, 92, 92, 0, 92, 92, 0, 92, 92, 92, 92, 92, 0, 0, 0, 0, 0,
  1475         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15,
  1476         -    0, 0, 18, 18, 18, 18, 18, 18, 18, 18, 18, 92, 92, 92, 92, 92, 92, 92,
  1477         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 198, 198, 198, 198, 198, 198, 198, 198,
  1478         -    198, 198, 198, 198, 198, 198, 198, 198, 198, 198, 198, 198, 198, 198,
  1479         -    198, 198, 198, 198, 198, 198, 198, 198, 198, 198, 198, 198, 199, 199,
  1480         -    199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
  1481         -    199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199,
  1482         -    199, 199, 199, 199, 92, 92, 92, 92, 92, 92, 92, 0, 0, 0, 0, 0, 9, 9,
  1483         -    9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1484         -    0, 0, 0, 0, 0, 0, 0, 0, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
  1485         -    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 14,
  1486         -    18, 18, 18, 4, 18, 18, 18, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15,
  1487         -    15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1488         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15,
  1489         -    0, 15, 0, 0, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15,
  1490         -    15, 15, 15, 0, 15, 0, 15, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 0, 15, 0,
  1491         -    15, 0, 15, 0, 15, 15, 15, 0, 15, 15, 0, 15, 0, 0, 15, 0, 15, 0, 15,
  1492         -    0, 15, 0, 15, 0, 15, 15, 0, 15, 0, 0, 15, 15, 15, 15, 0, 15, 15, 15,
  1493         -    15, 15, 15, 15, 0, 15, 15, 15, 15, 0, 15, 15, 15, 15, 0, 15, 0, 15,
  1494         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15,
  1495         -    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 15, 15, 15,
  1496         -    0, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1497         -    15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1498         -    0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14,
  1499         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 14, 14, 14,
         1479  +    9, 9, 9, 9, 9, 9, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
         1480  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 14, 14, 14, 14, 93, 93, 93,
         1481  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 14, 14,
         1482  +    14, 14, 14, 14, 14, 14, 93, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1483  +    14, 14, 14, 14, 93, 14, 14, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0,
         1484  +    0, 0, 0, 0, 0, 0, 0, 93, 93, 93, 93, 93, 0, 93, 93, 93, 93, 93, 93,
         1485  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1486  +    0, 0, 0, 0, 0, 93, 93, 93, 93, 93, 93, 93, 0, 93, 93, 93, 93, 93, 93,
         1487  +    93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 0, 0, 93, 93, 93, 93, 93,
         1488  +    93, 93, 0, 93, 93, 0, 93, 93, 93, 93, 93, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1489  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15,
         1490  +    15, 15, 15, 15, 15, 0, 0, 0, 93, 93, 93, 93, 93, 93, 93, 92, 92, 92,
         1491  +    92, 92, 92, 92, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 15,
         1492  +    14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15,
         1493  +    15, 15, 15, 15, 15, 15, 15, 15, 93, 93, 93, 93, 9, 9, 9, 9, 9, 9, 9,
         1494  +    9, 9, 9, 0, 0, 0, 0, 0, 4, 15, 15, 15, 15, 15, 0, 0, 18, 18, 18, 18,
         1495  +    18, 18, 18, 18, 18, 93, 93, 93, 93, 93, 93, 93, 0, 0, 0, 0, 0, 0, 0,
         1496  +    0, 0, 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, 204,
         1497  +    204, 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, 204, 204,
         1498  +    204, 204, 204, 204, 204, 204, 204, 205, 205, 205, 205, 205, 205, 205,
         1499  +    205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205,
         1500  +    205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 93,
         1501  +    93, 93, 93, 93, 93, 93, 92, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9,
         1502  +    9, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1503  +    0, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
         1504  +    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 14, 18, 18, 18, 4, 18,
         1505  +    18, 18, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 18, 18, 18, 18,
         1506  +    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
         1507  +    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
         1508  +    18, 18, 18, 18, 18, 18, 14, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
         1509  +    18, 18, 18, 18, 18, 0, 0, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15,
         1510  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1511  +    15, 15, 15, 15, 0, 15, 15, 0, 15, 0, 0, 15, 0, 15, 15, 15, 15, 15,
         1512  +    15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 0, 15, 0, 15, 0, 0, 0, 0, 0,
         1513  +    0, 15, 0, 0, 0, 0, 15, 0, 15, 0, 15, 0, 15, 15, 15, 0, 15, 15, 0, 15,
         1514  +    0, 0, 15, 0, 15, 0, 15, 0, 15, 0, 15, 0, 15, 15, 0, 15, 0, 0, 15, 15,
         1515  +    15, 15, 0, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 0, 15, 15,
         1516  +    15, 15, 0, 15, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 15, 15,
         1517  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0,
         1518  +    0, 0, 15, 15, 15, 0, 15, 15, 15, 15, 15, 0, 15, 15, 15, 15, 15, 15,
         1519  +    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0,
         1520  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1521  +    0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0,
         1522  +    0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1523  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 14,
         1524  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14,
         1525  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 14,
         1526  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 18, 18, 18, 18, 18,
         1527  +    18, 18, 18, 18, 18, 18, 18, 18, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14,
         1528  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1529  +    14, 14, 14, 14, 14, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1500   1530       14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1501         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 14, 14, 14, 14, 14,
  1502         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 14, 14, 14,
  1503         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 14, 14, 14, 14,
  1504         -    14, 14, 14, 14, 14, 14, 14, 14, 18, 18, 18, 18, 18, 18, 18, 18, 18,
  1505         -    18, 18, 18, 18, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1506         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1507         -    14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1508         -    0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1509         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0,
  1510         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1511         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1512         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1513         -    0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0,
  1514         -    14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14,
  1515         -    14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1531  +    14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1516   1532       0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1517         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 11, 11, 11,
  1518         -    11, 11, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1519         -    14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14,
  1520         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 14, 14, 14, 14, 14,
  1521         -    14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14,
         1533  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0,
         1534  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14,
         1535  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1522   1536       14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1523         -    0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0,
  1524         -    0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0,
  1525         -    14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14,
  1526         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1527         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1537  +    14, 14, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0,
         1538  +    0, 0, 0, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14,
         1539  +    14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1528   1540       0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
  1529         -    14, 14, 14, 14, 14, 14, 14, 0, 0, 14, 14, 14, 14, 0, 0, 0, 14, 0, 14,
  1530         -    14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14,
  1531         -    14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15,
         1541  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1542  +    11, 11, 11, 11, 11, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1543  +    14, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0,
         1544  +    0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1545  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14,
         1546  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1547  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0,
         1548  +    0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0,
         1549  +    0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14,
         1550  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1551  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0,
         1552  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1553  +    14, 14, 0, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1554  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1555  +    14, 14, 14, 14, 14, 14, 0, 14, 14, 14, 14, 0, 0, 0, 14, 14, 14, 14,
         1556  +    14, 14, 14, 14, 14, 0, 0, 14, 14, 14, 14, 14, 14, 0, 0, 0, 14, 14,
         1557  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1558  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 14, 14, 14, 14, 14, 14,
         1559  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
         1560  +    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 0, 0, 14, 14, 14, 14, 0, 0,
         1561  +    0, 0, 14, 14, 14, 0, 0, 0, 0, 0, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0,
         1562  +    0, 0, 0, 0, 0, 14, 14, 14, 14, 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1532   1563       15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1533         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1534         -    0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
  1535         -    15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1536         -    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
         1564  +    15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 0, 0, 0, 0,
         1565  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
         1566  +    15, 15, 15, 15, 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1567  +    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  1537   1568   #endif /* TCL_UTF_MAX > 3 */
  1538   1569   };
  1539   1570   
  1540   1571   /*
  1541   1572    * Each group represents a unique set of character attributes.  The attributes
  1542   1573    * are encoded into a 32-bit value as follows:
  1543   1574    *
................................................................................
  1560   1591       5, 23, 16, 11, -190078, 24, 2, -30846, 321, 386, -50879, 59522,
  1561   1592       -30911, 76930, -49790, 53825, 52801, 52545, 20289, 51777, 52033,
  1562   1593       53057, -24702, 54081, 53569, -41598, 54593, -33150, 54849, 55873,
  1563   1594       55617, 56129, -14206, 609, 451, 674, 20354, -24767, -14271, -33215,
  1564   1595       2763585, -41663, 2762817, -2768510, -49855, 17729, 18241, -2760318,
  1565   1596       -2759550, -2760062, 53890, 52866, 52610, 51842, 52098, -10833534,
  1566   1597       -10832510, 53122, -10823550, -10830718, 53634, 54146, -2750078,
  1567         -    -10829950, -2751614, 54658, 54914, -2745982, 55938, -10824062,
  1568         -    17794, 55682, 18306, 56194, -10818686, -10817918, 4, 6, -21370,
  1569         -    29761, 9793, 9537, 16449, 16193, 9858, 9602, 8066, 16514, 16258,
  1570         -    2113, 16002, 14722, 1, 12162, 13954, 2178, 22146, 20610, -1662,
  1571         -    29826, -15295, 24706, -1727, 20545, 7, 3905, 3970, 12353, 12418,
  1572         -    8, 1859649, -769822, 9949249, 10, 1601154, 1600898, 1598594, 1598082,
  1573         -    1598338, 1596546, 1582466, -9027966, -769983, -9044862, -976254,
  1574         -    15234, -1949375, -1918, -1983, -18814, -21886, -25470, -32638,
  1575         -    -28542, -32126, -1981, -2174, -18879, -2237, 1844610, -21951,
  1576         -    -25535, -28607, -32703, -32191, 13, 14, -1924287, -2145983, -2115007,
  1577         -    7233, 7298, 4170, 4234, 6749, 6813, -2750143, -976319, -2746047,
  1578         -    2763650, 2762882, -2759615, -2751679, -2760383, -2760127, -2768575,
  1579         -    1859714, -9044927, -10823615, -10830783, -10833599, -10832575,
  1580         -    -10830015, -10817983, -10824127, -10818751, 237633, 237698, 9949314,
         1598  +    -10829950, -2751614, 54658, 54914, -2745982, 55938, -10830462,
         1599  +    -10824062, 17794, 55682, 18306, 56194, -10818686, -10817918, 4,
         1600  +    6, -21370, 29761, 9793, 9537, 16449, 16193, 9858, 9602, 8066,
         1601  +    16514, 16258, 2113, 16002, 14722, 1, 12162, 13954, 2178, 22146,
         1602  +    20610, -1662, 29826, -15295, 24706, -1727, 20545, 7, 3905, 3970,
         1603  +    12353, 12418, 8, 1859649, -769822, 9949249, 10, 1601154, 1600898,
         1604  +    1598594, 1598082, 1598338, 1596546, 1582466, -9027966, -769983,
         1605  +    -9044862, -976254, -9058174, 15234, -1949375, -1918, -1983, -18814,
         1606  +    -21886, -25470, -32638, -28542, -32126, -1981, -2174, -18879,
         1607  +    -2237, 1844610, -21951, -25535, -28607, -32703, -32191, 13, 14,
         1608  +    -1924287, -2145983, -2115007, 7233, 7298, 4170, 4234, 6749, 6813,
         1609  +    -2750143, -976319, -2746047, 2763650, 2762882, -2759615, -2751679,
         1610  +    -2760383, -2760127, -2768575, 1859714, -9044927, -10823615, -12158,
         1611  +    -10830783, -10833599, -10832575, -10830015, -10817983, -10824127,
         1612  +    -10818751, 237633, -12223, -10830527, -9058239, 237698, 9949314,
  1581   1613       18, 17, 10305, 10370, 8769, 8834
  1582   1614   };
  1583   1615   
  1584   1616   #if TCL_UTF_MAX > 3
  1585   1617   #   define UNICODE_OUT_OF_RANGE(ch) (((ch) & 0x1fffff) >= 0x2fa20)
  1586   1618   #else
  1587   1619   #   define UNICODE_OUT_OF_RANGE(ch) (((ch) & 0x1f0000) != 0)

Changes to generic/tclUtf.c.

   108    108    *---------------------------------------------------------------------------
   109    109    *
   110    110    * Tcl_UniCharToUtf --
   111    111    *
   112    112    *	Store the given Tcl_UniChar as a sequence of UTF-8 bytes in the
   113    113    *	provided buffer. Equivalent to Plan 9 runetochar().
   114    114    *
          115  + *	Special handling of Surrogate pairs is handled as follows:
          116  + *	When this function is called for ch being a high surrogate,
          117  + *	the first byte of the 4-byte UTF-8 sequence is produced and
          118  + *	the function returns 1. Calling the function again with a
          119  + *	low surrogate, the remaining 3 bytes of the 4-byte UTF-8
          120  + *	sequence is produced, and the function returns 3. The buffer
          121  + *	is used to remember the high surrogate between the two calls.
          122  + *
          123  + *	If no low surrogate follows the high surrogate (which is actually
          124  + *	illegal), this can be handled reasonably by calling Tcl_UniCharToUtf
          125  + *	again with ch = -1. This will produce a 3-byte UTF-8 sequence
          126  + *	representing the high surrogate.
          127  + *
   115    128    * Results:
   116    129    *	The return values is the number of bytes in the buffer that were
   117    130    *	consumed.
   118    131    *
   119    132    * Side effects:
   120    133    *	None.
   121    134    *
................................................................................
   266    279    *	The caller must ensure that the source buffer is long enough that this
   267    280    *	routine does not run off the end and dereference non-existent memory
   268    281    *	looking for trail bytes. If the source buffer is known to be '\0'
   269    282    *	terminated, this cannot happen. Otherwise, the caller should call
   270    283    *	Tcl_UtfCharComplete() before calling this routine to ensure that
   271    284    *	enough bytes remain in the string.
   272    285    *
   273         - *	If TCL_UTF_MAX == 4, special handling of Surrogate pairs is done:
          286  + *	Special handling of Surrogate pairs is handled as follows:
   274    287    *	For any UTF-8 string containing a character outside of the BMP, the
   275    288    *	first call to this function will fill *chPtr with the high surrogate
   276         - *	and generate a return value of 0. Calling Tcl_UtfToUniChar again
   277         - *	will produce the low surrogate and a return value of 4. Because *chPtr
          289  + *	and generate a return value of 1. Calling Tcl_UtfToUniChar again
          290  + *	will produce the low surrogate and a return value of 3. Because *chPtr
   278    291    *	is used to remember whether the high surrogate is already produced, it
   279    292    *	is recommended to initialize the variable it points to as 0 before
   280    293    *	the first call to Tcl_UtfToUniChar is done.
   281    294    *
   282    295    * Results:
   283    296    *	*chPtr is filled with the Tcl_UniChar, and the return value is the
   284    297    *	number of bytes from the UTF-8 string that were consumed.
................................................................................
   328    341   		&& (((((byte - 0x10) << 2) & 0xFC) | 0xD800) == (*chPtr & 0xFCFC))
   329    342   		&& ((src[1] & 0xF0) == (((*chPtr << 4) & 0x30) | 0x80))
   330    343   		&& ((src[2] & 0xC0) == 0x80)) {
   331    344   	    *chPtr = ((src[1] & 0x0F) << 6) + (src[2] & 0x3F) + 0xDC00;
   332    345   	    return 3;
   333    346   	}
   334    347   #endif
   335         -	if (byte-0x80 < 0x20) {
          348  +	if ((unsigned)(byte-0x80) < (unsigned)0x20) {
   336    349   	    *chPtr = cp1252[byte-0x80];
   337    350   	} else {
   338    351   	    *chPtr = byte;
   339    352   	}
   340    353   	return 1;
   341    354       } else if (byte < 0xE0) {
   342    355   	if ((src[1] & 0xC0) == 0x80) {
................................................................................
  1949   1962   		 * quickly if the next char in the pattern isn't a special
  1950   1963   		 * character
  1951   1964   		 */
  1952   1965   
  1953   1966   		if ((p != '[') && (p != '?') && (p != '\\')) {
  1954   1967   		    if (nocase) {
  1955   1968   			while (*uniStr && (p != *uniStr)
  1956         -				&& (p != Tcl_UniCharToLower(*uniStr))) {
         1969  +				&& (p != (Tcl_UniChar)Tcl_UniCharToLower(*uniStr))) {
  1957   1970   			    uniStr++;
  1958   1971   			}
  1959   1972   		    } else {
  1960   1973   			while (*uniStr && (p != *uniStr)) {
  1961   1974   			    uniStr++;
  1962   1975   			}
  1963   1976   		    }
................................................................................
  2141   2154   		 * quickly if the next char in the pattern isn't a special
  2142   2155   		 * character.
  2143   2156   		 */
  2144   2157   
  2145   2158   		if ((p != '[') && (p != '?') && (p != '\\')) {
  2146   2159   		    if (nocase) {
  2147   2160   			while ((string < stringEnd) && (p != *string)
  2148         -				&& (p != Tcl_UniCharToLower(*string))) {
         2161  +				&& (p != (Tcl_UniChar)Tcl_UniCharToLower(*string))) {
  2149   2162   			    string++;
  2150   2163   			}
  2151   2164   		    } else {
  2152   2165   			while ((string < stringEnd) && (p != *string)) {
  2153   2166   			    string++;
  2154   2167   			}
  2155   2168   		    }

Changes to generic/tclUtil.c.

  2591   2591       /*
  2592   2592        * Promote based on the type of incoming object.
  2593   2593        * XXX: Currently doesn't take advantage of exact-ness that
  2594   2594        * XXX: TclReToGlob tells us about
  2595   2595       trivial = nocase ? 0 : TclMatchIsTrivial(TclGetString(ptnObj));
  2596   2596        */
  2597   2597   
  2598         -    if ((strObj->typePtr == &tclStringType) || (strObj->typePtr == NULL)) {
         2598  +    if (TclHasIntRep(strObj, &tclStringType) || (strObj->typePtr == NULL)) {
  2599   2599   	Tcl_UniChar *udata, *uptn;
  2600   2600   
  2601   2601   	udata = TclGetUnicodeFromObj(strObj, &length);
  2602   2602   	uptn  = TclGetUnicodeFromObj(ptnObj, &plen);
  2603   2603   	match = TclUniCharMatch(udata, length, uptn, plen, flags);
  2604   2604       } else if (TclIsPureByteArray(strObj) && TclIsPureByteArray(ptnObj)
  2605   2605   		&& !flags) {

Changes to generic/tclVar.c.

  3972   3972       }
  3973   3973   
  3974   3974       /*
  3975   3975        * Install the contents of the dictionary or list into the array.
  3976   3976        */
  3977   3977   
  3978   3978       arrayElemObj = objv[2];
  3979         -    if (arrayElemObj->typePtr == &tclDictType && arrayElemObj->bytes == NULL) {
         3979  +    if (TclHasIntRep(arrayElemObj, &tclDictType) && arrayElemObj->bytes == NULL) {
  3980   3980   	Tcl_Obj *keyPtr, *valuePtr;
  3981   3981   	Tcl_DictSearch search;
  3982   3982   	int done;
  3983   3983   
  3984   3984   	if (Tcl_DictObjSize(interp, arrayElemObj, &done) != TCL_OK) {
  3985   3985   	    return TCL_ERROR;
  3986   3986   	}

Changes to library/init.tcl.

    76     76   	    encoding dirs $Path
    77     77           }
    78     78       }
    79     79   }
    80     80   
    81     81   namespace eval tcl::Pkg {}
    82     82   
    83         -# Windows specific end of initialization
    84         -
    85         -if {(![interp issafe]) && ($tcl_platform(platform) eq "windows")} {
    86         -    namespace eval tcl {
    87         -	proc EnvTraceProc {lo n1 n2 op} {
    88         -	    global env
    89         -	    set x $env($n2)
    90         -	    set env($lo) $x
    91         -	    set env([string toupper $lo]) $x
    92         -	}
    93         -	proc InitWinEnv {} {
    94         -	    global env tcl_platform
    95         -	    foreach p [array names env] {
    96         -		set u [string toupper $p]
    97         -		if {$u ne $p} {
    98         -		    switch -- $u {
    99         -			COMSPEC -
   100         -			PATH {
   101         -			    set temp $env($p)
   102         -			    unset env($p)
   103         -			    set env($u) $temp
   104         -			    trace add variable env($p) write \
   105         -				    [namespace code [list EnvTraceProc $p]]
   106         -			    trace add variable env($u) write \
   107         -				    [namespace code [list EnvTraceProc $p]]
   108         -			}
   109         -		    }
   110         -		}
   111         -	    }
   112         -	    if {![info exists env(COMSPEC)]} {
   113         -		set env(COMSPEC) cmd.exe
   114         -	    }
   115         -	}
   116         -	InitWinEnv
   117         -    }
   118         -}
   119     83   
   120     84   # Setup the unknown package handler
   121     85   
   122     86   
   123     87   if {[interp issafe]} {
   124     88       package unknown {::tcl::tm::UnknownHandler ::tclPkgUnknown}
   125     89   } else {

Changes to macosx/tclMacOSXFCmd.c.

   573    573   GetOSTypeFromObj(
   574    574       Tcl_Interp *interp,		/* Used for error reporting if not NULL. */
   575    575       Tcl_Obj *objPtr,		/* The object from which to get an OSType. */
   576    576       OSType *osTypePtr)		/* Place to store resulting OSType. */
   577    577   {
   578    578       int result = TCL_OK;
   579    579   
   580         -    if (objPtr->typePtr != &tclOSTypeType) {
          580  +    if (!TclHasIntRep(objPtr, &tclOSTypeType)) {
   581    581   	result = SetOSTypeFromAny(interp, objPtr);
   582    582       }
   583    583       *osTypePtr = (OSType) objPtr->internalRep.longValue;
   584    584       return result;
   585    585   }
   586    586   
   587    587   /*

Added tests-perf/clock.perf.tcl.

            1  +#!/usr/bin/tclsh
            2  +# ------------------------------------------------------------------------
            3  +#
            4  +# test-performance.tcl --
            5  +# 
            6  +#  This file provides common performance tests for comparison of tcl-speed
            7  +#  degradation by switching between branches.
            8  +#  (currently for clock ensemble only)
            9  +#
           10  +# ------------------------------------------------------------------------
           11  +# 
           12  +# Copyright (c) 2014 Serg G. Brester (aka sebres)
           13  +# 
           14  +# See the file "license.terms" for information on usage and redistribution
           15  +# of this file.
           16  +# 
           17  +
           18  +array set in {-time 500}
           19  +if {[info exists ::argv0] && [file tail $::argv0] eq [file tail [info script]]} {
           20  +  array set in $argv
           21  +}
           22  +
           23  +## common test performance framework:
           24  +if {![namespace exists ::tclTestPerf]} {
           25  +  source [file join [file dirname [info script]] test-performance.tcl]
           26  +}
           27  +
           28  +namespace eval ::tclTestPerf-TclClock {
           29  +
           30  +namespace path {::tclTestPerf}
           31  +
           32  +## set testing defaults:
           33  +set ::env(TCL_TZ) :CET
           34  +
           35  +# warm-up interpeter compiler env, clock platform-related features:
           36  +
           37  +## warm-up test-related features (load clock.tcl, system zones, locales, etc.):
           38  +clock scan "" -gmt 1
           39  +clock scan ""
           40  +clock scan "" -timezone :CET
           41  +clock scan "" -format "" -locale en
           42  +clock scan "" -format "" -locale de
           43  +
           44  +## ------------------------------------------
           45  +
           46  +proc test-format {{reptime 1000}} {
           47  +  _test_run $reptime {
           48  +    # Format : short, week only (in gmt)
           49  +    {clock format 1482525936 -format "%u" -gmt 1}
           50  +    # Format : short, week only (system zone)
           51  +    {clock format 1482525936 -format "%u"}
           52  +    # Format : short, week only (CEST)
           53  +    {clock format 1482525936 -format "%u" -timezone :CET}
           54  +    # Format : date only (in gmt)
           55  +    {clock format 1482525936 -format "%Y-%m-%d" -gmt 1}
           56  +    # Format : date only (system zone)
           57  +    {clock format 1482525936 -format "%Y-%m-%d"}
           58  +    # Format : date only (CEST)
           59  +    {clock format 1482525936 -format "%Y-%m-%d" -timezone :CET}
           60  +    # Format : time only (in gmt)
           61  +    {clock format 1482525936 -format "%H:%M" -gmt 1}
           62  +    # Format : time only (system zone)
           63  +    {clock format 1482525936 -format "%H:%M"}
           64  +    # Format : time only (CEST)
           65  +    {clock format 1482525936 -format "%H:%M" -timezone :CET}
           66  +    # Format : time only (in gmt)
           67  +    {clock format 1482525936 -format "%H:%M:%S" -gmt 1}
           68  +    # Format : time only (system zone)
           69  +    {clock format 1482525936 -format "%H:%M:%S"}
           70  +    # Format : time only (CEST)
           71  +    {clock format 1482525936 -format "%H:%M:%S" -timezone :CET}
           72  +    # Format : default (in gmt)
           73  +    {clock format 1482525936 -gmt 1 -locale en}
           74  +    # Format : default (system zone)
           75  +    {clock format 1482525936 -locale en}
           76  +    # Format : default (CEST)
           77  +    {clock format 1482525936 -timezone :CET -locale en}
           78  +    # Format : ISO date-time (in gmt, numeric zone)
           79  +    {clock format 1246379400 -format "%Y-%m-%dT%H:%M:%S %z" -gmt 1}
           80  +    # Format : ISO date-time (system zone, CEST, numeric zone)
           81  +    {clock format 1246379400 -format "%Y-%m-%dT%H:%M:%S %z"}
           82  +    # Format : ISO date-time (CEST, numeric zone)
           83  +    {clock format 1246379400 -format "%Y-%m-%dT%H:%M:%S %z" -timezone :CET}
           84  +    # Format : ISO date-time (system zone, CEST)
           85  +    {clock format 1246379400 -format "%Y-%m-%dT%H:%M:%S %Z"}
           86  +    # Format : julian day with time (in gmt):
           87  +    {clock format 1246379415 -format "%J %H:%M:%S" -gmt 1}
           88  +    # Format : julian day with time (system zone):
           89  +    {clock format 1246379415 -format "%J %H:%M:%S"}
           90  +
           91  +    # Format : locale date-time (en):
           92  +    {clock format 1246379415 -format "%x %X" -locale en}
           93  +    # Format : locale date-time (de):
           94  +    {clock format 1246379415 -format "%x %X" -locale de}
           95  +
           96  +    # Format : locale lookup table month:
           97  +    {clock format 1246379400 -format "%b" -locale en -gmt 1}
           98  +    # Format : locale lookup 2 tables - month and day:
           99  +    {clock format 1246379400 -format "%b %Od" -locale en -gmt 1}
          100  +    # Format : locale lookup 3 tables - week, month and day:
          101  +    {clock format 1246379400 -format "%a %b %Od" -locale en -gmt 1}
          102  +    # Format : locale lookup 4 tables - week, month, day and year:
          103  +    {clock format 1246379400 -format "%a %b %Od %Oy" -locale en -gmt 1}
          104  +
          105  +    # Format : dynamic clock value (without converter caches):
          106  +    setup {set i 0}
          107  +    {clock format [incr i] -format "%Y-%m-%dT%H:%M:%S" -locale en -timezone :CET}
          108  +    cleanup {puts [clock format $i -format "%Y-%m-%dT%H:%M:%S" -locale en -timezone :CET]}
          109  +    # Format : dynamic clock value (without any converter caches, zone range overflow):
          110  +    setup {set i 0}
          111  +    {clock format [incr i 86400] -format "%Y-%m-%dT%H:%M:%S" -locale en -timezone :CET}
          112  +    cleanup {puts [clock format $i -format "%Y-%m-%dT%H:%M:%S" -locale en -timezone :CET]}
          113  +
          114  +    # Format : dynamic format (cacheable)
          115  +    {clock format 1246379415 -format [string trim "%d.%m.%Y %H:%M:%S "] -gmt 1}
          116  +
          117  +    # Format : all (in gmt, locale en)
          118  +    {clock format 1482525936 -format "%%a = %a | %%A = %A | %%b = %b | %%h = %h | %%B = %B | %%C = %C | %%d = %d | %%e = %e | %%g = %g | %%G = %G | %%H = %H | %%I = %I | %%j = %j | %%J = %J | %%k = %k | %%l = %l | %%m = %m | %%M = %M | %%N = %N | %%p = %p | %%P = %P | %%Q = %Q | %%s = %s | %%S = %S | %%t = %t | %%u = %u | %%U = %U | %%V = %V | %%w = %w | %%W = %W | %%y = %y | %%Y = %Y | %%z = %z | %%Z = %Z | %%n = %n | %%EE = %EE | %%EC = %EC | %%Ey = %Ey | %%n = %n | %%Od = %Od | %%Oe = %Oe | %%OH = %OH | %%Ok = %Ok | %%OI = %OI | %%Ol = %Ol | %%Om = %Om | %%OM = %OM | %%OS = %OS | %%Ou = %Ou | %%Ow = %Ow | %%Oy = %Oy" -gmt 1 -locale en}
          119  +    # Format : all (in CET, locale de)
          120  +    {clock format 1482525936 -format "%%a = %a | %%A = %A | %%b = %b | %%h = %h | %%B = %B | %%C = %C | %%d = %d | %%e = %e | %%g = %g | %%G = %G | %%H = %H | %%I = %I | %%j = %j | %%J = %J | %%k = %k | %%l = %l | %%m = %m | %%M = %M | %%N = %N | %%p = %p | %%P = %P | %%Q = %Q | %%s = %s | %%S = %S | %%t = %t | %%u = %u | %%U = %U | %%V = %V | %%w = %w | %%W = %W | %%y = %y | %%Y = %Y | %%z = %z | %%Z = %Z | %%n = %n | %%EE = %EE | %%EC = %EC | %%Ey = %Ey | %%n = %n | %%Od = %Od | %%Oe = %Oe | %%OH = %OH | %%Ok = %Ok | %%OI = %OI | %%Ol = %Ol | %%Om = %Om | %%OM = %OM | %%OS = %OS | %%Ou = %Ou | %%Ow = %Ow | %%Oy = %Oy" -timezone :CET -locale de}
          121  +  }
          122  +}
          123  +
          124  +proc test-scan {{reptime 1000}} {
          125  +  _test_run $reptime {
          126  +    # Scan : date (in gmt)
          127  +    {clock scan "25.11.2015" -format "%d.%m.%Y" -base 0 -gmt 1}
          128  +    # Scan : date (system time zone, with base)
          129  +    {clock scan "25.11.2015" -format "%d.%m.%Y" -base 0}
          130  +    # Scan : date (system time zone, without base)
          131  +    {clock scan "25.11.2015" -format "%d.%m.%Y"}
          132  +    # Scan : greedy match
          133  +    {clock scan "111" -format "%d%m%y" -base 0 -gmt 1}
          134  +    {clock scan "1111" -format "%d%m%y" -base 0 -gmt 1}
          135  +    {clock scan "11111" -format "%d%m%y" -base 0 -gmt 1}
          136  +    {clock scan "111111" -format "%d%m%y" -base 0 -gmt 1}
          137  +    # Scan : greedy match (space separated)
          138  +    {clock scan "1 1 1" -format "%d%m%y" -base 0 -gmt 1}
          139  +    {clock scan "111 1" -format "%d%m%y" -base 0 -gmt 1}
          140  +    {clock scan "1 111" -format "%d%m%y" -base 0 -gmt 1}
          141  +    {clock scan "1 11 1" -format "%d%m%y" -base 0 -gmt 1}
          142  +    {clock scan "1 11 11" -format "%d%m%y" -base 0 -gmt 1}
          143  +    {clock scan "11 11 11" -format "%d%m%y" -base 0 -gmt 1}
          144  +
          145  +    # Scan : time (in gmt)
          146  +    {clock scan "10:35:55" -format "%H:%M:%S" -base 1000000000 -gmt 1}
          147  +    # Scan : time (system time zone, with base)
          148  +    {clock scan "10:35:55" -format "%H:%M:%S" -base 1000000000}
          149  +    # Scan : time (gmt, without base)
          150  +    {clock scan "10:35:55" -format "%H:%M:%S" -gmt 1}
          151  +    # Scan : time (system time zone, without base)
          152  +    {clock scan "10:35:55" -format "%H:%M:%S"}
          153  +
          154  +    # Scan : date-time (in gmt)
          155  +    {clock scan "25.11.2015 10:35:55" -format "%d.%m.%Y %H:%M:%S" -base 0 -gmt 1}
          156  +    # Scan : date-time (system time zone with base)
          157  +    {clock scan "25.11.2015 10:35:55" -format "%d.%m.%Y %H:%M:%S" -base 0}
          158  +    # Scan : date-time (system time zone without base)
          159  +    {clock scan "25.11.2015 10:35:55" -format "%d.%m.%Y %H:%M:%S"}
          160  +
          161  +    # Scan : julian day in gmt
          162  +    {clock scan 2451545 -format %J -gmt 1}
          163  +    # Scan : julian day in system TZ
          164  +    {clock scan 2451545 -format %J}
          165  +    # Scan : julian day in other TZ
          166  +    {clock scan 2451545 -format %J -timezone +0200}
          167  +    # Scan : julian day with time:
          168  +    {clock scan "2451545 10:20:30" -format "%J %H:%M:%S"}
          169  +    # Scan : julian day with time (greedy match):
          170  +    {clock scan "2451545 102030" -format "%J%H%M%S"}
          171  +
          172  +    # Scan : century, lookup table month
          173  +    {clock scan {1970 Jan 2} -format {%C%y %b %d} -locale en -gmt 1}
          174  +    # Scan : century, lookup table month and day (both entries are first)
          175  +    {clock scan {1970 Jan 01} -format {%C%y %b %Od} -locale en -gmt 1}
          176  +    # Scan : century, lookup table month and day (list scan: entries with position 12 / 31)
          177  +    {clock scan {2016 Dec 31} -format {%C%y %b %Od} -locale en -gmt 1}
          178  +
          179  +    # Scan : ISO date-time (CEST)
          180  +    {clock scan "2009-06-30T18:30:00+02:00" -format "%Y-%m-%dT%H:%M:%S%z"}
          181  +    {clock scan "2009-06-30T18:30:00 CEST" -format "%Y-%m-%dT%H:%M:%S %z"}
          182  +    # Scan : ISO date-time (UTC)
          183  +    {clock scan "2009-06-30T18:30:00Z" -format "%Y-%m-%dT%H:%M:%S%z"}
          184  +    {clock scan "2009-06-30T18:30:00 UTC" -format "%Y-%m-%dT%H:%M:%S %z"}
          185  +
          186  +    # Scan : locale date-time (en):
          187  +    {clock scan "06/30/2009 18:30:15" -format "%x %X" -gmt 1 -locale en}
          188  +    # Scan : locale date-time (de):
          189  +    {clock scan "30.06.2009 18:30:15" -format "%x %X" -gmt 1 -locale de}
          190  +
          191  +    # Scan : dynamic format (cacheable)
          192  +    {clock scan "25.11.2015 10:35:55" -format [string trim "%d.%m.%Y %H:%M:%S "] -base 0 -gmt 1}
          193  +
          194  +    break
          195  +    # # Scan : long format test (allock chain)
          196  +    # {clock scan "25.11.2015" -format "%d.%m.%Y %d.%m.%Y %d.%m.%Y %d.%m.%Y %d.%m.%Y %d.%m.%Y %d.%m.%Y %d.%m.%Y" -base 0 -gmt 1}
          197  +    # # Scan : dynamic, very long format test (create obj representation, allock chain, GC, etc):
          198  +    # {clock scan "25.11.2015" -format [string repeat "[incr i] %d.%m.%Y %d.%m.%Y" 10] -base 0 -gmt 1}
          199  +    # # Scan : again:
          200  +    # {clock scan "25.11.2015" -format [string repeat "[incr i -1] %d.%m.%Y %d.%m.%Y" 10] -base 0 -gmt 1}
          201  +  } {puts [clock format $_(r) -locale en]}
          202  +}
          203  +
          204  +proc test-freescan {{reptime 1000}} {
          205  +  _test_run $reptime {
          206  +    # FreeScan : relative date
          207  +    {clock scan "5 years 18 months 385 days" -base 0 -gmt 1}
          208  +    # FreeScan : relative date with relative weekday
          209  +    {clock scan "5 years 18 months 385 days Fri" -base 0 -gmt 1}
          210  +    # FreeScan : relative date with ordinal month
          211  +    {clock scan "5 years 18 months 385 days next 1 January" -base 0 -gmt 1}
          212  +    # FreeScan : relative date with ordinal month and relative weekday
          213  +    {clock scan "5 years 18 months 385 days next January Fri" -base 0 -gmt 1}
          214  +    # FreeScan : ordinal month
          215  +    {clock scan "next January" -base 0 -gmt 1}
          216  +    # FreeScan : relative week
          217  +    {clock scan "next Fri" -base 0 -gmt 1}
          218  +    # FreeScan : relative weekday and week offset 
          219  +    {clock scan "next January + 2 week" -base 0 -gmt 1}
          220  +    # FreeScan : time only with base
          221  +    {clock scan "19:18:30" -base 148863600 -gmt 1}
          222  +    # FreeScan : time only without base, gmt
          223  +    {clock scan "19:18:30" -gmt 1}
          224  +    # FreeScan : time only without base, system
          225  +    {clock scan "19:18:30"}
          226  +    # FreeScan : date, system time zone
          227  +    {clock scan "05/08/2016 20:18:30"}
          228  +    # FreeScan : date, supplied time zone
          229  +    {clock scan "05/08/2016 20:18:30" -timezone :CET}
          230  +    # FreeScan : date, supplied gmt (equivalent -timezone :GMT)
          231  +    {clock scan "05/08/2016 20:18:30" -gmt 1}
          232  +    # FreeScan : date, supplied time zone gmt
          233  +    {clock scan "05/08/2016 20:18:30" -timezone :GMT}
          234  +    # FreeScan : time only, numeric zone in string, base time gmt (exchange zones between gmt / -0500)
          235  +    {clock scan "20:18:30 -0500" -base 148863600 -gmt 1}
          236  +    # FreeScan : time only, zone in string (exchange zones between system / gmt)
          237  +    {clock scan "19:18:30 GMT" -base 148863600}
          238  +    # FreeScan : fast switch of zones in cycle - GMT, MST, CET (system) and EST
          239  +    {clock scan "19:18:30 MST" -base 148863600 -gmt 1
          240  +     clock scan "19:18:30 EST" -base 148863600
          241  +    }
          242  +  } {puts [clock format $_(r) -locale en]}
          243  +}
          244  +
          245  +proc test-add {{reptime 1000}} {
          246  +  set tests {
          247  +    # Add : years
          248  +    {clock add 1246379415 5 years -gmt 1}
          249  +    # Add : months
          250  +    {clock add 1246379415 18 months -gmt 1}
          251  +    # Add : weeks
          252  +    {clock add 1246379415 20 weeks -gmt 1}
          253  +    # Add : days
          254  +    {clock add 1246379415 385 days -gmt 1}
          255  +    # Add : weekdays
          256  +    {clock add 1246379415 3 weekdays -gmt 1}
          257  +
          258  +    # Add : hours
          259  +    {clock add 1246379415 5 hours -gmt 1}
          260  +    # Add : minutes
          261  +    {clock add 1246379415 55 minutes -gmt 1}
          262  +    # Add : seconds
          263  +    {clock add 1246379415 100 seconds -gmt 1}
          264  +
          265  +    # Add : +/- in gmt
          266  +    {clock add 1246379415 -5 years +21 months -20 weeks +386 days -19 hours +30 minutes -10 seconds -gmt 1}
          267  +    # Add : +/- in system timezone
          268  +    {clock add 1246379415 -5 years +21 months -20 weeks +386 days -19 hours +30 minutes -10 seconds -timezone :CET}
          269  +
          270  +    # Add : gmt
          271  +    {clock add 1246379415 -5 years 18 months 366 days 5 hours 30 minutes 10 seconds -gmt 1}
          272  +    # Add : system timezone
          273  +    {clock add 1246379415 -5 years 18 months 366 days 5 hours 30 minutes 10 seconds -timezone :CET}
          274  +
          275  +    # Add : all in gmt
          276  +    {clock add 1246379415 4 years 18 months 50 weeks 378 days 3 weekdays 5 hours 30 minutes 10 seconds -gmt 1}
          277  +    # Add : all in system timezone
          278  +    {clock add 1246379415 4 years 18 months 50 weeks 378 days 3 weekdays 5 hours 30 minutes 10 seconds -timezone :CET}
          279  +
          280  +  }
          281  +  # if does not support add of weekdays:
          282  +  if {[catch {clock add 0 3 weekdays -gmt 1}]} {
          283  +    regsub -all {\mweekdays\M} $tests "days" tests
          284  +  }
          285  +  _test_run $reptime $tests {puts [clock format $_(r) -locale en]}
          286  +}
          287  +
          288  +proc test-convert {{reptime 1000}} {
          289  +  _test_run $reptime {
          290  +    # Convert locale (en -> de):
          291  +    {clock format [clock scan "Tue May 30 2017" -format "%a %b %d %Y" -gmt 1 -locale en] -format "%a %b %d %Y" -gmt 1 -locale de}
          292  +    # Convert locale (de -> en):
          293  +    {clock format [clock scan "Di Mai 30 2017" -format "%a %b %d %Y" -gmt 1 -locale de] -format "%a %b %d %Y" -gmt 1 -locale en}
          294  +
          295  +    # Convert TZ: direct
          296  +    {clock format [clock scan "19:18:30" -base 148863600 -timezone EST] -timezone MST}
          297  +    {clock format [clock scan "19:18:30" -base 148863600 -timezone MST] -timezone EST}
          298  +    # Convert TZ: included in scan string & format
          299  +    {clock format [clock scan "19:18:30 EST" -base 148863600] -format "%H:%M:%S %z" -timezone MST}
          300  +    {clock format [clock scan "19:18:30 EST" -base 148863600] -format "%H:%M:%S %z" -timezone EST}
          301  +
          302  +    # Format locale 1x: comparison values
          303  +    {clock format 0 -gmt 1 -locale en} 
          304  +    {clock format 0 -gmt 1 -locale de}
          305  +    {clock format 0 -gmt 1 -locale fr}
          306  +    # Format locale 2x: without switching locale (en, en)
          307  +    {clock format 0 -gmt 1 -locale en; clock format 0 -gmt 1 -locale en}
          308  +    # Format locale 2x: with switching locale (en, de)
          309  +    {clock format 0 -gmt 1 -locale en; clock format 0 -gmt 1 -locale de}
          310  +    # Format locale 3x: without switching locale (en, en, en)
          311  +    {clock format 0 -gmt 1 -locale en; clock format 0 -gmt 1 -locale en; clock format 0 -gmt 1 -locale en}
          312  +    # Format locale 3x: with switching locale (en, de, fr)
          313  +    {clock format 0 -gmt 1 -locale en; clock format 0 -gmt 1 -locale de; clock format 0 -gmt 1 -locale fr}
          314  +
          315  +    # Scan locale 2x: without switching locale (en, en) + (de, de)
          316  +    {clock scan "Tue May 30 2017" -format "%a %b %d %Y" -gmt 1 -locale en; clock scan "Tue May 30 2017" -format "%a %b %d %Y" -gmt 1 -locale en}
          317  +    {clock scan "Di Mai 30 2017" -format "%a %b %d %Y" -gmt 1 -locale de; clock scan "Di Mai 30 2017" -format "%a %b %d %Y" -gmt 1 -locale de}
          318  +    # Scan locale 2x: with switching locale (en, de)
          319  +    {clock scan "Tue May 30 2017" -format "%a %b %d %Y" -gmt 1 -locale en; clock scan "Di Mai 30 2017" -format "%a %b %d %Y" -gmt 1 -locale de}
          320  +    # Scan locale 3x: with switching locale (en, de, fr)
          321  +    {clock scan "Tue May 30 2017" -format "%a %b %d %Y" -gmt 1 -locale en; clock scan "Di Mai 30 2017" -format "%a %b %d %Y" -gmt 1 -locale de; clock scan "mar. mai 30 2017" -format "%a %b %d %Y" -gmt 1 -locale fr}
          322  +
          323  +    # Format TZ 2x: comparison values
          324  +    {clock format 0 -timezone CET -format "%Y-%m-%d %H:%M:%S %z"}
          325  +    {clock format 0 -timezone EST -format "%Y-%m-%d %H:%M:%S %z"}
          326  +    # Format TZ 2x: without switching
          327  +    {clock format 0 -timezone CET -format "%Y-%m-%d %H:%M:%S %z"; clock format 0 -timezone CET -format "%Y-%m-%d %H:%M:%S %z"}
          328  +    {clock format 0 -timezone EST -format "%Y-%m-%d %H:%M:%S %z"; clock format 0 -timezone EST -format "%Y-%m-%d %H:%M:%S %z"}
          329  +    # Format TZ 2x: with switching
          330  +    {clock format 0 -timezone CET -format "%Y-%m-%d %H:%M:%S %z"; clock format 0 -timezone EST -format "%Y-%m-%d %H:%M:%S %z"}
          331  +    # Format TZ 3x: with switching (CET, EST, MST)
          332  +    {clock format 0 -timezone CET -format "%Y-%m-%d %H:%M:%S %z"; clock format 0 -timezone EST -format "%Y-%m-%d %H:%M:%S %z"; clock format 0 -timezone MST -format "%Y-%m-%d %H:%M:%S %z"}
          333  +    # Format TZ 3x: with switching (GMT, EST, MST)
          334  +    {clock format 0 -gmt 1 -format "%Y-%m-%d %H:%M:%S %z"; clock format 0 -timezone EST -format "%Y-%m-%d %H:%M:%S %z"; clock format 0 -timezone MST -format "%Y-%m-%d %H:%M:%S %z"}
          335  +
          336  +    # FreeScan TZ 2x (+1 system-default): without switching TZ
          337  +    {clock scan "19:18:30 MST" -base 148863600; clock scan "19:18:30 MST" -base 148863600}
          338  +    {clock scan "19:18:30 EST" -base 148863600; clock scan "19:18:30 EST" -base 148863600}
          339  +    # FreeScan TZ 2x (+1 system-default): with switching TZ
          340  +    {clock scan "19:18:30 MST" -base 148863600; clock scan "19:18:30 EST" -base 148863600}
          341  +    # FreeScan TZ 2x (+1 gmt, +1 system-default)
          342  +    {clock scan "19:18:30 MST" -base 148863600 -gmt 1; clock scan "19:18:30 EST" -base 148863600}
          343  +    
          344  +    # Scan TZ: comparison included in scan string vs. given
          345  +    {clock scan "2009-06-30T18:30:00 CEST" -format "%Y-%m-%dT%H:%M:%S %z"}
          346  +    {clock scan "2009-06-30T18:30:00 CET" -format "%Y-%m-%dT%H:%M:%S %z"}
          347  +    {clock scan "2009-06-30T18:30:00" -timezone CET -format "%Y-%m-%dT%H:%M:%S"}
          348  +  }
          349  +}
          350  +
          351  +proc test-other {{reptime 1000}} {
          352  +  _test_run $reptime {
          353  +    # Bad zone
          354  +    {catch {clock scan "1 day" -timezone BAD_ZONE -locale en}}
          355  +
          356  +    # Scan : julian day (overflow)
          357  +    {catch {clock scan 5373485 -format %J}}
          358  +
          359  +    # Scan : test rotate of GC objects (format is dynamic, so tcl-obj removed with last reference)
          360  +    {set i 0; time { clock scan "[incr i] - 25.11.2015" -format "$i - %d.%m.%Y" -base 0 -gmt 1 } 50}
          361  +    # Scan : test reusability of GC objects (format is dynamic, so tcl-obj removed with last reference)
          362  +    {set i 50; time { clock scan "[incr i -1] - 25.11.2015" -format "$i - %d.%m.%Y" -base 0 -gmt 1 } 50}
          363  +  }
          364  +}
          365  +
          366  +proc test-ensemble-perf {{reptime 1000}} {
          367  +  _test_run $reptime {
          368  +    # Clock clicks (ensemble)
          369  +    {clock clicks}
          370  +    # Clock clicks (direct)
          371  +    {::tcl::clock::clicks}
          372  +    # Clock seconds (ensemble)
          373  +    {clock seconds}
          374  +    # Clock seconds (direct)
          375  +    {::tcl::clock::seconds}
          376  +    # Clock microseconds (ensemble)
          377  +    {clock microseconds}
          378  +    # Clock microseconds (direct)
          379  +    {::tcl::clock::microseconds}
          380  +    # Clock scan (ensemble)
          381  +    {clock scan ""}
          382  +    # Clock scan (direct)
          383  +    {::tcl::clock::scan ""}
          384  +    # Clock format (ensemble)
          385  +    {clock format 0 -f %s}
          386  +    # Clock format (direct)
          387  +    {::tcl::clock::format 0 -f %s}
          388  +  }
          389  +}
          390  +
          391  +proc test {{reptime 1000}} {
          392  +  puts ""
          393  +  test-ensemble-perf [expr {$reptime / 2}]; #fast enough
          394  +  test-format $reptime
          395  +  test-scan $reptime
          396  +  test-freescan $reptime
          397  +  test-add $reptime
          398  +  test-convert [expr {$reptime / 2}]; #fast enough
          399  +  test-other $reptime
          400  +
          401  +  puts \n**OK**
          402  +}
          403  +
          404  +}; # end of ::tclTestPerf-TclClock
          405  +
          406  +# ------------------------------------------------------------------------
          407  +
          408  +# if calling direct:
          409  +if {[info exists ::argv0] && [file tail $::argv0] eq [file tail [info script]]} {
          410  +  ::tclTestPerf-TclClock::test $in(-time)
          411  +}

Added tests-perf/test-performance.tcl.

            1  +# ------------------------------------------------------------------------
            2  +#
            3  +# test-performance.tcl --
            4  +# 
            5  +#  This file provides common performance tests for comparison of tcl-speed
            6  +#  degradation or regression by switching between branches.
            7  +#
            8  +#  To execute test case evaluate direct corresponding file "tests-perf\*.perf.tcl".
            9  +#
           10  +# ------------------------------------------------------------------------
           11  +# 
           12  +# Copyright (c) 2014 Serg G. Brester (aka sebres)
           13  +# 
           14  +# See the file "license.terms" for information on usage and redistribution
           15  +# of this file.
           16  +# 
           17  +
           18  +namespace eval ::tclTestPerf {
           19  +# warm-up interpeter compiler env, calibrate timerate measurement functionality:
           20  +
           21  +# if no timerate here - import from unsupported:
           22  +if {[namespace which -command timerate] eq {}} {
           23  +  namespace inscope ::tcl::unsupported {namespace export timerate}
           24  +  namespace import ::tcl::unsupported::timerate
           25  +}
           26  +
           27  +# if not yet calibrated:
           28  +if {[lindex [timerate {} 10] 6] >= (10-1)} {
           29  +  puts -nonewline "Calibration ... "; flush stdout
           30  +  puts "done: [lrange \
           31  +    [timerate -calibrate {}] \
           32  +  0 1]"
           33  +}
           34  +
           35  +proc {**STOP**} {args} {
           36  +  return -code error -level 4 "**STOP** in [info level [expr {[info level]-2}]] [join $args { }]" 
           37  +}
           38  +
           39  +proc _test_get_commands {lst} {
           40  +  regsub -all {(?:^|\n)[ \t]*(\#[^\n]*|\msetup\M[^\n]*|\mcleanup\M[^\n]*)(?=\n\s*(?:[\{\#]|setup|cleanup|$))} $lst "\n{\\1}"
           41  +}
           42  +
           43  +proc _test_out_total {} {
           44  +  upvar _ _
           45  +
           46  +  set tcnt [llength $_(itm)]
           47  +  if {!$tcnt} {
           48  +    puts ""
           49  +    return
           50  +  }
           51  +
           52  +  set mintm 0x7fffffff
           53  +  set maxtm 0
           54  +  set nett 0
           55  +  set wtm 0
           56  +  set wcnt 0
           57  +  set i 0
           58  +  foreach tm $_(itm) {
           59  +    if {[llength $tm] > 6} {
           60  +      set nett [expr {$nett + [lindex $tm 6]}]
           61  +    }
           62  +    set wtm [expr {$wtm + [lindex $tm 0]}]
           63  +    set wcnt [expr {$wcnt + [lindex $tm 2]}]
           64  +    set tm [lindex $tm 0]
           65  +    if {$tm > $maxtm} {set maxtm $tm; set maxi $i}
           66  +    if {$tm < $mintm} {set mintm $tm; set mini $i}
           67  +    incr i
           68  +  }
           69  +
           70  +  puts [string repeat ** 40]
           71  +  set s [format "%d cases in %.2f sec." $tcnt [expr {([clock milliseconds] - $_(starttime)) / 1000.0}]]
           72  +  if {$nett > 0} {
           73  +    append s [format " (%.2f nett-sec.)" [expr {$nett / 1000.0}]]
           74  +  }
           75  +  puts "Total $s:"
           76  +  lset _(m) 0 [format %.6f $wtm]
           77  +  lset _(m) 2 $wcnt
           78  +  lset _(m) 4 [format %.3f [expr {$wcnt / (($nett ? $nett : ($tcnt * [lindex $_(reptime) 0])) / 1000.0)}]]
           79  +  if {[llength $_(m)] > 6} {
           80  +    lset _(m) 6 [format %.3f $nett]
           81  +  }
           82  +  puts $_(m)
           83  +  puts "Average:"
           84  +  lset _(m) 0 [format %.6f [expr {[lindex $_(m) 0] / $tcnt}]]
           85  +  lset _(m) 2 [expr {[lindex $_(m) 2] / $tcnt}]
           86  +  if {[llength $_(m)] > 6} {
           87  +    lset _(m) 6 [format %.3f [expr {[lindex $_(m) 6] / $tcnt}]]
           88  +    lset _(m) 4 [format %.0f [expr {[lindex $_(m) 2] / [lindex $_(m) 6] * 1000}]]
           89  +  }
           90  +  puts $_(m)
           91  +  puts "Min:"
           92  +  puts [lindex $_(itm) $mini]
           93  +  puts "Max:"
           94  +  puts [lindex $_(itm) $maxi]
           95  +  puts [string repeat ** 40]
           96  +  puts ""
           97  +}
           98  +
           99  +proc _test_run {args} {
          100  +  upvar _ _
          101  +  # parse args:
          102  +  set _(out-result) 1
          103  +  if {[lindex $args 0] eq "-no-result"} {
          104  +    set _(out-result) 0
          105  +    set args [lrange $args 1 end]
          106  +  }
          107  +  if {[llength $args] < 2 || [llength $args] > 3} {
          108  +    return -code error "wrong # args: should be \"[lindex [info level [info level]] 0] ?-no-result? reptime lst ?outcmd?\""
          109  +  }
          110  +  set outcmd {puts $_(r)}
          111  +  set args [lassign $args reptime lst]
          112  +  if {[llength $args]} {
          113  +    set outcmd [lindex $args 0]
          114  +  }
          115  +  # avoid output if only once:
          116  +  if {[lindex $reptime 0] <= 1 || ([llength $reptime] > 1 && [lindex $reptime 1] == 1)} {
          117  +    set _(out-result) 0
          118  +  }
          119  +  array set _ [list itm {} reptime $reptime starttime [clock milliseconds]]
          120  +
          121  +  # process measurement:
          122  +  foreach _(c) [_test_get_commands $lst] {
          123  +    puts "% [regsub -all {\n[ \t]*} $_(c) {; }]"
          124  +    if {[regexp {^\s*\#} $_(c)]} continue
          125  +    if {[regexp {^\s*(?:setup|cleanup)\s+} $_(c)]} {
          126  +      puts [if 1 [lindex $_(c) 1]]
          127  +      continue
          128  +    }
          129  +    # if output result (and not once):
          130  +    if {$_(out-result)} {
          131  +      set _(r) [if 1 $_(c)]
          132  +      if {$outcmd ne {}} $outcmd
          133  +      if {[llength $_(reptime)] > 1} { # decrement max-count
          134  +        lset _(reptime) 1 [expr {[lindex $_(reptime) 1] - 1}]
          135  +      }
          136  +    }
          137  +    puts [set _(m) [timerate $_(c) {*}$_(reptime)]]
          138  +    lappend _(itm) $_(m)
          139  +    puts ""
          140  +  }
          141  +  _test_out_total
          142  +}
          143  +
          144  +}; # end of namespace ::tclTestPerf

Added tests-perf/timer-event.perf.tcl.

            1  +#!/usr/bin/tclsh
            2  +
            3  +# ------------------------------------------------------------------------
            4  +#
            5  +# timer-event.perf.tcl --
            6  +# 
            7  +#  This file provides performance tests for comparison of tcl-speed
            8  +#  of timer events (event-driven tcl-handling).
            9  +#
           10  +# ------------------------------------------------------------------------
           11  +# 
           12  +# Copyright (c) 2014 Serg G. Brester (aka sebres)
           13  +# 
           14  +# See the file "license.terms" for information on usage and redistribution
           15  +# of this file.
           16  +# 
           17  +
           18  +
           19  +if {![namespace exists ::tclTestPerf]} {
           20  +  source [file join [file dirname [info script]] test-performance.tcl]
           21  +}
           22  +
           23  +
           24  +namespace eval ::tclTestPerf-Timer-Event {
           25  +
           26  +namespace path {::tclTestPerf}
           27  +
           28  +proc test-queue {{reptime {1000 10000}}} {
           29  +
           30  +  set howmuch [lindex $reptime 1]
           31  +
           32  +  # because of extremely short measurement times by tests below, wait a little bit (warming-up),
           33  +  # to minimize influence of the time-gradation (just for better dispersion resp. result-comparison)
           34  +  timerate {after 0} 156
           35  +
           36  +  puts "*** up to $howmuch events ***"
           37  +  # single iteration by update, so using -no-result (measure only):
           38  +  _test_run -no-result $reptime [string map [list \{*\}\$reptime $reptime \$howmuch $howmuch \\# \#] {
           39  +    # generate up to $howmuch idle-events:
           40  +    {after idle {set foo bar}}
           41  +    # update / after idle:
           42  +    {update; if {![llength [after info]]} break}
           43  +    
           44  +    # generate up to $howmuch idle-events:
           45  +    {after idle {set foo bar}}
           46  +    # update idletasks / after idle:
           47  +    {update idletasks; if {![llength [after info]]} break}
           48  +
           49  +    # generate up to $howmuch immediate events:
           50  +    {after 0 {set foo bar}}
           51  +    # update / after 0:
           52  +    {update; if {![llength [after info]]} break}
           53  +    
           54  +    # generate up to $howmuch 1-ms events:
           55  +    {after 1 {set foo bar}}
           56  +    setup {after 1}
           57  +    # update / after 1:
           58  +    {update; if {![llength [after info]]} break}
           59  +
           60  +    # generate up to $howmuch immediate events (+ 1 event of the second generation):
           61  +    {after 0 {after 0 {}}}
           62  +    # update / after 0 (double generation):
           63  +    {update; if {![llength [after info]]} break}
           64  +
           65  +    # cancel forwards "after idle" / $howmuch idle-events in queue:
           66  +    setup {set i 0; timerate {set ev([incr i]) [after idle {set foo bar}]} {*}$reptime}
           67  +    setup {set le $i; set i 0; list 1 .. $le; # cancel up to $howmuch events}
           68  +    {after cancel $ev([incr i]); if {$i >= $le} break}
           69  +    cleanup {update; unset -nocomplain ev}
           70  +    # cancel backwards "after idle" / $howmuch idle-events in queue:
           71  +    setup {set i 0; timerate {set ev([incr i]) [after idle {set foo bar}]} {*}$reptime}
           72  +    setup {set le $i; incr i; list $le .. 1; # cancel up to $howmuch events}
           73  +    {after cancel $ev([incr i -1]); if {$i <= 1} break}
           74  +    cleanup {update; unset -nocomplain ev}
           75  +
           76  +    # cancel forwards "after 0" / $howmuch timer-events in queue:
           77  +    setup {set i 0; timerate {set ev([incr i]) [after 0 {set foo bar}]} {*}$reptime}
           78  +    setup {set le $i; set i 0; list 1 .. $le; # cancel up to $howmuch events}
           79  +    {after cancel $ev([incr i]); if {$i >= $le} break}
           80  +    cleanup {update; unset -nocomplain ev}
           81  +    # cancel backwards "after 0" / $howmuch timer-events in queue:
           82  +    setup {set i 0; timerate {set ev([incr i]) [after 0 {set foo bar}]} {*}$reptime}
           83  +    setup {set le $i; incr i; list $le .. 1; # cancel up to $howmuch events}
           84  +    {after cancel $ev([incr i -1]); if {$i <= 1} break}
           85  +    cleanup {update; unset -nocomplain ev}
           86  +    
           87  +    # end $howmuch events.
           88  +    cleanup {if [llength [after info]] {error "unexpected: [llength [after info]] events are still there."}}
           89  +  }]
           90  +}
           91  +
           92  +proc test-access {{reptime {1000 5000}}} {
           93  +  set howmuch [lindex $reptime 1]
           94  +
           95  +  _test_run $reptime [string map [list \{*\}\$reptime $reptime \$howmuch $howmuch] {
           96  +    # event random access: after idle + after info (by $howmuch events)
           97  +    setup {set i -1; timerate {set ev([incr i]) [after idle {}]} {*}$reptime}
           98  +    {after info $ev([expr {int(rand()*$i)}])}
           99  +    cleanup {update; unset -nocomplain ev}
          100  +    # event random access: after 0 + after info (by $howmuch events)
          101  +    setup {set i -1; timerate {set ev([incr i]) [after 0 {}]} {*}$reptime}
          102  +    {after info $ev([expr {int(rand()*$i)}])}
          103  +    cleanup {update; unset -nocomplain ev}
          104  +
          105  +    # end $howmuch events.
          106  +    cleanup {if [llength [after info]] {error "unexpected: [llength [after info]] events are still there."}}
          107  +  }]
          108  +}
          109  +
          110  +proc test-exec {{reptime 1000}} {
          111  +  _test_run $reptime {
          112  +    # after idle + after cancel
          113  +    {after cancel [after idle {set foo bar}]}
          114  +    # after 0 + after cancel
          115  +    {after cancel [after 0 {set foo bar}]}
          116  +    # after idle + update idletasks
          117  +    {after idle {set foo bar}; update idletasks}
          118  +    # after idle + update
          119  +    {after idle {set foo bar}; update}
          120  +    # immediate: after 0 + update
          121  +    {after 0 {set foo bar}; update}
          122  +    # delayed: after 1 + update
          123  +    {after 1 {set foo bar}; update}
          124  +    # empty update:
          125  +    {update}
          126  +    # empty update idle tasks:
          127  +    {update idletasks}
          128  +
          129  +    # simple shortest sleep:
          130  +    {after 0}
          131  +  }
          132  +}
          133  +
          134  +proc test-nrt-capability {{reptime 1000}} {
          135  +  _test_run $reptime {
          136  +    # comparison values:
          137  +    {after 0 {set a 5}; update}
          138  +    {after 0 {set a 5}; vwait a}
          139  +
          140  +    # conditional vwait with very brief wait-time:
          141  +    {after 1 {set a timeout}; vwait a; expr {$::a ne "timeout" ? 1 : "0[unset ::a]"}}
          142  +    {after 0 {set a timeout}; vwait a; expr {$::a ne "timeout" ? 1 : "0[unset ::a]"}}
          143  +  }
          144  +}
          145  +
          146  +proc test-long {{reptime 1000}} {
          147  +  _test_run $reptime {
          148  +    # in-between important event by amount of idle events:
          149  +    {time {after idle {after 30}} 10; after 1 {set important 1}; vwait important;}
          150  +    cleanup {foreach i [after info] {after cancel $i}}
          151  +    # in-between important event (of new generation) by amount of idle events:
          152  +    {time {after idle {after 30}} 10; after 1 {after 0 {set important 1}}; vwait important;} 
          153  +    cleanup {foreach i [after info] {after cancel $i}}
          154  +  }
          155  +}
          156  +
          157  +proc test {{reptime 1000}} {
          158  +  test-exec $reptime
          159  +  foreach howmuch {5000 50000} {
          160  +    test-access [list $reptime $howmuch]
          161  +  }
          162  +  test-nrt-capability $reptime
          163  +  test-long $reptime
          164  +
          165  +  puts ""
          166  +  foreach howmuch { 10000 20000 40000 60000 } {
          167  +    test-queue [list $reptime $howmuch]
          168  +  }
          169  +
          170  +  puts \n**OK**
          171  +}
          172  +
          173  +}; # end of ::tclTestPerf-Timer-Event
          174  +
          175  +# ------------------------------------------------------------------------
          176  +
          177  +# if calling direct:
          178  +if {[info exists ::argv0] && [file tail $::argv0] eq [file tail [info script]]} {
          179  +  array set in {-time 500}
          180  +  array set in $argv
          181  +  ::tclTestPerf-Timer-Event::test $in(-time)
          182  +}

Changes to tests/cmdMZ.test.

   337    337   test cmdMZ-5.7 {Tcl_TimeObjCmd: errors generate right trace} {
   338    338       list [catch {time {error foo}} msg] $msg $::errorInfo
   339    339   } {1 foo {foo
   340    340       while executing
   341    341   "error foo"
   342    342       invoked from within
   343    343   "time {error foo}"}}
          344  +
          345  +test cmdMZ-6.1 {Tcl_TimeRateObjCmd: basic format of command} {
          346  +    list [catch {timerate} msg] $msg
          347  +} {1 {wrong # args: should be "timerate ?-direct? ?-calibrate? ?-overhead double? command ?time ?max-count??"}}
          348  +test cmdMZ-6.2.1 {Tcl_TimeRateObjCmd: basic format of command} {
          349  +    list [catch {timerate a b c d} msg] $msg
          350  +} {1 {wrong # args: should be "timerate ?-direct? ?-calibrate? ?-overhead double? command ?time ?max-count??"}}
          351  +test cmdMZ-6.2.2 {Tcl_TimeRateObjCmd: basic format of command} {
          352  +    list [catch {timerate a b c} msg] $msg
          353  +} {1 {expected integer but got "b"}}
          354  +test cmdMZ-6.2.3 {Tcl_TimeRateObjCmd: basic format of command} {
          355  +    list [catch {timerate a b} msg] $msg
          356  +} {1 {expected integer but got "b"}}
          357  +test cmdMZ-6.3 {Tcl_TimeRateObjCmd: basic format of command} {
          358  +    list [catch {timerate -overhead b {} a b} msg] $msg
          359  +} {1 {expected floating-point number but got "b"}}
          360  +test cmdMZ-6.4 {Tcl_TimeRateObjCmd: compile of script happens even with negative iteration counts} {
          361  +    list [catch {timerate "foreach a {c d e} \{" -12456} msg] $msg
          362  +} {1 {missing close-brace}}
          363  +test cmdMZ-6.5 {Tcl_TimeRateObjCmd: result format and one iteration} {
          364  +    regexp {^\d+.\d+ \ws/# 1 # \d+ #/sec \d+.\d+ nett-ms$} [timerate {} 0]
          365  +} 1
          366  +test cmdMZ-6.6 {Tcl_TimeRateObjCmd: slower commands take longer, but it remains almost the same time of measument} {
          367  +    set m1 [timerate {after 0} 20]
          368  +    set m2 [timerate {after 1} 20]
          369  +    list \
          370  +	[expr {[lindex $m1 0] < [lindex $m2 0]}] \
          371  +	[expr {[lindex $m1 0] < 100}] \
          372  +	[expr {[lindex $m2 0] >= 500}] \
          373  +	[expr {[lindex $m1 2] > 1000}] \
          374  +	[expr {[lindex $m2 2] <= 50}] \
          375  +	[expr {[lindex $m1 4] > 10000}] \
          376  +	[expr {[lindex $m2 4] < 10000}] \
          377  +	[expr {[lindex $m1 6] > 10 && [lindex $m1 6] < 50}] \
          378  +	[expr {[lindex $m2 6] > 10 && [lindex $m2 6] < 50}]
          379  +} [lrepeat 9 1]
          380  +test cmdMZ-6.7 {Tcl_TimeRateObjCmd: errors generate right trace} {
          381  +    list [catch {timerate {error foo} 1} msg] $msg $::errorInfo
          382  +} {1 foo {foo
          383  +    while executing
          384  +"error foo"
          385  +    invoked from within
          386  +"timerate {error foo} 1"}}
          387  +test cmdMZ-6.8 {Tcl_TimeRateObjCmd: allow (conditional) break from timerate} {
          388  +    set m1 [timerate {break}]
          389  +    list \
          390  +	[expr {[lindex $m1 0] < 1000}] \
          391  +	[expr {[lindex $m1 2] == 1}] \
          392  +	[expr {[lindex $m1 4] > 1000}] \
          393  +	[expr {[lindex $m1 6] < 10}]
          394  +} {1 1 1 1}
          395  +test cmdMZ-6.9 {Tcl_TimeRateObjCmd: max count of iterations} {
          396  +    set m1 [timerate {} 1000 5];	# max-count wins
          397  +    set m2 [timerate {after 20} 1 5];	# max-time wins
          398  +    list [lindex $m1 2] [lindex $m2 2]
          399  +} {5 1}
          400  +test cmdMZ-6.10 {Tcl_TimeRateObjCmd: huge overhead cause 0us result} {
          401  +    set m1 [timerate -overhead 1e6 {after 10} 100 1]
          402  +    list \
          403  +	[expr {[lindex $m1 0] == 0.0}] \
          404  +	[expr {[lindex $m1 2] == 1}] \
          405  +	[expr {[lindex $m1 4] == 1000000}] \
          406  +	[expr {[lindex $m1 6] <= 0.001}]
          407  +} {1 1 1 1}
   344    408   
   345    409   # The tests for Tcl_WhileObjCmd are in while.test
   346    410   
   347    411   # cleanup
   348    412   cleanupTests
   349    413   }
   350    414   namespace delete ::tcl::test::cmdMZ
   351    415   return
   352    416   
   353    417   # Local Variables:
   354    418   # mode: tcl
   355    419   # End:

Changes to tests/proc.test.

   317    317   	set end [getbytes]
   318    318       }
   319    319       set leakedBytes [expr {$end - $tmp}]
   320    320   } -cleanup {
   321    321       rename getbytes {}
   322    322       unset -nocomplain end i tmp leakedBytes
   323    323   } -result 0
          324  +test proc-4.9 {[39fed4dae5] Valid Tcl_PkgPresent return} procbodytest {
          325  +    procbodytest::check
          326  +} 1
   324    327   
   325    328   test proc-5.1 {Bytecompiling noop; test for correct argument substitution} -body {
   326    329       proc p args {} ; # this will be bytecompiled into t
   327    330       proc t {} {
   328    331   	set res {}
   329    332   	set a 0
   330    333   	set b 0

Changes to tools/tcltk-man2html-utils.tcl.

   145    145   	    {\%}	{} \
   146    146   	    "\\\n"	"\n" \
   147    147   	    {\(+-}	"&#177;" \
   148    148   	    {\(co}	"&copy;" \
   149    149   	    {\(em}	"&#8212;" \
   150    150   	    {\(en}	"&#8211;" \
   151    151   	    {\(fm}	"&#8242;" \
          152  +	    {\(mc}	"&#181;" \
   152    153   	    {\(mu}	"&#215;" \
   153    154   	    {\(mi}	"&#8722;" \
   154    155   	    {\(->}	"<font size=\"+1\">&#8594;</font>" \
   155    156   	    {\fP}	{\fR} \
   156    157   	    {\.}	. \
   157    158   	    {\(bu}	"&#8226;" \
   158    159   	    ]

Changes to unix/tclUnixTime.c.

    55     55   {
    56     56       return time(NULL);
    57     57   }
    58     58   
    59     59   /*
    60     60    *----------------------------------------------------------------------
    61     61    *
           62  + * TclpGetMicroseconds --
           63  + *
           64  + *	This procedure returns the number of microseconds from the epoch.
           65  + *	On most Unix systems the epoch is Midnight Jan 1, 1970 GMT.
           66  + *
           67  + * Results:
           68  + *	Number of microseconds from the epoch.
           69  + *
           70  + * Side effects:
           71  + *	None.
           72  + *
           73  + *----------------------------------------------------------------------
           74  + */
           75  +
           76  +Tcl_WideInt
           77  +TclpGetMicroseconds(void)
           78  +{
           79  +    Tcl_Time time;
           80  +
           81  +    tclGetTimeProcPtr(&time, tclTimeClientData);
           82  +    return ((Tcl_WideInt)time.sec)*1000000 + time.usec;
           83  +}
           84  +
           85  +/*
           86  + *----------------------------------------------------------------------
           87  + *
    62     88    * TclpGetClicks --
    63     89    *
    64     90    *	This procedure returns a value that represents the highest resolution
    65     91    *	clock available on the system. There are no garantees on what the
    66     92    *	resolution will be. In Tcl we will call this value a "click". The
    67     93    *	start time is also system dependant.
    68     94    *
................................................................................
   187    213   #else
   188    214   #error Wide high-resolution clicks not implemented on this platform
   189    215   #endif
   190    216       }
   191    217   
   192    218       return nsec;
   193    219   }
          220  +
          221  +/*
          222  + *----------------------------------------------------------------------
          223  + *
          224  + * TclpWideClickInMicrosec --
          225  + *
          226  + *	This procedure return scale to convert click values from the
          227  + *	TclpGetWideClicks native resolution to microsecond resolution
          228  + *	and back.
          229  + *
          230  + * Results:
          231  + * 	1 click in microseconds as double.
          232  + *
          233  + * Side effects:
          234  + *	None.
          235  + *
          236  + *----------------------------------------------------------------------
          237  + */
          238  +
          239  +double
          240  +TclpWideClickInMicrosec(void)
          241  +{
          242  +    if (tclGetTimeProcPtr != NativeGetTime) {
          243  +	return 1.0;
          244  +    } else {
          245  +#ifdef MAC_OSX_TCL
          246  +	static int initialized = 0;
          247  +	static double scale = 0.0;
          248  +
          249  +	if (initialized) {
          250  +	    return scale;
          251  +	} else {
          252  +	    mach_timebase_info_data_t tb;
          253  +
          254  +	    mach_timebase_info(&tb);
          255  +	    /* value of tb.numer / tb.denom = 1 click in nanoseconds */
          256  +	    scale = ((double)tb.numer) / tb.denom / 1000;
          257  +	    initialized = 1;
          258  +	    return scale;
          259  +	}
          260  +#else
          261  +#error Wide high-resolution clicks not implemented on this platform
          262  +#endif
          263  +    }
          264  +}
   194    265   #endif /* TCL_WIDE_CLICKS */
   195    266   
   196    267   /*
   197    268    *----------------------------------------------------------------------
   198    269    *
   199    270    * Tcl_GetTime --
   200    271    *

Changes to win/makefile.vc.

   386    386   release:    setup $(TCLSH) $(TCLSTUBLIB) dlls pkgs
   387    387   core:	    setup $(TCLLIB) $(TCLSTUBLIB)
   388    388   shell:	    setup $(TCLSH)
   389    389   dlls:	    setup $(TCLREGLIB) $(TCLDDELIB)
   390    390   all:	    setup $(TCLSH) $(TCLSTUBLIB) dlls pkgs
   391    391   tcltest:    setup $(TCLTEST) dlls
   392    392   install:    install-binaries install-libraries install-docs install-pkgs
          393  +!if $(SYMBOLS)
          394  +install:    install-pdbs
          395  +!endif
   393    396   setup:      default-setup
   394    397   
   395    398   test: test-core test-pkgs
   396    399   test-core: setup $(TCLTEST) dlls
   397    400   	set TCL_LIBRARY=$(ROOT:\=/)/library
   398    401   	$(DEBUGGER) $(TCLTEST) "$(ROOT:\=/)/tests/all.tcl" $(TESTFLAGS) -loadfile <<
   399    402   		package ifneeded dde 1.4.1 [list load "$(TCLDDELIB:\=/)" dde]
................................................................................
   911    914   
   912    915   install-msgs:
   913    916   	@echo Installing message catalogs
   914    917   	@set TCL_LIBRARY=$(ROOT:\=/)/library
   915    918   	@$(TCLSH_NATIVE) "$(ROOT:\=/)/tools/installData.tcl" \
   916    919   	    "$(ROOT:\=/)/library/msgs" "$(SCRIPT_INSTALL_DIR)/msgs"
   917    920   
          921  +install-pdbs:
          922  +	@echo Installing debug symbols
          923  +	@$(CPY) "$(OUT_DIR)\*.pdb" "$(BIN_INSTALL_DIR)\"
          924  +# "emacs font-lock highlighting fix
          925  +
   918    926   #---------------------------------------------------------------------
   919    927   # Clean up
   920    928   #---------------------------------------------------------------------
   921    929   
   922    930   tidy:
   923    931   !if "$(TCLLIB)" != "$(TCLIMPLIB)"
   924    932   	@echo Removing $(TCLLIB) ...

Changes to win/nmakehlp.c.

   789    789    *      If found, the command prints
   790    790    *         name_DIRPATH=<full path of located directory>
   791    791    *      and returns 0. If not found, does not print anything and returns 1.
   792    792    */
   793    793   static int LocateDependency(const char *keypath)
   794    794   {
   795    795       int i, ret;
   796         -    static char *paths[] = {"..", "..\\..", "..\\..\\.."};
          796  +    static const char *paths[] = {"..", "..\\..", "..\\..\\.."};
   797    797   
   798    798       for (i = 0; i < (sizeof(paths)/sizeof(paths[0])); ++i) {
   799    799   	ret = LocateDependencyHelper(paths[i], keypath);
   800    800   	if (ret == 0)
   801    801   	    return ret;
   802    802       }
   803    803       return ret;

Changes to win/rules.vc.

   470    470   !endif
   471    471   !if "$(MACHINE)" != "$(ARCH)"
   472    472   !error Specified MACHINE macro $(MACHINE) does not match detected target architecture $(ARCH).
   473    473   !endif
   474    474   !else
   475    475   MACHINE=$(ARCH)
   476    476   !endif
          477  +
          478  +#---------------------------------------------------------------
          479  +# The PLATFORM_IDENTIFY macro matches the values returned by
          480  +# the Tcl platform::identify command
          481  +!if "$(MACHINE)" == "AMD64"
          482  +PLATFORM_IDENTIFY = win32-x86_64
          483  +!else
          484  +PLATFORM_IDENTIFY = win32-ix86
          485  +!endif
          486  +
          487  +# The MULTIPLATFORM macro controls whether binary extensions are installed
          488  +# in platform-specific directories. Intended to be set/used by extensions.
          489  +!ifndef MULTIPLATFORM_INSTALL
          490  +MULTIPLATFORM_INSTALL = 0
          491  +!endif
   477    492   
   478    493   #------------------------------------------------------------
   479    494   # Figure out the *host* architecture by reading the registry
   480    495   
   481    496   !if ![reg query HKLM\Hardware\Description\System\CentralProcessor\0 /v Identifier | findstr /i x86]
   482    497   NATIVE_ARCH=IX86
   483    498   !else
................................................................................
   726    741   !if [nmakehlp -f $(OPTS) "staticpkg"] && $(STATIC_BUILD)
   727    742   !message *** Doing staticpkg
   728    743   TCL_USE_STATIC_PACKAGES	= 1
   729    744   !else
   730    745   TCL_USE_STATIC_PACKAGES	= 0
   731    746   !endif
   732    747   
          748  +# Yes, it's weird that the "symbols" option controls DEBUG and
          749  +# the "pdbs" option controls SYMBOLS. That's historical.
   733    750   !if [nmakehlp -f $(OPTS) "symbols"]
   734    751   !message *** Doing symbols
   735    752   DEBUG		= 1
   736    753   !else
   737    754   DEBUG		= 0
   738    755   !endif
   739    756   
................................................................................
  1201   1218   !endif
  1202   1219   DEMO_INSTALL_DIR	= $(SCRIPT_INSTALL_DIR)\demos
  1203   1220   INCLUDE_INSTALL_DIR	= $(_INSTALLDIR)\include
  1204   1221   
  1205   1222   !else # extension other than Tk
  1206   1223   
  1207   1224   PRJ_INSTALL_DIR         = $(_INSTALLDIR)\$(PROJECT)$(DOTVERSION)
         1225  +!if $(MULTIPLATFORM_INSTALL)
         1226  +LIB_INSTALL_DIR		= $(PRJ_INSTALL_DIR)\$(PLATFORM_IDENTIFY)
         1227  +BIN_INSTALL_DIR		= $(PRJ_INSTALL_DIR)\$(PLATFORM_IDENTIFY)
         1228  +!else
  1208   1229   LIB_INSTALL_DIR		= $(PRJ_INSTALL_DIR)
  1209   1230   BIN_INSTALL_DIR		= $(PRJ_INSTALL_DIR)
         1231  +!endif
  1210   1232   DOC_INSTALL_DIR		= $(PRJ_INSTALL_DIR)
  1211   1233   SCRIPT_INSTALL_DIR	= $(PRJ_INSTALL_DIR)
  1212   1234   DEMO_INSTALL_DIR	= $(PRJ_INSTALL_DIR)\demos
  1213   1235   INCLUDE_INSTALL_DIR	= $(_INSTALLDIR)\..\include
  1214   1236   
  1215   1237   !endif
  1216   1238   
................................................................................
  1476   1498   
  1477   1499   !ifndef DEFAULT_BUILD_TARGET
  1478   1500   DEFAULT_BUILD_TARGET = $(PROJECT)
  1479   1501   !endif
  1480   1502   
  1481   1503   default-target: $(DEFAULT_BUILD_TARGET)
  1482   1504   
         1505  +!if $(MULTIPLATFORM_INSTALL)
         1506  +default-pkgindex:
         1507  +	@echo package ifneeded $(PRJ_PACKAGE_TCLNAME) $(DOTVERSION) \
         1508  +	    [list load [file join $$dir $(PLATFORM_IDENTIFY) $(PRJLIBNAME)]] > $(OUT_DIR)\pkgIndex.tcl
         1509  +!else
  1483   1510   default-pkgindex:
  1484   1511   	@echo package ifneeded $(PRJ_PACKAGE_TCLNAME) $(DOTVERSION) \
  1485   1512   	    [list load [file join $$dir $(PRJLIBNAME)]] > $(OUT_DIR)\pkgIndex.tcl
         1513  +!endif
  1486   1514   
  1487   1515   default-pkgindex-tea:
  1488   1516   	@if exist $(ROOT)\pkgIndex.tcl.in nmakehlp -s << $(ROOT)\pkgIndex.tcl.in > $(OUT_DIR)\pkgIndex.tcl
  1489   1517   @[email protected]    $(DOTVERSION)
  1490   1518   @[email protected]       $(PRJ_PACKAGE_TCLNAME)
  1491   1519   @[email protected]    $(PRJ_PACKAGE_TCLNAME)
  1492   1520   @[email protected]       $(PRJLIBNAME)
  1493   1521   <<
  1494   1522   
  1495         -
  1496   1523   default-install: default-install-binaries default-install-libraries
         1524  +!if $(SYMBOLS)
         1525  +default-install: default-install-pdbs
         1526  +!endif
  1497   1527   
         1528  +# Again to deal with historical brokenness, there is some confusion
         1529  +# in terminlogy. For extensions, the "install-binaries" was used to
         1530  +# locate target directory for *binary shared libraries* and thus
         1531  +# the appropriate macro is LIB_INSTALL_DIR since BIN_INSTALL_DIR is
         1532  +# for executables (exes). On the other hand the "install-libraries"
         1533  +# target is for *scripts* and should have been called "install-scripts".
  1498   1534   default-install-binaries: $(PRJLIB)
  1499         -	@echo Installing binaries to '$(SCRIPT_INSTALL_DIR)'
  1500         -	@if not exist "$(SCRIPT_INSTALL_DIR)" mkdir "$(SCRIPT_INSTALL_DIR)"
  1501         -	@$(CPY) $(PRJLIB) "$(SCRIPT_INSTALL_DIR)" >NUL
         1535  +	@echo Installing binaries to '$(LIB_INSTALL_DIR)'
         1536  +	@if not exist "$(LIB_INSTALL_DIR)" mkdir "$(LIB_INSTALL_DIR)"
         1537  +	@$(CPY) $(PRJLIB) "$(LIB_INSTALL_DIR)" >NUL
  1502   1538   
  1503         -default-install-libraries: $(OUT_DIR)\pkgIndex.tcl
         1539  +# Alias for default-install-scripts
         1540  +default-install-libraries: default-install-scripts
         1541  +
         1542  +default-install-scripts: $(OUT_DIR)\pkgIndex.tcl
  1504   1543   	@echo Installing libraries to '$(SCRIPT_INSTALL_DIR)'
  1505   1544   	@if exist $(LIBDIR) $(CPY) $(LIBDIR)\*.tcl "$(SCRIPT_INSTALL_DIR)"
  1506   1545   	@echo Installing package index in '$(SCRIPT_INSTALL_DIR)'
  1507   1546   	@$(CPY) $(OUT_DIR)\pkgIndex.tcl $(SCRIPT_INSTALL_DIR)
  1508   1547   
  1509   1548   default-install-stubs:
  1510   1549   	@echo Installing stubs library to '$(SCRIPT_INSTALL_DIR)'
  1511   1550   	@if not exist "$(SCRIPT_INSTALL_DIR)" mkdir "$(SCRIPT_INSTALL_DIR)"
  1512   1551   	@$(CPY) $(PRJSTUBLIB) "$(SCRIPT_INSTALL_DIR)" >NUL
  1513   1552   
         1553  +default-install-pdbs:
         1554  +	@echo Installing PDBs to '$(LIB_INSTALL_DIR)'
         1555  +	@if not exist "$(LIB_INSTALL_DIR)" mkdir "$(LIB_INSTALL_DIR)"
         1556  +	@$(CPY) "$(OUT_DIR)\*.pdb" "$(LIB_INSTALL_DIR)\"
         1557  +
  1514   1558   default-install-docs-html:
  1515   1559   	@echo Installing documentation files to '$(DOC_INSTALL_DIR)'
  1516   1560   	@if not exist "$(DOC_INSTALL_DIR)" mkdir "$(DOC_INSTALL_DIR)"
  1517   1561   	@if exist $(DOCDIR) for %f in ("$(DOCDIR)\*.html" "$(DOCDIR)\*.css" "$(DOCDIR)\*.png") do @$(COPY) %f "$(DOC_INSTALL_DIR)"
  1518   1562   
  1519   1563   default-install-docs-n:
  1520   1564   	@echo Installing documentation files to '$(DOC_INSTALL_DIR)'

Changes to win/tclWinTime.c.

    24     24   
    25     25   typedef struct {
    26     26       CRITICAL_SECTION cs;	/* Mutex guarding this structure. */
    27     27       int initialized;		/* Flag == 1 if this structure is
    28     28   				 * initialized. */
    29     29       int perfCounterAvailable;	/* Flag == 1 if the hardware has a performance
    30     30   				 * counter. */
           31  +    DWORD calibrationInterv;	/* Calibration interval in seconds (start 1 sec) */
    31     32       HANDLE calibrationThread;	/* Handle to the thread that keeps the virtual
    32     33   				 * clock calibrated. */
    33     34       HANDLE readyEvent;		/* System event used to trigger the requesting
    34     35   				 * thread when the clock calibration procedure
    35     36   				 * is initialized for the first time. */
    36     37       HANDLE exitEvent; 		/* Event to signal out of an exit handler to
    37     38   				 * tell the calibration loop to terminate. */
    38     39       LARGE_INTEGER nominalFreq;	/* Nominal frequency of the system performance
    39     40   				 * counter, that is, the value returned from
    40     41   				 * QueryPerformanceFrequency. */
    41         -
    42     42       /*
    43     43        * The following values are used for calculating virtual time. Virtual
    44     44        * time is always equal to:
    45     45        *    lastFileTime + (current perf counter - lastCounter)
    46     46        *				* 10000000 / curCounterFreq
    47     47        * and lastFileTime and lastCounter are updated any time that virtual time
    48     48        * is returned to a caller.
    49     49        */
    50     50   
    51     51       ULARGE_INTEGER fileTimeLastCall;
    52     52       LARGE_INTEGER perfCounterLastCall;
    53     53       LARGE_INTEGER curCounterFreq;
           54  +    LARGE_INTEGER posixEpoch;	/* Posix epoch expressed as 100-ns ticks since
           55  +				 * the windows epoch. */
    54     56   
    55     57       /*
    56     58        * Data used in developing the estimate of performance counter frequency
    57     59        */
    58     60   
    59     61       Tcl_WideUInt fileTimeSample[SAMPLES];
    60     62   				/* Last 64 samples of system time. */
................................................................................
    63     65       int sampleNo;		/* Current sample number. */
    64     66   } TimeInfo;
    65     67   
    66     68   static TimeInfo timeInfo = {
    67     69       { NULL, 0, 0, NULL, NULL, 0 },
    68     70       0,
    69     71       0,
           72  +    1,
    70     73       (HANDLE) NULL,
    71     74       (HANDLE) NULL,
    72     75       (HANDLE) NULL,
    73     76   #ifdef HAVE_CAST_TO_UNION
    74     77       (LARGE_INTEGER) (Tcl_WideInt) 0,
    75     78       (ULARGE_INTEGER) (DWORDLONG) 0,
    76     79       (LARGE_INTEGER) (Tcl_WideInt) 0,
    77     80       (LARGE_INTEGER) (Tcl_WideInt) 0,
           81  +    (LARGE_INTEGER) (Tcl_WideInt) 0,
    78     82   #else
    79         -    0,
    80         -    0,
    81         -    0,
    82         -    0,
           83  +    {0, 0},
           84  +    {0, 0},
           85  +    {0, 0},
           86  +    {0, 0},
           87  +    {0, 0},
    83     88   #endif
    84     89       { 0 },
    85     90       { 0 },
    86     91       0
    87     92   };
           93  +
           94  +/*
           95  + * Scale to convert wide click values from the TclpGetWideClicks native
           96  + * resolution to microsecond resolution and back.
           97  + */
           98  +static struct {
           99  +    int initialized;		/* 1 if initialized, 0 otherwise */
          100  +    int perfCounter;		/* 1 if performance counter usable for wide clicks */
          101  +    double microsecsScale;	/* Denominator scale between clock / microsecs */
          102  +} wideClick = {0, 0.0};
          103  +
    88    104   
    89    105   /*
    90    106    * Declarations for functions defined later in this file.
    91    107    */
    92    108   
    93    109   static void		StopCalibration(ClientData clientData);
    94    110   static DWORD WINAPI	CalibrationThread(LPVOID arg);
................................................................................
    95    111   static void 		UpdateTimeEachSecond(void);
    96    112   static void		ResetCounterSamples(Tcl_WideUInt fileTime,
    97    113   			    Tcl_WideInt perfCounter, Tcl_WideInt perfFreq);
    98    114   static Tcl_WideInt	AccumulateSample(Tcl_WideInt perfCounter,
    99    115   			    Tcl_WideUInt fileTime);
   100    116   static void		NativeScaleTime(Tcl_Time* timebuf,
   101    117   			    ClientData clientData);
          118  +static Tcl_WideInt	NativeGetMicroseconds(void);
   102    119   static void		NativeGetTime(Tcl_Time* timebuf,
   103    120   			    ClientData clientData);
   104    121   
   105    122   /*
   106    123    * TIP #233 (Virtualized Time): Data for the time hooks, if any.
   107    124    */
   108    125   
................................................................................
   126    143    *
   127    144    *----------------------------------------------------------------------
   128    145    */
   129    146   
   130    147   Tcl_WideUInt
   131    148   TclpGetSeconds(void)
   132    149   {
   133         -    Tcl_Time t;
          150  +    Tcl_WideInt usecSincePosixEpoch;
   134    151   
   135         -    tclGetTimeProcPtr(&t, tclTimeClientData);	/* Tcl_GetTime inlined. */
   136         -    return t.sec;
          152  +    /* Try to use high resolution timer */
          153  +    if ( tclGetTimeProcPtr == NativeGetTime
          154  +      && (usecSincePosixEpoch = NativeGetMicroseconds())
          155  +    ) {
          156  +	return usecSincePosixEpoch / 1000000;
          157  +    } else {
          158  +	Tcl_Time t;
          159  +
          160  +	tclGetTimeProcPtr(&t, tclTimeClientData);	/* Tcl_GetTime inlined. */
          161  +	return t.sec;
          162  +    }
   137    163   }
   138    164   
   139    165   /*
   140    166    *----------------------------------------------------------------------
   141    167    *
   142    168    * TclpGetClicks --
   143    169    *
................................................................................
   154    180    *
   155    181    *----------------------------------------------------------------------
   156    182    */
   157    183   
   158    184   Tcl_WideUInt
   159    185   TclpGetClicks(void)
   160    186   {
   161         -    /*
   162         -     * Use the Tcl_GetTime abstraction to get the time in microseconds, as
   163         -     * nearly as we can, and return it.
   164         -     */
   165         -
   166         -    Tcl_Time now;		/* Current Tcl time */
   167         -    unsigned long retval;	/* Value to return */
   168         -
   169         -    tclGetTimeProcPtr(&now, tclTimeClientData);	/* Tcl_GetTime inlined */
   170         -
   171         -    retval = ((Tcl_WideUInt) now.sec * 1000000) + now.usec;
   172         -    return retval;
   173         -
          187  +    Tcl_WideInt usecSincePosixEpoch;
          188  +
          189  +    /* Try to use high resolution timer */
          190  +    if ( tclGetTimeProcPtr == NativeGetTime
          191  +      && (usecSincePosixEpoch = NativeGetMicroseconds())
          192  +    ) {
          193  +	return (Tcl_WideUInt)usecSincePosixEpoch;
          194  +    } else {
          195  +	/*
          196  +	* Use the Tcl_GetTime abstraction to get the time in microseconds, as
          197  +	* nearly as we can, and return it.
          198  +	*/
          199  +
          200  +	Tcl_Time now;		/* Current Tcl time */
          201  +
          202  +	tclGetTimeProcPtr(&now, tclTimeClientData);	/* Tcl_GetTime inlined */
          203  +	return (Tcl_WideUInt)(now.sec * 1000000) + now.usec;
          204  +    }
          205  +}
          206  +
          207  +/*
          208  + *----------------------------------------------------------------------
          209  + *
          210  + * TclpGetWideClicks --
          211  + *
          212  + *	This procedure returns a WideInt value that represents the highest
          213  + *	resolution clock in microseconds available on the system.
          214  + *
          215  + * Results:
          216  + *	Number of microseconds (from some start time).
          217  + *
          218  + * Side effects:
          219  + *	This should be used for time-delta resp. for measurement purposes
          220  + *	only, because on some platforms can return microseconds from some
          221  + *	start time (not from the epoch).
          222  + *
          223  + *----------------------------------------------------------------------
          224  + */
          225  +
          226  +Tcl_WideInt
          227  +TclpGetWideClicks(void)
          228  +{
          229  +    LARGE_INTEGER curCounter;
          230  +
          231  +    if (!wideClick.initialized) {
          232  +	LARGE_INTEGER perfCounterFreq;
          233  +
          234  +	/*
          235  +	 * The frequency of the performance counter is fixed at system boot and
          236  +	 * is consistent across all processors. Therefore, the frequency need
          237  +	 * only be queried upon application initialization.
          238  +	 */
          239  +	if (QueryPerformanceFrequency(&perfCounterFreq)) {
          240  +	    wideClick.perfCounter = 1;
          241  +	    wideClick.microsecsScale = 1000000.0 / perfCounterFreq.QuadPart;
          242  +	} else {
          243  +	    /* fallback using microseconds */
          244  +	    wideClick.perfCounter = 0;
          245  +	    wideClick.microsecsScale = 1;
          246  +	}
          247  +
          248  +	wideClick.initialized = 1;
          249  +    }
          250  +    if (wideClick.perfCounter) {
          251  +	if (QueryPerformanceCounter(&curCounter)) {
          252  +	    return (Tcl_WideInt)curCounter.QuadPart;
          253  +	}
          254  +	/* fallback using microseconds */
          255  +	wideClick.perfCounter = 0;
          256  +	wideClick.microsecsScale = 1;
          257  +	return TclpGetMicroseconds();
          258  +    } else {
          259  +    	return TclpGetMicroseconds();
          260  +    }
          261  +}
          262  +
          263  +/*
          264  + *----------------------------------------------------------------------
          265  + *
          266  + * TclpWideClickInMicrosec --
          267  + *
          268  + *	This procedure return scale to convert wide click values from the
          269  + *	TclpGetWideClicks native resolution to microsecond resolution
          270  + *	and back.
          271  + *
          272  + * Results:
          273  + * 	1 click in microseconds as double.
          274  + *
          275  + * Side effects:
          276  + *	None.
          277  + *
          278  + *----------------------------------------------------------------------
          279  + */
          280  +
          281  +double
          282  +TclpWideClickInMicrosec(void)
          283  +{
          284  +    if (!wideClick.initialized) {
          285  +    	(void)TclpGetWideClicks();	/* initialize */
          286  +    }
          287  +    return wideClick.microsecsScale;
          288  +}
          289  +
          290  +/*
          291  + *----------------------------------------------------------------------
          292  + *
          293  + * TclpGetMicroseconds --
          294  + *
          295  + *	This procedure returns a WideInt value that represents the highest
          296  + *	resolution clock in microseconds available on the system.
          297  + *
          298  + * Results:
          299  + *	Number of microseconds (from the epoch).
          300  + *
          301  + * Side effects:
          302  + *	None.
          303  + *
          304  + *----------------------------------------------------------------------
          305  + */
          306  +
          307  +Tcl_WideInt
          308  +TclpGetMicroseconds(void)
          309  +{
          310  +    Tcl_WideInt usecSincePosixEpoch;
          311  +
          312  +    /* Try to use high resolution timer */
          313  +    if ( tclGetTimeProcPtr == NativeGetTime
          314  +      && (usecSincePosixEpoch = NativeGetMicroseconds())
          315  +    ) {
          316  +	return usecSincePosixEpoch;
          317  +    } else {
          318  +	/*
          319  +	* Use the Tcl_GetTime abstraction to get the time in microseconds, as
          320  +	* nearly as we can, and return it.
          321  +	*/
          322  +
          323  +	Tcl_Time now;
          324  +
          325  +	tclGetTimeProcPtr(&now, tclTimeClientData);	/* Tcl_GetTime inlined */
          326  +	return (((Tcl_WideInt)now.sec) * 1000000) + now.usec;
          327  +    }
   174    328   }
   175    329   
   176    330   /*
   177    331    *----------------------------------------------------------------------
   178    332    *
   179    333    * Tcl_GetTime --
   180    334    *
................................................................................
   195    349    *----------------------------------------------------------------------
   196    350    */
   197    351   
   198    352   void
   199    353   Tcl_GetTime(
   200    354       Tcl_Time *timePtr)		/* Location to store time information. */
   201    355   {
   202         -    tclGetTimeProcPtr(timePtr, tclTimeClientData);
          356  +    Tcl_WideInt usecSincePosixEpoch;
          357  +
          358  +    /* Try to use high resolution timer */
          359  +    if ( tclGetTimeProcPtr == NativeGetTime
          360  +      && (usecSincePosixEpoch = NativeGetMicroseconds())
          361  +    ) {
          362  +	timePtr->sec = (long) (usecSincePosixEpoch / 1000000);
          363  +	timePtr->usec = (unsigned long) (usecSincePosixEpoch % 1000000);
          364  +    } else {
          365  +    	tclGetTimeProcPtr(timePtr, tclTimeClientData);
          366  +    }
   203    367   }
   204    368   
   205    369   /*
   206    370    *----------------------------------------------------------------------
   207    371    *
   208    372    * NativeScaleTime --
   209    373    *
................................................................................
   228    392        * Native scale is 1:1. Nothing is done.
   229    393        */
   230    394   }
   231    395   
   232    396   /*
   233    397    *----------------------------------------------------------------------
   234    398    *
   235         - * NativeGetTime --
          399  + * NativeGetMicroseconds --
   236    400    *
   237         - *	TIP #233: Gets the current system time in seconds and microseconds
   238         - *	since the beginning of the epoch: 00:00 UCT, January 1, 1970.
          401  + *	Gets the current system time in microseconds since the beginning
          402  + *	of the epoch: 00:00 UCT, January 1, 1970.
   239    403    *
   240    404    * Results:
   241         - *	Returns the current time in timePtr.
          405  + *	Returns the wide integer with number of microseconds from the epoch, or
          406  + *	0 if high resolution timer is not available.
   242    407    *
   243    408    * Side effects:
   244    409    *	On the first call, initializes a set of static variables to keep track
   245    410    *	of the base value of the performance counter, the corresponding wall
   246    411    *	clock (obtained through ftime) and the frequency of the performance
   247    412    *	counter. Also spins a thread whose function is to wake up periodically
   248    413    *	and monitor these values, adjusting them as necessary to correct for
   249    414    *	drift in the performance counter's oscillator.
   250    415    *
   251    416    *----------------------------------------------------------------------
   252    417    */
   253    418   
   254         -static void
   255         -NativeGetTime(
   256         -    Tcl_Time *timePtr,
   257         -    ClientData clientData)
          419  +static inline Tcl_WideInt
          420  +NativeCalc100NsTicks(
          421  +    ULONGLONG fileTimeLastCall,
          422  +    LONGLONG perfCounterLastCall,
          423  +    LONGLONG curCounterFreq,
          424  +    LONGLONG curCounter
          425  +) {
          426  +    return fileTimeLastCall +
          427  +	((curCounter - perfCounterLastCall) * 10000000 / curCounterFreq);
          428  +}
          429  +
          430  +static Tcl_WideInt
          431  +NativeGetMicroseconds(void)
   258    432   {
   259         -    struct _timeb t;
   260         -
   261    433       /*
   262    434        * Initialize static storage on the first trip through.
   263    435        *
   264    436        * Note: Outer check for 'initialized' is a performance win since it
   265    437        * avoids an extra mutex lock in the common case.
   266    438        */
   267    439   
   268    440       if (!timeInfo.initialized) {
   269    441   	TclpInitLock();
   270    442   	if (!timeInfo.initialized) {
          443  +
          444  +	    timeInfo.posixEpoch.LowPart = 0xD53E8000;
          445  +	    timeInfo.posixEpoch.HighPart = 0x019DB1DE;
          446  +
   271    447   	    timeInfo.perfCounterAvailable =
   272    448   		    QueryPerformanceFrequency(&timeInfo.nominalFreq);
   273    449   
   274    450   	    /*
   275    451   	     * Some hardware abstraction layers use the CPU clock in place of
   276    452   	     * the real-time clock as a performance counter reference. This
   277    453   	     * results in:
................................................................................
   368    544   
   369    545       if (timeInfo.perfCounterAvailable && timeInfo.curCounterFreq.QuadPart!=0) {
   370    546   	/*
   371    547   	 * Query the performance counter and use it to calculate the current
   372    548   	 * time.
   373    549   	 */
   374    550   
   375         -	ULARGE_INTEGER fileTimeLastCall;
   376         -	LARGE_INTEGER perfCounterLastCall, curCounterFreq;
          551  +	ULONGLONG fileTimeLastCall;
          552  +	LONGLONG perfCounterLastCall, curCounterFreq;
   377    553   				/* Copy with current data of calibration cycle */
   378    554   
   379    555   	LARGE_INTEGER curCounter;
   380    556   				/* Current performance counter. */
   381         -	Tcl_WideInt curFileTime;/* Current estimated time, expressed as 100-ns
   382         -				 * ticks since the Windows epoch. */
   383         -	static LARGE_INTEGER posixEpoch;
   384         -				/* Posix epoch expressed as 100-ns ticks since
   385         -				 * the windows epoch. */
   386         -	Tcl_WideInt usecSincePosixEpoch;
   387         -				/* Current microseconds since Posix epoch. */
   388         -
   389         -	posixEpoch.LowPart = 0xD53E8000;
   390         -	posixEpoch.HighPart = 0x019DB1DE;
   391    557   
   392    558   	QueryPerformanceCounter(&curCounter);
   393    559   
   394    560   	/*
   395    561   	 * Hold time section locked as short as possible
   396    562   	 */
   397    563   	EnterCriticalSection(&timeInfo.cs);
   398    564   
   399         -	fileTimeLastCall.QuadPart = timeInfo.fileTimeLastCall.QuadPart;
   400         -	perfCounterLastCall.QuadPart = timeInfo.perfCounterLastCall.QuadPart;
   401         -	curCounterFreq.QuadPart = timeInfo.curCounterFreq.QuadPart;
          565  +	fileTimeLastCall = timeInfo.fileTimeLastCall.QuadPart;
          566  +	perfCounterLastCall = timeInfo.perfCounterLastCall.QuadPart;
          567  +	curCounterFreq = timeInfo.curCounterFreq.QuadPart;
   402    568   
   403    569   	LeaveCriticalSection(&timeInfo.cs);
   404    570   
   405    571   	/*
   406    572   	 * If calibration cycle occurred after we get curCounter
   407    573   	 */
   408         -	if (curCounter.QuadPart <= perfCounterLastCall.QuadPart) {
   409         -	    usecSincePosixEpoch =
   410         -		(fileTimeLastCall.QuadPart - posixEpoch.QuadPart) / 10;
   411         -	    timePtr->sec = (long) (usecSincePosixEpoch / 1000000);
   412         -	    timePtr->usec = (unsigned long) (usecSincePosixEpoch % 1000000);
   413         -	    return;
          574  +	if (curCounter.QuadPart <= perfCounterLastCall) {
          575  +	    /* Calibrated file-time is saved from posix in 100-ns ticks */
          576  +	    return fileTimeLastCall / 10;
   414    577   	}
   415    578   
   416    579   	/*
   417    580   	 * If it appears to be more than 1.1 seconds since the last trip
   418    581   	 * through the calibration loop, the performance counter may have
   419    582   	 * jumped forward. (See MSDN Knowledge Base article Q274323 for a
   420    583   	 * description of the hardware problem that makes this test
   421    584   	 * necessary.) If the counter jumps, we don't want to use it directly.
   422    585   	 * Instead, we must return system time. Eventually, the calibration
   423    586   	 * loop should recover.
   424    587   	 */
   425    588   
   426         -	if (curCounter.QuadPart - perfCounterLastCall.QuadPart <
   427         -		11 * curCounterFreq.QuadPart / 10
          589  +	if (curCounter.QuadPart - perfCounterLastCall <
          590  +		11 * curCounterFreq * timeInfo.calibrationInterv / 10
   428    591   	) {
   429         -	    curFileTime = fileTimeLastCall.QuadPart +
   430         -		 ((curCounter.QuadPart - perfCounterLastCall.QuadPart)
   431         -		    * 10000000 / curCounterFreq.QuadPart);
   432         -
   433         -	    usecSincePosixEpoch = (curFileTime - posixEpoch.QuadPart) / 10;
   434         -	    timePtr->sec = (long) (usecSincePosixEpoch / 1000000);
   435         -	    timePtr->usec = (unsigned long) (usecSincePosixEpoch % 1000000);
   436         -	    return;
          592  +	    /* Calibrated file-time is saved from posix in 100-ns ticks */
          593  +	    return NativeCalc100NsTicks(fileTimeLastCall,
          594  +		perfCounterLastCall, curCounterFreq, curCounter.QuadPart) / 10;
   437    595   	}
   438    596       }
   439    597   
   440    598       /*
   441         -     * High resolution timer is not available. Just use ftime.
          599  +     * High resolution timer is not available.
          600  +     */
          601  +    return 0;
          602  +}
          603  +
          604  +/*
          605  + *----------------------------------------------------------------------
          606  + *
          607  + * NativeGetTime --
          608  + *
          609  + *	TIP #233: Gets the current system time in seconds and microseconds
          610  + *	since the beginning of the epoch: 00:00 UCT, January 1, 1970.
          611  + *
          612  + * Results:
          613  + *	Returns the current time in timePtr.
          614  + *
          615  + * Side effects:
          616  + *	See NativeGetMicroseconds for more information.
          617  + *
          618  + *----------------------------------------------------------------------
          619  + */
          620  +
          621  +static void
          622  +NativeGetTime(
          623  +    Tcl_Time *timePtr,
          624  +    ClientData clientData)
          625  +{
          626  +    Tcl_WideInt usecSincePosixEpoch;
          627  +
          628  +    /*
          629  +     * Try to use high resolution timer.
   442    630        */
          631  +    if ( (usecSincePosixEpoch = NativeGetMicroseconds()) ) {
          632  +	timePtr->sec = (long) (usecSincePosixEpoch / 1000000);
          633  +	timePtr->usec = (unsigned long) (usecSincePosixEpoch % 1000000);
          634  +    } else {
          635  +	/*
          636  +	* High resolution timer is not available. Just use ftime.
          637  +	*/
   443    638   
   444         -    _ftime(&t);
   445         -    timePtr->sec = (long)t.time;
   446         -    timePtr->usec = t.millitm * 1000;
          639  +	struct _timeb t;
          640  +
          641  +	_ftime(&t);
          642  +	timePtr->sec = (long)t.time;
          643  +	timePtr->usec = t.millitm * 1000;
          644  +    }
   447    645   }
   448    646   
   449    647   /*
   450    648    *----------------------------------------------------------------------
   451    649    *
   452    650    * StopCalibration --
   453    651    *
................................................................................
   459    657    *
   460    658    * Side effects:
   461    659    *	Sets the 'exitEvent' event in the 'timeInfo' structure to ask the
   462    660    *	thread in question to exit, and waits for it to do so.
   463    661    *
   464    662    *----------------------------------------------------------------------
   465    663    */
          664  +
          665  +void TclWinResetTimerResolution(void);
   466    666   
   467    667   static void
   468    668   StopCalibration(
   469    669       ClientData unused)		/* Client data is unused */
   470    670   {
   471    671       SetEvent(timeInfo.exitEvent);
   472    672   
................................................................................
   518    718        */
   519    719   
   520    720       GetSystemTimeAsFileTime(&curFileTime);
   521    721       QueryPerformanceCounter(&timeInfo.perfCounterLastCall);
   522    722       QueryPerformanceFrequency(&timeInfo.curCounterFreq);
   523    723       timeInfo.fileTimeLastCall.LowPart = curFileTime.dwLowDateTime;
   524    724       timeInfo.fileTimeLastCall.HighPart = curFileTime.dwHighDateTime;
          725  +    /* Calibrated file-time will be saved from posix in 100-ns ticks */
          726  +    timeInfo.fileTimeLastCall.QuadPart -= timeInfo.posixEpoch.QuadPart;
   525    727   
   526    728       ResetCounterSamples(timeInfo.fileTimeLastCall.QuadPart,
   527    729   	    timeInfo.perfCounterLastCall.QuadPart,
   528    730   	    timeInfo.curCounterFreq.QuadPart);
   529    731   
   530    732       /*
   531    733        * Wake up the calling thread. When it wakes up, it will release the
................................................................................
   577    779   static void
   578    780   UpdateTimeEachSecond(void)
   579    781   {
   580    782       LARGE_INTEGER curPerfCounter;
   581    783   				/* Current value returned from
   582    784   				 * QueryPerformanceCounter. */
   583    785       FILETIME curSysTime;	/* Current system time. */
          786  +    static LARGE_INTEGER lastFileTime; /* File time of the previous calibration */
   584    787       LARGE_INTEGER curFileTime;	/* File time at the time this callback was
   585    788   				 * scheduled. */
   586    789       Tcl_WideInt estFreq;	/* Estimated perf counter frequency. */
   587    790       Tcl_WideInt vt0;		/* Tcl time right now. */
   588    791       Tcl_WideInt vt1;		/* Tcl time one second from now. */
   589    792       Tcl_WideInt tdiff;		/* Difference between system clock and Tcl
   590    793   				 * time. */
   591    794       Tcl_WideInt driftFreq;	/* Frequency needed to drift virtual time into
   592    795   				 * step over 1 second. */
   593    796   
   594    797       /*
   595         -     * Sample performance counter and system time.
          798  +     * Sample performance counter and system time (from posix epoch).
   596    799        */
   597    800   
   598         -    QueryPerformanceCounter(&curPerfCounter);
   599    801       GetSystemTimeAsFileTime(&curSysTime);
   600    802       curFileTime.LowPart = curSysTime.dwLowDateTime;
   601    803       curFileTime.HighPart = curSysTime.dwHighDateTime;
          804  +    curFileTime.QuadPart -= timeInfo.posixEpoch.QuadPart;
          805  +    /* If calibration still not needed (check for possible time switch) */
          806  +    if ( curFileTime.QuadPart > lastFileTime.QuadPart
          807  +      && curFileTime.QuadPart < lastFileTime.QuadPart +
          808  +      				    (timeInfo.calibrationInterv * 10000000)
          809  +    ) {
          810  +    	/* again in next one second */
          811  +	return;
          812  +    }
          813  +    QueryPerformanceCounter(&curPerfCounter);
   602    814   
   603         -    EnterCriticalSection(&timeInfo.cs);
          815  +    lastFileTime.QuadPart = curFileTime.QuadPart;
   604    816   
   605    817       /*
   606    818        * We devide by timeInfo.curCounterFreq.QuadPart in several places. That
   607    819        * value should always be positive on a correctly functioning system. But
   608    820        * it is good to be defensive about such matters. So if something goes
   609    821        * wrong and the value does goes to zero, we clear the
   610    822        * timeInfo.perfCounterAvailable in order to cause the calibration thread
   611    823        * to shut itself down, then return without additional processing.
   612    824        */
   613    825   
   614    826       if (timeInfo.curCounterFreq.QuadPart == 0){
   615         -	LeaveCriticalSection(&timeInfo.cs);
   616    827   	timeInfo.perfCounterAvailable = 0;
   617    828   	return;
   618    829       }
   619    830   
   620    831       /*
   621    832        * Several things may have gone wrong here that have to be checked for.
   622    833        *  (1) The performance counter may have jumped.
................................................................................
   647    858        *
   648    859        * vt1 = 20000000 + curFileTime
   649    860        *
   650    861        * The frequency that we need to use to drift the counter back into place
   651    862        * is estFreq * 20000000 / (vt1 - vt0)
   652    863        */
   653    864   
   654         -    vt0 = 10000000 * (curPerfCounter.QuadPart
   655         -		- timeInfo.perfCounterLastCall.QuadPart)
   656         -	    / timeInfo.curCounterFreq.QuadPart
   657         -	    + timeInfo.fileTimeLastCall.QuadPart;
   658         -    vt1 = 20000000 + curFileTime.QuadPart;
   659         -
          865  +    vt0 = NativeCalc100NsTicks(timeInfo.fileTimeLastCall.QuadPart,
          866  +	    timeInfo.perfCounterLastCall.QuadPart, timeInfo.curCounterFreq.QuadPart,
          867  +	    curPerfCounter.QuadPart);
   660    868       /*
   661    869        * If we've gotten more than a second away from system time, then drifting
   662    870        * the clock is going to be pretty hopeless. Just let it jump. Otherwise,
   663    871        * compute the drift frequency and fill in everything.
   664    872        */
   665    873   
   666    874       tdiff = vt0 - curFileTime.QuadPart;
   667    875       if (tdiff > 10000000 || tdiff < -10000000) {
   668         -	timeInfo.fileTimeLastCall.QuadPart = curFileTime.QuadPart;
   669         -	timeInfo.curCounterFreq.QuadPart = estFreq;
          876  +    	/* jump to current system time, use curent estimated frequency */
          877  +    	vt0 = curFileTime.QuadPart;
   670    878       } else {
   671         -	driftFreq = estFreq * 20000000 / (vt1 - vt0);
          879  +    	/* calculate new frequency and estimate drift to the next second */
          880  +	vt1 = 20000000 + curFileTime.QuadPart;
          881  +	driftFreq = (estFreq * 20000000 / (vt1 - vt0));
          882  +	/*
          883  +	 * Avoid too large drifts (only half of the current difference),
          884  +	 * that allows also be more accurate (aspire to the smallest tdiff),
          885  +	 * so then we can prolong calibration interval by tdiff < 100000
          886  +	 */
          887  +	driftFreq = timeInfo.curCounterFreq.QuadPart +
          888  +		(driftFreq - timeInfo.curCounterFreq.QuadPart) / 2;
   672    889   
   673         -	if (driftFreq > 1003*estFreq/1000) {
   674         -	    driftFreq = 1003*estFreq/1000;
   675         -	} else if (driftFreq < 997*estFreq/1000) {
   676         -	    driftFreq = 997*estFreq/1000;
          890  +	/*
          891  +	 * Average between estimated, 2 current and 5 drifted frequencies,
          892  +	 * (do the soft drifting as possible)
          893  +	 */
          894  +	estFreq = (estFreq + 2 * timeInfo.curCounterFreq.QuadPart + 5 * driftFreq) / 8;
          895  +    }
          896  +
          897  +    /* Avoid too large discrepancy from nominal frequency */
          898  +    if (estFreq > 1003*timeInfo.nominalFreq.QuadPart/1000) {
          899  +	estFreq = 1003*timeInfo.nominalFreq.QuadPart/1000;
          900  +	vt0 = curFileTime.QuadPart;
          901  +    } else if (estFreq < 997*timeInfo.nominalFreq.QuadPart/1000) {
          902  +	estFreq = 997*timeInfo.nominalFreq.QuadPart/1000;
          903  +	vt0 = curFileTime.QuadPart;
          904  +    } else if (vt0 != curFileTime.QuadPart) {
          905  +	/*
          906  +	 * Be sure the clock ticks never backwards (avoid it by negative drifting)
          907  +	 * just compare native time (in 100-ns) before and hereafter using
          908  +	 * new calibrated values) and do a small adjustment (short time freeze)
          909  +	 */
          910  +	LARGE_INTEGER newPerfCounter;
          911  +	Tcl_WideInt nt0, nt1;
          912  +
          913  +	QueryPerformanceCounter(&newPerfCounter);
          914  +	nt0 = NativeCalc100NsTicks(timeInfo.fileTimeLastCall.QuadPart,
          915  +		timeInfo.perfCounterLastCall.QuadPart, timeInfo.curCounterFreq.QuadPart,
          916  +		newPerfCounter.QuadPart);
          917  +	nt1 = NativeCalc100NsTicks(vt0,
          918  +		curPerfCounter.QuadPart, estFreq,
          919  +		newPerfCounter.QuadPart);
          920  +	if (nt0 > nt1) { /* drifted backwards, try to compensate with new base */
          921  +	    /* first adjust with a micro jump (short frozen time is acceptable) */
          922  +	    vt0 += nt0 - nt1;
          923  +	    /* if drift unavoidable (e. g. we had a time switch), then reset it */
          924  +	    vt1 = vt0 - curFileTime.QuadPart;
          925  +	    if (vt1 > 10000000 || vt1 < -10000000) {
          926  +	    	/* larger jump resp. shift relative new file-time */
          927  +	    	vt0 = curFileTime.QuadPart;
          928  +	    }
   677    929   	}
          930  +    }
   678    931   
   679         -	timeInfo.fileTimeLastCall.QuadPart = vt0;
   680         -	timeInfo.curCounterFreq.QuadPart = driftFreq;
          932  +    /* In lock commit new values to timeInfo (hold lock as short as possible) */
          933  +    EnterCriticalSection(&timeInfo.cs);
          934  +
          935  +    /* grow calibration interval up to 10 seconds (if still precise enough) */
          936  +    if (tdiff < -100000 || tdiff > 100000) {
          937  +	/* too long drift - reset calibration interval to 1000 second */
          938  +	timeInfo.calibrationInterv = 1;
          939  +    } else if (timeInfo.calibrationInterv < 10) {
          940  +	timeInfo.calibrationInterv++;
   681    941       }
   682    942   
          943  +    timeInfo.fileTimeLastCall.QuadPart = vt0;
          944  +    timeInfo.curCounterFreq.QuadPart = estFreq;
   683    945       timeInfo.perfCounterLastCall.QuadPart = curPerfCounter.QuadPart;
   684    946   
   685    947       LeaveCriticalSection(&timeInfo.cs);
   686    948   }
   687    949   
   688    950   /*
   689    951    *----------------------------------------------------------------------