Difference From:

[fc9286dad1] uum (user: kinaba, tags: redesign, date: 2012-07-15 12:11:33)

To:

[a7c6c8f12d] mumu- (user: kinaba, tags: trunk, date: 2012-07-16 09:05:51)

Modified icfp-96533632.tgz from [943329c30072989f] to [570d6534801f984c].

cannot compute difference between binary files

Modified make-submission from [bd7a911c141ae544] to [f900dd5fb0eee1fd].

    1  #!/bin/sh                                                                              1  #!/bin/sh
                                                                                        >     2  cd src
                                                                                        >     3  make
                                                                                        >     4  mv lifter ../submission/lifter
                                                                                        >     5  make clean
                                                                                        >     6  cd ..
    2  rm -rf submission/src                                                                  7  rm -rf submission/src
    3  cp -r src submission/src                                                               8  cp -r src submission/src
    4  tar czf icfp-96533632.tgz submission                                                   9  tar czf icfp-96533632.tgz submission

Added maps/1000x1000.map version [40335f17dbed961f]

                                                                                        >     1  ################################################################################
                                                                                        >     2  #L\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >     3  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >     4  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >     5  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >     6  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >     7  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >     8  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >     9  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    10  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    11  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    12  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    13  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    14  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    15  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    16  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    17  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    18  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    19  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    20  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    21  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    22  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    23  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    24  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    25  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    26  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    27  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    28  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    29  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    30  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    31  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    32  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    33  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    34  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    35  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    36  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    37  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    38  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    39  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    40  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    41  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    42  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    43  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    44  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    45  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    46  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    47  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    48  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    49  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    50  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    51  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    52  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    53  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    54  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    55  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    56  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    57  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    58  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    59  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    60  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    61  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    62  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    63  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    64  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    65  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    66  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    67  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    68  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    69  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    70  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    71  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    72  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    73  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    74  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    75  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    76  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    77  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    78  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    79  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    80  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    81  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    82  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    83  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    84  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    85  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    86  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    87  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    88  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    89  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    90  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    91  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    92  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    93  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    94  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    95  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    96  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    97  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    98  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >    99  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   100  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   101  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   102  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   103  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   104  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   105  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   106  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   107  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   108  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   109  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   110  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   111  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   112  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   113  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   114  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   115  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   116  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   117  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   118  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   119  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   120  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   121  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   122  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   123  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   124  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   125  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   126  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   127  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   128  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   129  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   130  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   131  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   132  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   133  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   134  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   135  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   136  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   137  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   138  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   139  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   140  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   141  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   142  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   143  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   144  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   145  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   146  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   147  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   148  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   149  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   150  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   151  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   152  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   153  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   154  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   155  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   156  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   157  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   158  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   159  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   160  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   161  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   162  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   163  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   164  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   165  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   166  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   167  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   168  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   169  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   170  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   171  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   172  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   173  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   174  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   175  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   176  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   177  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   178  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   179  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   180  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   181  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   182  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   183  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   184  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   185  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   186  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   187  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   188  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   189  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   190  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   191  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   192  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   193  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   194  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   195  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   196  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   197  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   198  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   199  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   200  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   201  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   202  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   203  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   204  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   205  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   206  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   207  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   208  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   209  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   210  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   211  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   212  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   213  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   214  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   215  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   216  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   217  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   218  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   219  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   220  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   221  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   222  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   223  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   224  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   225  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   226  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   227  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   228  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   229  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   230  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   231  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   232  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   233  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   234  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   235  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   236  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   237  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   238  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   239  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   240  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   241  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   242  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   243  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   244  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   245  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   246  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   247  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   248  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   249  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   250  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   251  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   252  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   253  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   254  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   255  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   256  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   257  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   258  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   259  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   260  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   261  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   262  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   263  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   264  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   265  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   266  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   267  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   268  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   269  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   270  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   271  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   272  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   273  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   274  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   275  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   276  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   277  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   278  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   279  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   280  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   281  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   282  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   283  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   284  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   285  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   286  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   287  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   288  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   289  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   290  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   291  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   292  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   293  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   294  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   295  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   296  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   297  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   298  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   299  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   300  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   301  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   302  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   303  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   304  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   305  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   306  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   307  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   308  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   309  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   310  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   311  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   312  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   313  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   314  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   315  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   316  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   317  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   318  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   319  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   320  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   321  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   322  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   323  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   324  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   325  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   326  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   327  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   328  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   329  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   330  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   331  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   332  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   333  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   334  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   335  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   336  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   337  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   338  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   339  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   340  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   341  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   342  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   343  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   344  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   345  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   346  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   347  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   348  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   349  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   350  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   351  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   352  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   353  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   354  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   355  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   356  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   357  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   358  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   359  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   360  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   361  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   362  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   363  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   364  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   365  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   366  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   367  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   368  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   369  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   370  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   371  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   372  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   373  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   374  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   375  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   376  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   377  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   378  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   379  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   380  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   381  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   382  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   383  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   384  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   385  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   386  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   387  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   388  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   389  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   390  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   391  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   392  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   393  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   394  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   395  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   396  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   397  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   398  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   399  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   400  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   401  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   402  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   403  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   404  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   405  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   406  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   407  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   408  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   409  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   410  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   411  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   412  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   413  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   414  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   415  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   416  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   417  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   418  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   419  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   420  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   421  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   422  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   423  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   424  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   425  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   426  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   427  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   428  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   429  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   430  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   431  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   432  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   433  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   434  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   435  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   436  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   437  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   438  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   439  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   440  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   441  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   442  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   443  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   444  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   445  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   446  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   447  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   448  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   449  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   450  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   451  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   452  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   453  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   454  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   455  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   456  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   457  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   458  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   459  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   460  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   461  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   462  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   463  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   464  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   465  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   466  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   467  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   468  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   469  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   470  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   471  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   472  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   473  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   474  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   475  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   476  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   477  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   478  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   479  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   480  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   481  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   482  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   483  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   484  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   485  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   486  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   487  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   488  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   489  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   490  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   491  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   492  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   493  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   494  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   495  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   496  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   497  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   498  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   499  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   500  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   501  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   502  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   503  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   504  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   505  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   506  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   507  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   508  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   509  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   510  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   511  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   512  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   513  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   514  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   515  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   516  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   517  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   518  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   519  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   520  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   521  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   522  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   523  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   524  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   525  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   526  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   527  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   528  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   529  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   530  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   531  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   532  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   533  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   534  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   535  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   536  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   537  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   538  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   539  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   540  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   541  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   542  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   543  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   544  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   545  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   546  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   547  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   548  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   549  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   550  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   551  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   552  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   553  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   554  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   555  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   556  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   557  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   558  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   559  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   560  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   561  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   562  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   563  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   564  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   565  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   566  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   567  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   568  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   569  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   570  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   571  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   572  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   573  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   574  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   575  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   576  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   577  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   578  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   579  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   580  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   581  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   582  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   583  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   584  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   585  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   586  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   587  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   588  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   589  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   590  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   591  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   592  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   593  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   594  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   595  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   596  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   597  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   598  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   599  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   600  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   601  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   602  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   603  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   604  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   605  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   606  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   607  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   608  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   609  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   610  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   611  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   612  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   613  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   614  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   615  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   616  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   617  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   618  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   619  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   620  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   621  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   622  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   623  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   624  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   625  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   626  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   627  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   628  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   629  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   630  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   631  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   632  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   633  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   634  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   635  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   636  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   637  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   638  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   639  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   640  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   641  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   642  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   643  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   644  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   645  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   646  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   647  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   648  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   649  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   650  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   651  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   652  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   653  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   654  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   655  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   656  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   657  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   658  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   659  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   660  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   661  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   662  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   663  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   664  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   665  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   666  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   667  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   668  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   669  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   670  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   671  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   672  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   673  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   674  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   675  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   676  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   677  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   678  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   679  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   680  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   681  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   682  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   683  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   684  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   685  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   686  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   687  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   688  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   689  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   690  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   691  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   692  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   693  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   694  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   695  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   696  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   697  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   698  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   699  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   700  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   701  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   702  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   703  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   704  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   705  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   706  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   707  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   708  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   709  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   710  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   711  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   712  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   713  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   714  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   715  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   716  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   717  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   718  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   719  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   720  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   721  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   722  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   723  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   724  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   725  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   726  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   727  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   728  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   729  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   730  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   731  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   732  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   733  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   734  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   735  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   736  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   737  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   738  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   739  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   740  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   741  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   742  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   743  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   744  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   745  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   746  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   747  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   748  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   749  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   750  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   751  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   752  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   753  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   754  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   755  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   756  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   757  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   758  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   759  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   760  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   761  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   762  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   763  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   764  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   765  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   766  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   767  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   768  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   769  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   770  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   771  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   772  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   773  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   774  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   775  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   776  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   777  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   778  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   779  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   780  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   781  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   782  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   783  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   784  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   785  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   786  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   787  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   788  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   789  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   790  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   791  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   792  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   793  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   794  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   795  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   796  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   797  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   798  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   799  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   800  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   801  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   802  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   803  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   804  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   805  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   806  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   807  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   808  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   809  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   810  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   811  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   812  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   813  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   814  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   815  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   816  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   817  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   818  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   819  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   820  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   821  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   822  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   823  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   824  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   825  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   826  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   827  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   828  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   829  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   830  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   831  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   832  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   833  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   834  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   835  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   836  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   837  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   838  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   839  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   840  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   841  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   842  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   843  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   844  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   845  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   846  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   847  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   848  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   849  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   850  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   851  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   852  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   853  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   854  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   855  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   856  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   857  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   858  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   859  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   860  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   861  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   862  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   863  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   864  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   865  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   866  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   867  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   868  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   869  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   870  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   871  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   872  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   873  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   874  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   875  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   876  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   877  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   878  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   879  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   880  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   881  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   882  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   883  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   884  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   885  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   886  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   887  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   888  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   889  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   890  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   891  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   892  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   893  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   894  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   895  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   896  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   897  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   898  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   899  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   900  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   901  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   902  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   903  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   904  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   905  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   906  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   907  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   908  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   909  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   910  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   911  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   912  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   913  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   914  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   915  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   916  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   917  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   918  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   919  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   920  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   921  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   922  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   923  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   924  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   925  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   926  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   927  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   928  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   929  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   930  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   931  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   932  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   933  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   934  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   935  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   936  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   937  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   938  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   939  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   940  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   941  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   942  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   943  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   944  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   945  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   946  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   947  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   948  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   949  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   950  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   951  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   952  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   953  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   954  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   955  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   956  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   957  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   958  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   959  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   960  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   961  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   962  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   963  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   964  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   965  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   966  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   967  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   968  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   969  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   970  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   971  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   972  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   973  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   974  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   975  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   976  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   977  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   978  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   979  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   980  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   981  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   982  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   983  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   984  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   985  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   986  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   987  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   988  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   989  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   990  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   991  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   992  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   993  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   994  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   995  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   996  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   997  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   998  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >   999  #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
                                                                                        >  1000  ################################################################################

Added maps/80x60.map version [b22e0d0f5c688ed4]

                                                                                        >     1  ############################################################
                                                                                        >     2  #L\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.*.*.*.*.*.*.*.*.*.*#
                                                                                        >     3  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.*W*.*.*.*.*.*.*.*.*.#
                                                                                        >     4  #.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*#
                                                                                        >     5  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.*W*.*.*.*.*.*.*.*.*.#
                                                                                        >     6  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.*.*.*.*.*.*.*.*.*.*#
                                                                                        >     7  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >     8  #.\.\.\.\.\.\.\.\.@.\.\.@.\.\.\.\.\.\.\.*.*.*.*.*.*.*.*.*.*#
                                                                                        >     9  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    10  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.*.*.*.*.*.*.*.*.*.*#
                                                                                        >    11  #.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*#
                                                                                        >    12  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.*.*.*.*.*.*.*.*.*.*#
                                                                                        >    13  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    14  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\*W*.*.*.*.*.*.*.*.*.#
                                                                                        >    15  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.*W*.*.*.*.*.*.*.*.*.#
                                                                                        >    16  #.\.\.\.\.\.\.\.\.\W\.\.\.\.\.\.\.\.\.\*W*.*.*.*.*.*.*.*.*.#
                                                                                        >    17  #.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.*.**W*.*.*.*.*.*.*.*.*.#
                                                                                        >    18  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\*W*.*.*.*.*.*.*.*.*.#
                                                                                        >    19  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.*W*.*.*.*.*.*.*.*.*.#
                                                                                        >    20  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\*W*.*.*.*.*.*.*.*.*.#
                                                                                        >    21  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    22  #.\.\.\.\!\.\.\.\.\.\.\.\W\.\.\.\.\.\.\*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    23  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    24  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    25  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    26  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    27  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    28  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    29  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    30  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    31  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\!\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    32  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    33  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    34  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    35  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\!\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    36  #.\.\.\.\.\.\.\.\W\.\.\.\.\.\.\.\.\.\.\*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    37  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    38  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.R*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    39  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    40  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.A*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    41  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    42  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.B*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    43  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    44  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.C*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    45  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    46  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.D*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    47  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    48  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.E*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    49  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    50  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.F*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    51  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    52  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.G*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    53  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    54  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.H*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    55  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    56  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.I*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    57  #\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\..*.*.*.*.*.*.*.*.*.*#
                                                                                        >    58  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    59  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    60  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    61  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    62  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    63  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    64  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    65  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    66  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    67  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    68  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    69  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    70  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    71  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    72  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    73  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    74  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    75  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    76  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    77  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    78  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.W*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    79  #.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.1*!*.*.*.*.*.*.*.*.*.#
                                                                                        >    80  ############################################################
                                                                                        >    81  
                                                                                        >    82  Flooding 80
                                                                                        >    83  Trampoline A targets 1
                                                                                        >    84  Trampoline B targets 1
                                                                                        >    85  Trampoline C targets 1
                                                                                        >    86  Trampoline D targets 1
                                                                                        >    87  Trampoline E targets 1
                                                                                        >    88  Trampoline F targets 1
                                                                                        >    89  Trampoline G targets 1
                                                                                        >    90  Trampoline H targets 1
                                                                                        >    91  Trampoline I targets 1

Added maps/beard5.map version [7639fcdcf36705e1]

                                                                                        >     1             ##########
                                                                                        >     2          ####..******####
                                                                                        >     3        ###..  3ABCDEF...###
                                                                                        >     4        ##                 ##
                                                                                        >     5       ###                  ##
                                                                                        >     6      ###.....\\\...\\\.....###
                                                                                        >     7      #..     \\\ * \\\      ##
                                                                                        >     8      ##          *          ##
                                                                                        >     9       ###       ***        ##
                                                                                        >    10         #*****************##
                                                                                        >    11         ###..............##
                                                                                        >    12           ###...........##
                                                                                        >    13             ####WR..W####
                                                                                        >    14                ##L####
                                                                                        >    15                 .....
                                                                                        >    16             ######  ######
                                                                                        >    17            ##1\! G##2 !\H##
                                                                                        >    18             ######  ######
                                                                                        >    19  
                                                                                        >    20  Trampoline A targets 1
                                                                                        >    21  Trampoline B targets 1
                                                                                        >    22  Trampoline C targets 1
                                                                                        >    23  Trampoline D targets 1
                                                                                        >    24  Trampoline E targets 1
                                                                                        >    25  Trampoline F targets 1
                                                                                        >    26  Trampoline G targets 2
                                                                                        >    27  Trampoline H targets 3
                                                                                        >    28  Growth 5
                                                                                        >    29  Razors 0

Added maps/horock1.map version [7e25f07bad607ab0]

                                                                                        >     1  #####L######
                                                                                        >     2  #....R....A#
                                                                                        >     3  #..........#
                                                                                        >     4  #\.  #@\ ..#
                                                                                        >     5  #\...#*  ###
                                                                                        >     6  #\.........#
                                                                                        >     7  #\..*.@....#
                                                                                        >     8  ####@@.  ..#
                                                                                        >     9  #....#.. ###
                                                                                        >    10  #....#..**.#
                                                                                        >    11  #.1..#  .\\#
                                                                                        >    12  ############
                                                                                        >    13  
                                                                                        >    14  Trampoline A targets 1

Added maps/horock2.map version [2fb25272ef9314ea]

                                                                                        >     1  #################
                                                                                        >     2  #A       .@@@@@@#
                                                                                        >     3  #  ..    #*...*1#
                                                                                        >     4  #  .##########*##
                                                                                        >     5  #  ..@   \\\\#* #
                                                                                        >     6  #  ..#   #####*.#
                                                                                        >     7  #   .#####    * #
                                                                                        >     8  #LR .......   . #
                                                                                        >     9  #################
                                                                                        >    10  
                                                                                        >    11  Trampoline A targets 1
                                                                                        >    12  Flooding 10
                                                                                        >    13  Water 0

Added maps/horock3.map version [d80af0f6153d8208]

                                                                                        >     1  #################
                                                                                        >     2  # \\\\#   *  *  #
                                                                                        >     3  #  ##   !!#..@. ####
                                                                                        >     4  #*    @...####.....#
                                                                                        >     5  #\\   \@...........#
                                                                                        >     6  #\  # .\@    #  #.########
                                                                                        >     7  #\  # ..\@   #   ..      #
                                                                                        >     8  #\  # .. \@  #   ..      #
                                                                                        >     9  #\  # *.. \@    #######  #
                                                                                        >    10  #\  # ###  \@   #     #W #
                                                                                        >    11  ### #       \@  #     ##L#
                                                                                        >    12  #...#@@**@@**\@ #
                                                                                        >    13  #R ..........!\##
                                                                                        >    14  #################
                                                                                        >    15  
                                                                                        >    16  Growth 25

Added maps/static.map version [c02e46733b9bb4b5]

                                                                                        >     1  L
                                                                                        >     2  \
                                                                                        >     3  \
                                                                                        >     4  \
                                                                                        >     5  \
                                                                                        >     6  \
                                                                                        >     7  \
                                                                                        >     8  \
                                                                                        >     9  \
                                                                                        >    10  R  \

Added maps/test2.map version [60334061c33d6104]

                                                                                        >     1  * L
                                                                                        >     2    W
                                                                                        >     3  *
                                                                                        >     4  #R#
                                                                                        >     5  
                                                                                        >     6  Growth 2

Added maps/test3.map version [1e96116428423b73]

                                                                                        >     1  L *       CD
                                                                                        >     2    *  \B    2
                                                                                        >     3   R   A1
                                                                                        >     4  
                                                                                        >     5  Trampoline A targets 1
                                                                                        >     6  Trampoline B targets 1
                                                                                        >     7  Trampoline C targets 1
                                                                                        >     8  Trampoline D targets 2

Modified score_memo.txt from [95f0626c958d6d31] to [c6c27c0064ba89ec].

    1  contest1     212!                                                                      1  contest1     212!
    2  contest2     280?                                                                |     2  contest2     281!
    3  contest3     275!                                                                      3  contest3     275!
    4  contest4     561?                                                                      4  contest4     561?
    5  contest5    1281?                                                                      5  contest5    1281?
    6  contest6     737   // deadend trap                                               |     6  contest6    1163?
    7  contest7     867?                                                                      7  contest7     867?
    8  contest8    1245   // tricky                                                     |     8  contest8    1291    // むり：岩が降ってきてliftふさぐ系
    9  contest9    3042?                                                                |     9  contest9    3044?
   10  contest10   2076   // * on lambda, must move * first                             |    10  contest10   2340    // "λの上に岩" トラップが複数
   11  flood1       569   // too slow, because of 1-left danger lambda                  |    11  flood1       937?
   12  flood2       280?                                                                |    12  flood2       281!
   13  flood3       802   // too slow, drown                                            |    13  flood3       852    // 溺死
   14  flood4       970   // incorrect order of digging                                 |    14  flood4       982    // むり
   15  flood5       561?                                                                     15  flood5       561?
   16  trampoline1  291   // * on trampoline. must move * first                         |    16  trampoline1  291    // 岩が降ってきてliftふさぐ系
   17  trampoline2 1728?                                                                |    17  trampoline2 1732?
   18  trampoline3  698   // * on trampoline target. must move * first.                 |    18  trampoline3 3255    // "上に岩" ワープゾーン版
   19  beard1       856?                                                                |    19  beard1       853?
   20  beard2      2792   // hutsu-ni muzui                                             |    20  beard2      4487?   // 崩すの怖がりすぎて間に合わなくなって溺死
   21  beard3       811   // tricky. must hurry to cut hige.                            |    21  beard3       809    // むり
   22  beard4       677   // deadend trap                                               |    22  beard4      1997    // 髭を解放しないように動く
                                                                                        >    23  beard5       665    // むり
                                                                                        >    24  horock1      732?
                                                                                        >    25  horock2      235    // むり
                                                                                        >    26  horock3     1542    // むり

Modified src/Makefile from [01a4f7a0531dae71] to [6a3a85034044348b].

    1  # To build, the following packages are needed.                                         1  # To build, the following packages are needed.
    2  #   wget http://ftp.digitalmars.com/dmd_2.059-0_i386.deb                         |     2  #   $ wget http://ftp.digitalmars.com/dmd_2.059-0_i386.deb
    3  #   sudo apt-get install gcc gcc-multilib                                        |     3  #   $ sudo apt-get install gcc gcc-multilib
    4  #   sudo pkg -i dmd_2.059-0_i386.deb                                             |     4  #   $ sudo pkg -i dmd_2.059-0_i386.deb
                                                                                        >     5  #
                                                                                        >     6  # Optional GUI is Windows only. Need to install DFL (http://github.com/Rayerd/df
                                                                                        >     7  
                                                                                        >     8  cui:
                                                                                        >     9          dmd -O -release -inline -oflifter main.d driver.d game.d output.d solver
                                                                                        >    10  
                                                                                        >    11  gui:
                                                                                        >    12          dmd -O -release -inline -ofgui gui_main.d gui.d driver.d game.d output.d
    5                                                                                        13  
    6  all:                                                                             |    14  clean:
    7          dmd -O -release -inline -oflifter cui_auto_main.d driver.d game.d output |    15          rm -f *.obj *.o *.exe *.deps

Deleted src/cui_auto_main.d version [b38d60ea39d11e6e]

    1  import util;                                                                     <
    2  import game;                                                                     <
    3  import output;                                                                   <
    4  import driver;                                                                   <
    5  import solver;                                                                   <
    6                                                                                   <
    7  class CUI(Solver) : GameObserver                                                 <
    8  {                                                                                <
    9          this(in Game g) { solver = new Solver(g); }                              <
   10          Solver solver;                                                           <
   11          bool fin;                                                                <
   12          override void on_game_changed(char c, in Game g, bool finished)          <
   13          {                                                                        <
   14                  fin = finished;                                                  <
   15          }                                                                        <
   16  }                                                                                <
   17                                                                                   <
   18  void main(string[] args)                                                         <
   19  {                                                                                <
   20          Driver d = new Driver(stdin);                                            <
   21          d.addObserver!(GuardedOutput)();                                         <
   22          auto c = d.addObserver!(CUI!MainSolver)();                               <
   23          while(!c.fin)                                                            <
   24                  d.command(c.solver.single_step());                               <
   25  }                                                                                <

Modified src/game.d from [fc05481901940844] to [d9bf3ea129c7cbc5].

    6  {                                                                                      6  {
    7          public immutable int y, x;                                                     7          public immutable int y, x;
    8          mixin DeriveCreate;                                                            8          mixin DeriveCreate;
    9          mixin DeriveCompare;                                                           9          mixin DeriveCompare;
   10          mixin DeriveShow;                                                             10          mixin DeriveShow;
   11          Pos clone() const { return cast(Pos) this; }                                  11          Pos clone() const { return cast(Pos) this; }
   12                                                                                        12  
   13  @property:                                                                       |    13  const @property:
   14          Pos wait()  { return this.clone(); }                                          14          Pos wait()  { return this.clone(); }
   15          Pos up()    { return new Pos(y+1, x); }                                       15          Pos up()    { return new Pos(y+1, x); }
   16          Pos down()  { return new Pos(y-1, x); }                                       16          Pos down()  { return new Pos(y-1, x); }
   17          Pos left()  { return new Pos(y, x-1); }                                       17          Pos left()  { return new Pos(y, x-1); }
   18          Pos right() { return new Pos(y, x+1); }                                       18          Pos right() { return new Pos(y, x+1); }
   19          alias wait  W,w;                                                              19          alias wait  W,w;
   20          alias up    U,u;                                                              20          alias up    U,u;
................................................................................................................................................................................

   39                                                                                        39  
   40  ////////////////////////////////////////////////////////////////////////////////      40  ////////////////////////////////////////////////////////////////////////////////
   41                                                                                        41  
   42  class Water                                                                           42  class Water
   43  {                                                                                     43  {
   44          public immutable int base, pace;                                              44          public immutable int base, pace;
   45          mixin DeriveCreate;                                                           45          mixin DeriveCreate;
   46          mixin DeriveCompare;                                                     <
   47          mixin DeriveShow;                                                             46          mixin DeriveShow;
   48          Water clone() const { return cast(Water)this; }                          |    47          Water clone() const { return cast(Water) this; }
   49                                                                                        48  
   50          static load(string[string] params)                                            49          static load(string[string] params)
   51          {                                                                             50          {
   52                  return new Water(params.get("Water",    "0").to!int(),                51                  return new Water(params.get("Water",    "0").to!int(),
   53                                   params.get("Flooding", "0").to!int());               52                                   params.get("Flooding", "0").to!int());
   54          }                                                                             53          }
   55                                                                                        54  
   56          int level(int number_of_update) const                                    |    55          int level(int turn) const
   57          {                                                                             56          {
   58                  return pace ? base+(number_of_update/pace) : base;               |    57                  return pace ? base+(turn/pace) : base;
   59          }                                                                             58          }
   60                                                                                        59  
   61          int until_rise(int number_of_update) const                               |    60          int until_rise(int turn) const
   62          {                                                                             61          {
   63                  return pace ? pace-number_of_update%pace : int.max;              |    62                  return pace ? pace-turn%pace : int.max;
   64          }                                                                             63          }
   65  }                                                                                     64  }
   66                                                                                        65  
   67  unittest                                                                              66  unittest
   68  {                                                                                     67  {
   69          Water w = new Water(1, 3);                                                    68          Water w = new Water(1, 3);
   70          assert( 1 == w.level(0) );                                                    69          assert( 1 == w.level(0) );
................................................................................................................................................................................

   86                                                                                        85  
   87  ////////////////////////////////////////////////////////////////////////////////      86  ////////////////////////////////////////////////////////////////////////////////
   88                                                                                        87  
   89  class Hige                                                                            88  class Hige
   90  {                                                                                     89  {
   91          public immutable int pace;                                                    90          public immutable int pace;
   92          mixin DeriveCreate;                                                           91          mixin DeriveCreate;
   93          mixin DeriveCompare;                                                     <
   94          mixin DeriveShow;                                                             92          mixin DeriveShow;
   95          Hige clone() const { return cast(Hige)this; }                                 93          Hige clone() const { return cast(Hige)this; }
   96                                                                                        94  
   97          static load(string[string] params)                                            95          static load(string[string] params)
   98          {                                                                             96          {
   99                  return new Hige(params.get("Growth", "25").to!int());                 97                  return new Hige(params.get("Growth", "25").to!int());
  100          }                                                                             98          }
................................................................................................................................................................................

  108          {                                                                            106          {
  109                  return pace ? pace-turn%pace : int.max;                              107                  return pace ? pace-turn%pace : int.max;
  110          }                                                                            108          }
  111  }                                                                                    109  }
  112                                                                                       110  
  113  ////////////////////////////////////////////////////////////////////////////////     111  ////////////////////////////////////////////////////////////////////////////////
  114                                                                                       112  
  115  class Map                                                                        |   113  class Trampoline
  116  {                                                                                    114  {
                                                                                        >   115          private immutable char[]   target_of_;
                                                                                        >   116          private immutable char[][] source_of_;
                                                                                        >   117          private immutable Pos[]    position_of_;
                                                                                        >   118          private immutable char[]   source_list_;
                                                                                        >   119          private immutable char[]   target_list_;
  117          mixin DeriveShow;                                                            120          mixin DeriveShow;
  118                                                                                   <
                                                                                        >   121          Trampoline clone() const { return cast(Trampoline) this; }
  119          static Map load(string[] raw_data, string[string] params, char[char] tra |   122          this(Map m, char[char] tramparam)
  120          {                                                                            123          {
  121                  // TODO: choose optimal representation.                          |   124                  auto ta = new char['I'+1];
  122                  return new Map(raw_data, params, trampo);                        |   125                  auto sr = new char[]['9'+1];
                                                                                        >   126                  auto po = new Pos[max('I','9')+1];
                                                                                        >   127                  char[] sl, tl;
                                                                                        >   128                  foreach(fr,to; tramparam) {
                                                                                        >   129                          ta[fr]  = to;
                                                                                        >   130                          sr[to] ~= fr;
                                                                                        >   131                  }
                                                                                        >   132                  for(int y=1; y<=m.H; ++y)
                                                                                        >   133                  for(int x=1; x<=m.W; ++x) {
                                                                                        >   134                          char c = m[y,x];
                                                                                        >   135                          if('A'<=c && c<='I') {
                                                                                        >   136                                  sl ~= c;
                                                                                        >   137                                  po[c] = new Pos(y,x);
                                                                                        >   138                          }
                                                                                        >   139                          if('1'<=c && c<='9') {
                                                                                        >   140                                  tl ~= c;
                                                                                        >   141                                  po[c] = new Pos(y,x);
                                                                                        >   142                          }
                                                                                        >   143                  }
                                                                                        >   144                  target_of_ = cast(immutable) ta;
                                                                                        >   145                  source_of_ = cast(immutable) sr;
                                                                                        >   146                  position_of_ = cast(immutable) po;
                                                                                        >   147                  source_list_ = cast(immutable) sl;
                                                                                        >   148                  target_list_ = cast(immutable) tl;
  123          }                                                                            149          }
  124                                                                                       150  
                                                                                        >   151  @property const:
                                                                                        >   152          const(char[]) source_list() { return source_list_; }
                                                                                        >   153          const(char[]) target_list() { return target_list_; }
                                                                                        >   154          const(char[]) source_of(char c) { return source_of_[c]; }
                                                                                        >   155          char target_of(char c) { return target_of_[c]; }
                                                                                        >   156          Pos[] source_pos(char c) {
                                                                                        >   157                  Pos[] ps;
                                                                                        >   158                  foreach(s; source_of(c))
                                                                                        >   159                          ps ~= position_of_[s].clone();
                                                                                        >   160                  return ps;
                                                                                        >   161          }
                                                                                        >   162          Pos target_pos(char c) { return position_of_[target_of_[c]].clone(); }
                                                                                        >   163  }
                                                                                        >   164  
                                                                                        >   165  ////////////////////////////////////////////////////////////////////////////////
                                                                                        >   166  
                                                                                        >   167  class Map
                                                                                        >   168  {
                                                                                        >   169          mixin DeriveShow;
                                                                                        >   170  
  125          char[][] data;                                                               171          char[][] data;
  126          Pos robot;                                                                   172          Pos robot;
  127          Pos lift;                                                                    173          Pos lift;
  128          int waterproof;                                                              174          int waterproof;
  129          Pos[char] tr_target;                                                     <
  130          Pos[][char] tr_source;                                                   <
  131          const(Hige) hige;                                                        <
  132          int razor;                                                                   175          int razor;
                                                                                        >   176          int collected_lambda;
                                                                                        >   177          int total_lambda;
                                                                                        >   178          bool cleared;
                                                                                        >   179          Pos[] may_update;
  133                                                                                       180  
  134          Map clone() const { return new Map(this); }                                  181          Map clone() const { return new Map(this); }
  135          this(in Map m) {                                                             182          this(in Map m) {
  136                  foreach(s; m.data)                                                   183                  foreach(s; m.data)
  137                          this.data ~= s.dup;                                          184                          this.data ~= s.dup;
  138                  this.robot = m.robot.clone();                                        185                  this.robot = m.robot.clone();
  139                  this.lift = m.lift.clone();                                          186                  this.lift = m.lift.clone();
  140                  this.waterproof = m.waterproof;                                      187                  this.waterproof = m.waterproof;
  141                  this.tr_target = cast(Pos[char])m.tr_target;                     <
  142                  this.tr_source = cast(Pos[][char])m.tr_source;                   <
  143                  this.hige = m.hige.clone();                                      <
  144                  this.razor = m.razor;                                                188                  this.razor = m.razor;
                                                                                        >   189                  this.collected_lambda = m.collected_lambda;
                                                                                        >   190                  this.total_lambda = m.total_lambda;
                                                                                        >   191                  this.may_update = (cast(Map)m).may_update.dup;
                                                                                        >   192                  this.cleared = m.cleared;
  145          }                                                                            193          }
  146                                                                                       194  
  147          this(string[] raw_data, string[string] params, char[char] trampo)            195          this(string[] raw_data, string[string] params, char[char] trampo)
  148          {                                                                            196          {
  149                  int width = 0;                                                       197                  int width = 0;
  150                  foreach(r; raw_data)                                                 198                  foreach(r; raw_data)
  151                          width = max(width, r.length);                                199                          width = max(width, r.length);
................................................................................................................................................................................

  157                                                                                       205  
  158                  for(int y=1; y<=H; ++y)                                              206                  for(int y=1; y<=H; ++y)
  159                  for(int x=1; x<=W; ++x) {                                            207                  for(int x=1; x<=W; ++x) {
  160                          if(this[y,x] == 'R')                                         208                          if(this[y,x] == 'R')
  161                                  this.robot = new Pos(y,x);                           209                                  this.robot = new Pos(y,x);
  162                          if(this[y,x] == 'L' || this[y,x] == 'O')                     210                          if(this[y,x] == 'L' || this[y,x] == 'O')
  163                                  this.lift = new Pos(y,x);                            211                                  this.lift = new Pos(y,x);
  164                  }                                                                <
  165                                                                                   <
  166                  Pos[char] tr_pos;                                                <
  167                  for(int y=1; y<=H; ++y)                                          <
  168                  for(int x=1; x<=W; ++x) {                                        <
                                                                                        >   212                          if(this[y,x] == '\\' || this[y,x] == '@')
                                                                                        >   213                                  total_lambda++;
  169                          char c = this[y,x];                                      |   214                          if(this[y,x] == '*' || this[y,x] == '@')
  170                          if('1'<=c && c<='9' || 'A'<=c&&c<='I')                   <
  171                                  tr_pos[c] = new Pos(y,x);                        |   215                                  may_update ~= new Pos(y,x);
  172                  }                                                                    216                  }
  173                                                                                       217  
  174                  this.waterproof = params.get("Waterproof", "5").to!int();            218                  this.waterproof = params.get("Waterproof", "5").to!int();
  175                  foreach(fr,to; trampo) {                                         <
  176                          tr_target[fr] = tr_pos[to];                              <
  177                          if(to !in tr_source) tr_source[to] = [];                 <
  178                          tr_source[to] ~= tr_pos[fr];                             <
  179                  }                                                                <
  180                                                                                   <
  181                  this.hige = Hige.load(params);                                   <
  182                  this.razor = params.get("Razors", "0").to!int();                     219                  this.razor = params.get("Razors", "0").to!int();
  183          }                                                                            220          }
  184                                                                                       221  
  185          const @property {                                                            222          const @property {
  186                  int H() { return data.length; }                                      223                  int H() { return data.length; }
  187                  int W() { return data[0].length; }                                   224                  int W() { return data[0].length; }
  188          }                                                                            225          }
................................................................................................................................................................................

  225                                  ans ~= new Pos(y,x);                                 262                                  ans ~= new Pos(y,x);
  226                  return ans;                                                          263                  return ans;
  227          }                                                                            264          }
  228                                                                                       265  
  229          Pos[] razors() const { return objects('!'); }                                266          Pos[] razors() const { return objects('!'); }
  230          Pos[] lambdas() const { return objects('\\'); }                              267          Pos[] lambdas() const { return objects('\\'); }
  231                                                                                       268  
  232          bool cleared() const                                                     <
  233          {                                                                        <
  234                  for(int y=1; y<=H; ++y)                                          <
  235                  for(int x=1; x<=W; ++x)                                          <
  236                          if(this[y,x] == 'L' || this[y,x] == 'O')                 <
  237                                  return false;                                    <
  238                  return true;                                                     <
  239          }                                                                        <
  240                                                                                   <
  241          Tuple!(int,bool) command(char c, int turn)                               |   269          bool command(char c, int turn, bool hige_day, in Trampoline tr)
  242          {                                                                            270          {
  243                  assert( this[robot] == 'R' );                                        271                  assert( this[robot] == 'R' );
  244                  if(c=='R') return move( 0, +1, turn);                            |   272                  if(c=='R') return move( 0, +1, hige_day, tr);
  245                  if(c=='L') return move( 0, -1, turn);                            |   273                  if(c=='L') return move( 0, -1, hige_day, tr);
  246                  if(c=='U') return move(+1,  0, turn);                            |   274                  if(c=='U') return move(+1,  0, hige_day, tr);
  247                  if(c=='D') return move(-1,  0, turn);                            |   275                  if(c=='D') return move(-1,  0, hige_day, tr);
  248                  if(c=='W') return move( 0,  0, turn);                            |   276                  if(c=='W') return move( 0,  0, hige_day, tr);
  249                  if(c=='S') return use_razor(turn);                               |   277                  if(c=='S') return use_razor(hige_day);
  250                  assert(false);                                                       278                  assert(false);
  251          }                                                                            279          }
  252                                                                                       280  
  253          Tuple!(int, bool) use_razor(int turn)                                    |   281          bool use_razor(bool hige_day)
  254          {                                                                            282          {
  255                  if(razor) {                                                          283                  if(razor) {
  256                          razor--;                                                     284                          razor--;
  257                          for(int dy=-1; dy<=+1; ++dy)                                 285                          for(int dy=-1; dy<=+1; ++dy)
  258                          for(int dx=-1; dx<=+1; ++dx)                                 286                          for(int dx=-1; dx<=+1; ++dx)
  259                                  if(this[robot.y+dy,robot.x+dx] == 'W')           |   287                                  if(this[robot.y+dy,robot.x+dx] == 'W') {
                                                                                        >   288                                          emptified(new Pos(robot.y+dy,robot.x+dx)
  260                                          this[robot.y+dy,robot.x+dx] = ' ';           289                                          this[robot.y+dy,robot.x+dx] = ' ';
                                                                                        >   290                                  }
  261                  }                                                                    291                  }
  262                                                                                       292  
  263                  bool dead = update(turn);                                        |   293                  return update(hige_day);
  264                  return tuple(0,dead);                                            <
  265          }                                                                            294          }
  266                                                                                       295  
                                                                                        >   296          bool rocky(char c) { return c=='*' || c=='@'; }
                                                                                        >   297  
                                                                                        >   298                  void emptified(Pos p) {
                                                                                        >   299                          for(int dy=0; dy<=+1; ++dy)
                                                                                        >   300                          for(int dx=-1; dx<=+1; ++dx)
                                                                                        >   301                                  may_update ~= new Pos(p.y+dy, p.x+dx);
                                                                                        >   302                  }
                                                                                        >   303  
  267          Tuple!(int, bool) move(int dy, int dx, int turn)                         |   304          bool move(int dy, int dx, bool hige_day, in Trampoline tr)
  268          {                                                                            305          {
                                                                                        >   306                  emptified(robot);
                                                                                        >   307  
  269                  int y = robot.y;                                                     308                  int y = robot.y;
  270                  int x = robot.x;                                                     309                  int x = robot.x;
  271                  int lambda = 0;                                                  <
  272                  if( '\\' == this[y+dy,x+dx] )                                        310                  if( '\\' == this[y+dy,x+dx] )
  273                          lambda++;                                                |   311                          collected_lambda++;
  274                  if( '!' == this[y+dy,x+dx] )                                         312                  if( '!' == this[y+dy,x+dx] )
  275                          razor++;                                                     313                          razor++;
                                                                                        >   314                  if( 'O' == this[y+dy,x+dx] )
                                                                                        >   315                          cleared = true;
  276                  if( " \\!.O".count(this[y+dy,x+dx])==1 ) {                           316                  if( " \\!.O".count(this[y+dy,x+dx])==1 ) {
  277                          this[y,x]=' ';                                               317                          this[y,x]=' ';
  278                          this[y+dy,x+dx]='R';                                         318                          this[y+dy,x+dx]='R';
  279                          robot = new Pos(y+dy,x+dx);                                  319                          robot = new Pos(y+dy,x+dx);
  280                  } else if(dy==0 && '*'==this[y+dy,x+dx] && ' '==this[y+dy*2,x+dx |   320                  } else if(dy==0 && rocky(this[y+dy,x+dx]) && ' '==this[y+dy*2,x+
                                                                                        >   321                          char rock = this[y+dy,x+dx];
  281                          this[y,x]=' ';                                               322                          this[y,x]=' ';
  282                          this[y+dy,x+dx]='R';                                         323                          this[y+dy,x+dx]='R';
  283                          this[y+dy*2,x+dx*2]='*';                                 |   324                          this[y+dy*2,x+dx*2]=rock;
  284                          robot = new Pos(y+dy,x+dx);                                  325                          robot = new Pos(y+dy,x+dx);
                                                                                        >   326                          may_update ~= new Pos(y+dy*2,x+dx*2);
  285                  } else if('A'<=this[y+dy,x+dx] && this[y+dy,x+dx]<='I') {            327                  } else if('A'<=this[y+dy,x+dx] && this[y+dy,x+dx]<='I') {
  286                          this[y,x]=' ';                                               328                          this[y,x]=' ';
  287                          Pos tp = tr_target[this[y+dy,x+dx]];                     |   329                          Pos tp = tr.target_pos(this[y+dy,x+dx]);
  288                          foreach(p; tr_source[this[tp]])                          |   330                          foreach(p; tr.source_pos(this[tp])) {
                                                                                        >   331                                  emptified(p);
  289                                  this[p] = ' ';                                       332                                  this[p] = ' ';
                                                                                        >   333                          }
  290                          this[tp] = 'R';                                              334                          this[tp] = 'R';
  291                          robot = tp;                                                  335                          robot = tp;
  292                  }                                                                    336                  }
  293                  bool dead = update(turn);                                        |   337                  return update(hige_day);
  294                  return tuple(lambda,dead);                                       <
  295          }                                                                            338          }
  296                                                                                       339  
  297          bool update(int turn)                                                    |   340          bool update(bool hige_day)
  298          {                                                                            341          {
                                                                                        >   342                  // Write after all the updates are processed.
                                                                                        >   343                  Tuple!(int,int,char)[] write_buffer;
                                                                                        >   344                  void write(int y, int x, char c) { write_buffer ~= tuple(y,x,c);
                                                                                        >   345                  void writep(Pos p, char c) { write_buffer ~= tuple(0+p.y,0+p.x,c
                                                                                        >   346                  scope(exit) {
                                                                                        >   347                          may_update.length = 0;
                                                                                        >   348                          foreach(wr; write_buffer) {
                                                                                        >   349                                  this[wr[0],wr[1]] = wr[2];
                                                                                        >   350                                  if(rocky(wr[2]))
                                                                                        >   351                                          may_update ~= new Pos(wr[0],wr[1]);
                                                                                        >   352                                  if(wr[2]==' ')
                                                                                        >   353                                          emptified(new Pos(wr[0], wr[1]));
                                                                                        >   354                          }
                                                                                        >   355                  }
                                                                                        >   356  
                                                                                        >   357                  if(collected_lambda == total_lambda)
                                                                                        >   358                          if(this[lift]=='L')
                                                                                        >   359                                  this[lift] = 'O';
                                                                                        >   360  
  299                  bool dead = false;                                                   361                  bool dead = false;
                                                                                        >   362                  if( hige_day ) {
                                                                                        >   363                          for(int y=1; y<=H; ++y)
                                                                                        >   364                          for(int x=1; x<=W; ++x)
                                                                                        >   365                                  if(this[y,x]=='W')
                                                                                        >   366                                          may_update ~= new Pos(y,x);
                                                                                        >   367                  }
  300                                                                                       368  
  301                  char[][] next;                                                   |   369                  sort(may_update);
  302                  foreach(y,s; data)                                               |   370                  foreach(p; may_update) {
  303                          next ~= s.dup;                                           |   371                          int y = p.y, x = p.x;
  304                                                                                   <
  305                  ref char access(Pos p) { return next[H-p.y][p.x-1]; }            <
  306                                                                                   <
  307                  bool lambda = false;                                             <
  308                  for(int y=1; y<=H; ++y)                                          <
  309                  for(int x=1; x<=W; ++x)                                          <
  310                          lambda |= (this[y,x] == '\\');                           <
  311                                                                                   <
  312                  for(int y=1; y<=H; ++y)                                          <
  313                  for(int x=1; x<=W; ++x) {                                        <
  314                          Pos p = new Pos(y,x);                                    <
                                                                                        >   372                          char rock = this[p];
  315                          if(this[p]=='*') {                                       |   373                          if(rocky(this[p])) {
  316                                  if(this[p.D]==' ') {                                 374                                  if(this[p.D]==' ') {
  317                                          access(p)  =' ';                         |   375                                          writep(p, ' ');
  318                                          access(p.D)='*';                         |   376                                          writep(p.D, (rock=='@'&&this[p.D.D]!=' '
  319                                          if(robot == p.D.D)                           377                                          if(robot == p.D.D)
  320                                                  dead=true;                           378                                                  dead=true;
  321                                  }                                                    379                                  }
  322                                  else if((this[p.D]=='*' || this[p.D]=='\\') && t |   380                                  else if((rocky(this[p.D]) || this[p.D]=='\\') &&
  323                                          access(p)=' ';                           |   381                                          writep(p, ' ');
  324                                          access(p.R.D)='*';                       |   382                                          writep(p.R.D,(rock=='@'&&this[p.R.D.D]!=
  325                                          if(robot == p.R.D.D)                         383                                          if(robot == p.R.D.D)
  326                                                  dead=true;                           384                                                  dead=true;
  327                                  }                                                    385                                  }
  328                                  else if(this[p.D]=='*' && this[p.L]==' ' && this |   386                                  else if(rocky(this[p.D]) && this[p.L]==' ' && th
  329                                          access(p)=' ';                           |   387                                          writep(p, ' ');
  330                                          access(p.L.D)='*';                       |   388                                          writep(p.L.D, (rock=='@'&&this[p.L.D.D]!
  331                                          if(robot == p.L.D.D)                         389                                          if(robot == p.L.D.D)
  332                                                  dead=true;                           390                                                  dead=true;
  333                                  }                                                    391                                  }
  334                          }                                                            392                          }
  335                          else if(this[p]=='L') {                                  <
  336                                  if(!lambda)                                      <
  337                                          access(p) = 'O';                         <
  338                          }                                                        <
  339                          else if(this[p]=='W') {                                      393                          else if(this[p]=='W') {
  340                                  if( hige.is_growing_turn(turn) )                 |   394                                  if(hige_day) {
  341                                          for(int dy=-1; dy<=+1; ++dy)                 395                                          for(int dy=-1; dy<=+1; ++dy)
  342                                          for(int dx=-1; dx<=+1; ++dx)                 396                                          for(int dx=-1; dx<=+1; ++dx)
  343                                                  if(this[p.y+dy,p.x+dx] == ' ')   |   397                                                  if(this[p.y+dy,p.x+dx] == ' ') {
  344                                                          access(new Pos(p.y+dy,p. |   398                                                          write(p.y+dy,p.x+dx,'W')
                                                                                        >   399                                                          if(robot.y==p.y+dy-1 && 
                                                                                        >   400                                                                  dead = false; //
                                                                                        >   401                                                  }
                                                                                        >   402                                  }
  345                          }                                                            403                          }
  346                  }                                                                    404                  }
  347                  data = next;                                                     <
                                                                                        >   405  
  348                  return dead;                                                         406                  return dead;
  349          }                                                                            407          }
  350  }                                                                                    408  }
  351                                                                                       409  
  352  ////////////////////////////////////////////////////////////////////////////////     410  ////////////////////////////////////////////////////////////////////////////////
  353                                                                                       411  
  354  class Game                                                                           412  class Game
  355  {                                                                                    413  {
  356  public:                                                                          |   414          mixin DeriveShow;
                                                                                        >   415  
  357          this(File input)                                                             416          this(File input)
  358          {                                                                            417          {
  359                  // Read map data                                                 |   418                  string[]       raw_data;
  360                  string[] map_data_lines;                                         |   419                  string[string] params;
  361                  for(string line; !(line=input.readln().chomp()).empty; )         <
  362                          map_data_lines ~= line;                                  <
  363                                                                                       420  
  364                  // H*W                                                           |   421                  // Raw map data; read until empty line.
  365                  H_ = map_data_lines.length;                                      |   422                  for(string line; !(line=input.readln().chomp()).empty; )
  366                  W_ = 0;                                                          |   423                          raw_data ~= line;
  367                  foreach(mdl; map_data_lines)                                     <
  368                          W_ = max(W_, mdl.length);                                <
  369                                                                                       424  
  370                  // Copy to modifiable buffer and adjust coordinates.             |   425                  // Additional commands; read until EOF.
  371                  raw_data_ = new char[][H_+1];                                    |   426                  char[char] trampo;
  372                  foreach(i,mdl; map_data_lines) {                                 |   427                  for(string line; !(line=input.readln()).empty; ) {
  373                          char[] buf = new char[mdl.length+1];                     |   428                          string[] ss = line.split();
  374                          buf[0] = '#';                                            |   429                          if( ss.length == 2 )
  375                          buf[1..$] = mdl[];                                       |   430                                  params[ss[0]] = ss[1];
  376                          raw_data_[H_-i] = buf;                                   |   431                          if( ss.length == 4 && ss[0]=="Trampoline" && ss[2]=="tar
  377                  }                                                                <
  378                                                                                   <
  379                  // Detect objects                                                <
  380                  for(int y=1; y<=H_; ++y)                                         <
  381                  for(int x=1; x<raw_data_[y].length; ++x)                         <
  382                  {                                                                <
  383                          char c = raw_data_[y][x];                                <
  384                          switch(c)                                                <
  385                          {                                                        <
  386                          case '#':                                                <
  387                          case '.':                                                <
  388                          case ' ':                                                <
  389                                  break;                                           <
  390                          case 'L':                                                <
  391                          case 'O':                                                <
  392                                  lift_pos_ = new Pos(y,x);                        <
  393                                  break;                                           <
  394                          case 'A': .. case 'I':                                   <
  395                          case '1': .. case '9':                                   <
  396                                  trampoline_pos_[c] = new Pos(y,x);               <
  397                                  break;                                           <
  398                          case '!':                                                <
  399                                  razor_pos_ ~= new Pos(y,x);                      <
  400                                  break;                                           <
  401                          case '\\':                                               <
  402                                  lambda_pos_ ~= new Pos(y,x);                     <
  403                                  break;                                           <
  404                                                                                   <
  405                          // Moving objects are erased from raw_data_              <
  406                          case 'R':                                                <
  407                                  robot_pos_ = new Pos(y,x);                       <
  408                                  raw_data_[y][x] = ' ';                           <
  409                                  break;                                           <
  410                          case '*':                                                <
  411                          case 'W':                                                <
  412                                  dynamic_objects_[new Pos(y,x)] = c;              <
  413                                  raw_data_[y][x] = ' ';                           <
  414                                  if(c=='*')                                       <
  415                                          may_update_[new Pos(y,x)] = true;        <
  416                                  break;                                           <
  417                          default:                                                 <
  418                                  assert(false);                                   <
  419                          }                                                        <
                                                                                        >   432                                  trampo[ss[1][0]] = ss[3][0];
  420                  }                                                                    433                  }
  421                                                                                       434  
  422                  // Read other parameters                                         |   435                  this.map   = new Map(raw_data, params, trampo);
  423                  for(string line; !(line=input.readln()).empty; )                 |   436                  this.water = Water.load(params);
  424                  {                                                                <
                                                                                        >   437                  this.hige  = Hige.load(params);
  425                          string[] ss = line.split();                              |   438                  this.tr    = new Trampoline(this.map, trampo);
  426                          if( ss.length == 2 )                                     <
  427                                  switch(ss[0])                                    <
  428                                  {                                                <
  429                                  case "Water":      water_base_ = ss[1].to!int(); <
  430                                  case "Flooding":   water_pace_ = ss[1].to!int(); <
  431                                  case "Waterproof": max_air_    = ss[1].to!int(); <
  432                                  case "Growth":     hige_pace_  = ss[1].to!int(); <
  433                                  case "Razors":     num_razor_  = ss[1].to!int(); <
  434                                  default: assert(false);                          <
  435                                  }                                                |   439          }
  436                          if( ss.length == 4 && ss[0]=="Trampoline" && ss[2]=="tar <
  437                          {                                                        <
  438                                  char fr=ss[1][0], to=ss[3][0];                   <
  439                                  trampoline_[fr] = to;                            <
  440                                  if(to !in trampoline_rev_) trampoline_rev_[to] = <
  441                                  trampoline_rev_[to] ~= fr;                       <
  442                          }                                                        <
  443                  }                                                                <
  444                                                                                       440  
  445                  air_left_ = max_air_;                                            |   441          Game clone() const { return new Game(this); }
                                                                                        >   442          this(in Game g) {
                                                                                        >   443                  map   = g.map.clone();
                                                                                        >   444                  water = g.water.clone();
                                                                                        >   445                  hige  = g.hige.clone();
                                                                                        >   446                  tr    = g.tr.clone();
                                                                                        >   447                  turn  = g.turn;
                                                                                        >   448                  dead  = g.dead;
                                                                                        >   449                  under_water = g.under_water;
  446          }                                                                            450          }
  447                                                                                       451  
  448          @property const {                                                        <
  449                  int H() { return H_; }                                           <
  450                  int W() { return W_; }                                           <
  451                  char trampoline(char c) { return (c in trampoline_ ? trampoline_ <
  452                  const(Pos)[] trampoline_rev(char c) {                            <
  453                          const(Pos)[] pp;                                         <
  454                          if(c in trampoline_rev_) {                               <
  455                                  foreach(ch; trampoline_rev_[c])                  <
  456                                          pp ~= trampoline_pos_[ch];               <
  457                          }                                                        <
  458                          return pp;                                               <
  459                  }                                                                <
  460                  int water_level() {                                              <
  461                          return water_pace_ ? water_base_ + turn_/water_pace_ : w <
  462                  }                                                                <
  463                  int water_until_rise() {                                         <
  464                          return water_pace_ ? water_pace_ - turn_%water_pace_ : i <
  465                  }                                                                <
  466                  int hige_until_rise() {                                          <
  467                          return hige_pace_ ? hige_pace_ - turn_%hige_pace_ : int. <
  468                  }                                                                <
  469                  bool is_hige_turn() {                                            <
  470                          return hige_pace_ ? turn_%hige_pace_ == hige_pace_-1 : f <
  471                  }                                                                <
  472                  int hp() { return air_left_; }                                   <
  473                  int num_razor() { return num_razor_; }                           <
  474                  bool cleared() { return cleared_; }                              <
  475                  bool dead() { return dead_; }                                    <
  476                  long score() { return num_lambda_*(dead_ ? 25L : cleared_ ? 75L  <
  477                  const(Pos) robot() { return robot_pos_; }                        <
  478                  const(Pos) lift() { return lift_pos_; }                          <
  479                  Pos[] lambdas() {                                                <
  480                          Pos[] pp;                                                <
  481                          foreach(p; lambda_pos_)                                  <
  482                                  pp ~= p.clone();                                 <
  483                          return pp;                                               <
  484                  }                                                                <
  485                  Pos[] razors() {                                                 <
  486                          Pos[] pp;                                                <
  487                          foreach(p; razor_pos_)                                   <
  488                                  pp ~= p.clone();                                 <
  489                          return pp;                                               <
  490                  }                                                                <
  491                  const(Pos)[] higes() {                                           <
  492                          const(Pos)[] pp;                                         <
  493                          foreach(p,c; dynamic_objects_)                           <
  494                                  if(c=='W')                                       <
  495                                          pp ~= p;                                 <
  496                          return pp;                                               <
  497                  }                                                                <
  498          }                                                                        <
  499          const {                                                                  <
  500                  char opIndex(in Pos p) { return opIndex(p.y, p.x); }             <
  501                  char opIndex(int y, int x) { return map_get(y, x); }             <
  502          }                                                                        <
  503                                                                                   <
  504  public:                                                                          <
  505          void command(char c)                                                         452          void command(char c)
  506          {                                                                            453          {
                                                                                        >   454                  assert(c != 'A');
  507                  if(dead || cleared)                                                  455                  if(dead || cleared)
  508                          return;                                                      456                          return;
  509                                                                                       457  
  510                  if(c == 'U') command_move(+1, 0);                                |   458                  // TODO: clarify the event order
  511                  if(c == 'D') command_move(-1, 0);                                |   459                  bool dead_now = map.command(c, turn, hige.is_growing_turn(turn),
  512                  if(c == 'L') command_move(0, -1);                                |   460                  if( dead_now )
  513                  if(c == 'R') command_move(0, +1);                                |   461                          dead = true;
  514                  if(c == 'S') use_razor();                                        <
  515                  if(c == 'W') {}                                                  <
  516                                                                                   <
  517                  if(!cleared)                                                     |   462                  if(!map.cleared) {
  518                  {                                                                <
  519                          map_update();                                            <
                                                                                        >   463                          if( map.robot.y <= water_level )
  520                          water_update();                                          |   464                                  ++under_water;
                                                                                        >   465                          else
                                                                                        >   466                                  under_water = 0;
                                                                                        >   467                          if( under_water > map.waterproof )
                                                                                        >   468                                  dead = true;
  521                  }                                                                    469                  }
  522                  turn_ ++;                                                        |   470                  turn += 1;
  523          }                                                                            471          }
  524                                                                                       472  
  525          void command_move(int dy, int dx)                                        |   473          Map map;
  526          {                                                                        <
                                                                                        >   474          Water water;
  527                  int y = robot_pos_.y, x = robot_pos_.x;                          |   475          Hige hige;
  528                  char c = this[y+dy, x+dx];                                       <
  529                  Pos p = new Pos(y+dy, x+dx);                                     <
  530                                                                                   <
  531                  switch(c){                                                       <
  532                  case 'O':                                                        <
  533                          cleared_ = true;                                         <
  534                          move_robot_to(p);                                        <
  535                          break;                                                   <
  536                  case '\\':                                                       <
  537                          take_lambda_at(p);                                       <
  538                          move_robot_to(p);                                        <
  539                          break;                                                   <
  540                  case '!':                                                        <
  541                          take_razor_at(p);                                        <
  542                          move_robot_to(p);                                        <
  543                          break;                                                   <
  544                  case 'A': .. case 'I':                                           <
  545                          enter_trampoline_at(p, c);                               |   476          Trampoline tr;
  546                          break;                                                   <
  547                  case ' ':                                                        <
  548                  case '.':                                                        <
  549                          move_robot_to(p);                                        <
  550                          break;                                                   <
  551                  case '*':                                                        <
  552                          if(dy!=0 || this[y,x+dx*2]!=' ')                         <
  553                                  break;                                           <
  554                          move_robot_to(p);                                        <
  555                          push_rock(p, new Pos(y,x+dx*2));                         <
  556                          break;                                                   <
  557                  default:                                                         <
  558                          break;                                                   <
  559                  }                                                                <
  560          }                                                                        <
  561                                                                                   <
  562          void use_razor()                                                         <
  563          {                                                                        <
  564                  if(num_razor_ == 0)                                              <
  565                          return;                                                  |   477          int  turn = 0;
  566                  num_razor_ --;                                                   <
  567                                                                                   <
  568                  for(int dy=-1; dy<=+1; ++dy)                                     <
  569                  for(int dx=-1; dx<=+1; ++dx) if(dy||dx)                          <
  570                  {                                                                <
  571                          Pos p = new Pos(robot_pos_.y+dy, robot_pos_.x+dx);       <
  572                          if(auto it = p in dynamic_objects_)                      <
  573                                  if(*it == 'W') {                                 <
  574                                          something_gone(p);                       <
  575                                          dynamic_objects_.remove(p);              <
  576                                  }                                                <
  577                  }                                                                <
  578          }                                                                        <
  579                                                                                   <
  580          void take_lambda_at(Pos p)                                               <
  581          {                                                                        <
  582                  map_set_empty(p);                                                <
  583                  num_lambda_ ++;                                                  <
  584                  lambda_pos_ = lambda_pos_.erase(p);                              <
  585          }                                                                        <
  586                                                                                   <
  587          void take_razor_at(Pos p)                                                <
  588          {                                                                        <
  589                  map_set_empty(p);                                                <
  590                  num_razor_ ++;                                                   <
  591                  razor_pos_ = razor_pos_.erase(p);                                <
  592          }                                                                        <
  593                                                                                   <
  594          void enter_trampoline_at(Pos p, char c)                                  <
  595          {                                                                        <
  596                  char d = trampoline(c);                                          <
  597                  foreach(cc; trampoline_rev_[d]) {                                <
  598                          Pos pp = trampoline_pos_[cc];                            <
  599                          something_gone(pp);                                      <
  600                          map_set_empty(pp);                                       <
  601                  }                                                                <
  602                  move_robot_to(trampoline_pos_[d]);                               <
  603          }                                                                        <
  604                                                                                   <
  605          void move_robot_to(Pos p)                                                <
  606          {                                                                        <
  607                  something_gone(robot_pos_);                                      <
  608                  map_set_empty(p.y, p.x);                                         <
  609                  robot_pos_ = p;                                                  <
  610          }                                                                        <
  611                                                                                   <
  612          void push_rock(Pos fr, Pos to)                                           <
  613          {                                                                        <
  614                  dynamic_objects_.remove(fr);                                     <
  615                  dynamic_objects_[to] = '*';                                      <
  616                  may_update_[to] = true;                                          <
  617          }                                                                        <
  618                                                                                   <
  619          void something_gone(Pos p)                                               <
  620          {                                                                        <
  621                  for(int dy=0;  dy<=+1; ++dy)                                     <
  622                  for(int dx=-1; dx<=+1; ++dx) if(dy||dx)                          <
  623                          may_update_[new Pos(p.y+dy,p.x+dx)] = true;              <
  624          }                                                                        <
                                                                                        >   478          bool dead = false;
                                                                                        >   479          int  under_water = 0;
                                                                                        >   480          // TODO: when adding members, take care of clone().
                                                                                        >   481          // TODO: fix this poor design.
  625                                                                                       482  
  626          void map_update()                                                        |   483  @property const:
  627          {                                                                        |   484          long score()           { return map.collected_lambda*(dead?25L:cleared?7
  628                  Pos[] may_update_list;                                           <
  629                  foreach(p,_; may_update_)                                        <
  630                          if(this[p] == '*')                                       <
  631                                  may_update_list ~= p;                            <
  632                  may_update_ = null;                                              <
  633                                                                                   <
  634                  if( is_hige_turn() )                                             <
  635                          foreach(p,c; dynamic_objects_)                           <
  636                                  if(c == 'W')                                     <
  637                                          may_update_list ~= p;                    <
  638                                                                                   <
  639                  sort(may_update_list);                                           <
  640                  char[Pos] to_be_written;                                         <
  641                  foreach(p; may_update_list)                                      <
  642                          if(is_hige_turn() && this[p]=='W')                       <
  643                          {                                                        <
  644                                  for(int dy=-1; dy<=+1; ++dy)                     <
  645                                  for(int dx=-1; dx<=+1; ++dx) {                   <
  646                                          Pos q = new Pos(p.y+dy,p.x+dx);          <
  647                                          if( this[q] == ' ' )                     <
  648                                                  to_be_written[q] = 'W';          <
  649                                  }                                                <
  650                          }                                                        <
  651                          else                                                     <
  652                          {                                                        <
  653                                  int y = p.y;                                     <
  654                                  int x = p.x;                                     <
  655                                  char below = this[y-1,x];                        <
  656                                  // *                                             <
  657                                  // _                                             <
  658                                  if(below==' ') {                                 <
  659                                          Pos q = new Pos(y-1,x);                  <
  660                                          to_be_written[p] = ' ';                  <
  661                                          to_be_written[q] = '*';                  <
  662                                          may_update_[q] = true;                   <
  663                                  }                                                <
  664                                  // *_      *_                                    <
  665                                  // *_  or  \_                                    <
  666                                  else if((below=='*'||below=='\\')&&this[y-1,x+1] <
  667                                          Pos q = new Pos(y-1,x+1);                <
  668                                          to_be_written[p] = ' ';                  <
  669                                          to_be_written[q] = '*';                  <
  670                                          may_update_[q] = true;                   <
  671                                  }                                                <
  672                                  // _*                                            <
  673                                  // _*                                            <
  674                                  else if(below=='*'&&this[y-1,x-1]==' '&&this[y,x <
  675                                          Pos q = new Pos(y-1,x-1);                <
  676                                          to_be_written[p] = ' ';                  <
  677                                          to_be_written[q] = '*';                  <
  678                                          may_update_[q] = true;                   <
  679                                  }                                                <
  680                          }                                                        <
  681                                                                                   <
  682                  foreach(p,c; to_be_written) {                                    <
  683                          dynamic_objects_[p] = c;                                 <
  684                          if(c=='*' && p.y==robot_pos_.y+1 && p.x==robot_pos_.x)   <
  685                                  dead_ = true;                                    <
  686                  }                                                                <
  687                                                                                   <
  688                  if(lambda_pos_.empty)                                            <
  689                          raw_data_[lift_pos_.y][lift_pos_.x] = 'O';               <
  690          }                                                                        <
  691                                                                                   <
  692          void water_update()                                                      <
  693          {                                                                        <
  694                  if( robot_pos_.y <= water_level() )                              |   485          int water_level()      { return water.level(turn); }
  695                          air_left_ --;                                            <
  696                  else                                                             <
  697                          air_left_ = max_air_;                                    <
  698                  if( air_left_ < 0 )                                              <
  699                          dead_ = true;                                            <
  700          }                                                                        <
  701                                                                                   <
  702  private:                                                                         <
  703          char map_get(int y, int x) const                                         <
  704          {                                                                        <
  705                  if( y<1 || H<y || x<1 || W<x ) return '#';                       <
  706                  Pos p = new Pos(y,x);                                            <
  707                  if(p == robot_pos_)                                              <
  708                          return 'R';                                              <
  709                  if(auto it = (p in dynamic_objects_))                            <
  710                          return *it;                                              <
  711                  if( x<0 || raw_data_[y].length<=x ) return ' ';                  <
  712                  return raw_data_[y][x];                                          <
  713          }                                                                        <
  714                                                                                   <
  715          void map_set_empty(in Pos p)                                             <
  716          {                                                                        <
  717                  return map_set_empty(p.y, p.x);                                  <
  718          }                                                                        <
  719                                                                                   <
  720          void map_set_empty(int y, int x)                                         <
  721          {                                                                        <
  722                  if( y<1 || H<y || x<1 || W<x ) return;                           <
  723                  if( x<0 || raw_data_[y].length<=x ) return;                      <
  724                  raw_data_[y][x] = ' ';                                           <
  725          }                                                                        <
  726                                                                                   <
  727  public:                                                                          <
  728          Game clone() const { return new Game(this); }                            <
  729          this(in Game g) {                                                        <
  730                  H_ = g.H_;                                                       <
  731                  W_ = g.W_;                                                       <
  732                  raw_data_ = new char[][g.raw_data_.length];                      <
  733                  foreach(i,d; g.raw_data_) raw_data_[i] = d.dup;                  <
  734                  trampoline_pos_ = cast(Pos[char]) g.trampoline_pos_;             <
  735                  razor_pos_  = (cast(Game)g).razor_pos_.dup;                      <
  736                  lambda_pos_ = (cast(Game)g).lambda_pos_.dup;                     <
  737                  lift_pos_   = g.lift_pos_.clone();                               <
  738                  robot_pos_  = g.robot_pos_.clone();                              <
  739                  dynamic_objects_ = dup(g.dynamic_objects_);                      <
  740                  trampoline_     = (cast(Game)g).trampoline_;                     <
  741                  trampoline_rev_ = (cast(Game)g).trampoline_rev_;                 <
  742                  water_base_ = g.water_base_;                                     <
  743                  water_pace_ = g.water_pace_;                                     <
  744                  max_air_    = g.max_air_;                                        <
  745                  hige_pace_  = g.hige_pace_;                                      <
  746                  num_razor_  = g.num_razor_;                                      <
  747                  num_lambda_ = g.num_lambda_;                                     <
  748                  turn_       = g.turn_;                                           <
  749                  air_left_   = g.air_left_;                                       <
  750                  cleared_    = g.cleared_;                                        <
  751                  dead_       = g.dead_;                                           <
  752                  may_update_ = dup(g.may_update_);                                <
  753          }                                                                        <
  754                                                                                   <
  755          V[K] dup(V,K)(in V[K] aa) {                                              <
  756                  V[K] aa2;                                                        <
  757                  foreach(k,v; aa) aa2[k] = v;                                     <
  758                  return aa2;                                                      <
  759          }                                                                        <
  760                                                                                   <
  761  private:                                                                         <
  762          int          H_;                                                         <
  763          int          W_;                                                         <
  764          char[][]     raw_data_;                                                  <
  765          Pos[char]    trampoline_pos_;                                            <
  766          Pos[]        razor_pos_;                                                 <
  767          Pos[]        lambda_pos_;                                                <
  768          Pos          lift_pos_;                                                  <
  769          Pos          robot_pos_;                                                 <
  770          char[Pos]    dynamic_objects_;                                           <
  771          char[char]   trampoline_;                                                <
  772          char[][char] trampoline_rev_;                                            <
  773          int          water_base_ = 0;                                            <
  774          int          water_pace_ = 0;                                            <
  775          int          max_air_    = 10;                                           <
  776          int          hige_pace_  = 25;                                           <
  777          int          num_razor_  = 0;                                            <
  778          int          num_lambda_ = 0;                                            <
  779                                                                                   <
  780          int turn_     = 0;                                                       <
  781          int air_left_ = 0;                                                       <
                                                                                        >   486          int water_until_rise() { return water.until_rise(turn); }
                                                                                        >   487          int hige_until_rise()  { return hige.until_rise(turn); }
                                                                                        >   488          int hp()               { return map.waterproof - under_water; }
  782          bool cleared_ = false;                                                   |   489          bool cleared()         { return map.cleared; }
  783          bool dead_    = false;                                                   <
  784          bool[Pos] may_update_;                                                   <
  785  }                                                                                    490  }

Modified src/gui.d from [e84cacd6262f93a7] to [93d9f5f261f71d2c].

    4  import driver;                                                                         4  import driver;
    5                                                                                         5  
    6  class GUI(Solver) : Form, GameObserver                                                 6  class GUI(Solver) : Form, GameObserver
    7  {                                                                                      7  {
    8          this(in Game g)                                                                8          this(in Game g)
    9          {                                                                              9          {
   10                  this.solver = new Solver(g);                                          10                  this.solver = new Solver(g);
   11                  setup_size(g.W, g.H);                                            |    11                  setup_size(g.map.W, g.map.H);
   12                  setup_resources(g);                                                   12                  setup_resources(g);
   13                  draw(g);                                                              13                  draw(g);
   14          }                                                                             14          }
   15                                                                                        15  
   16          private void delegate(char c) fn;                                        |    16          void run(void delegate(char c) command, bool automate = true)
   17          void set_fn(F)(F f) { this.fn = f; }                                     <
   18                                                                                   <
   19          void run(bool automate = false)                                          <
   20          {                                                                             17          {
   21                  if(automate) {                                                        18                  if(automate) {
   22                          Timer t = new Timer;                                          19                          Timer t = new Timer;
   23                          t.interval = 50;                                              20                          t.interval = 50;
   24                          t.tick ~= (Timer sender, EventArgs ea){                  <
   25                                  fn(solver.single_step());                        |    21                          t.tick ~= (Timer s, EventArgs e){command(solver.single_s
   26                          };                                                       <
   27                          t.start();                                                    22                          t.start();
   28                          this.closing ~= (Form f,CancelEventArgs c){t.stop();};        23                          this.closing ~= (Form f,CancelEventArgs c){t.stop();};
   29                  } else {                                                              24                  } else {
   30                          setup_keyhandling();                                     |    25                          setup_keyhandling(command);
   31                  }                                                                     26                  }
   32                  Application.run(this);                                                27                  Application.run(this);
   33          }                                                                             28          }
   34                                                                                        29  
   35          override void on_game_changed(char c, in Game g, bool finished)               30          override void on_game_changed(char c, in Game g, bool finished)
   36          {                                                                             31          {
   37                  draw(g);                                                              32                  draw(g);
   38          }                                                                             33          }
   39                                                                                        34  
   40  private:                                                                              35  private:
   41          int cell;                                                                <
   42                                                                                   <
   43          void setup_size(int W, int H)                                                 36          void setup_size(int W, int H)
   44          {                                                                             37          {
   45                  this.formBorderStyle = FormBorderStyle.FIXED_DIALOG;                  38                  this.formBorderStyle = FormBorderStyle.FIXED_DIALOG;
   46                  this.maximizeBox = false;                                             39                  this.maximizeBox = false;
   47                  this.minimizeBox = false;                                             40                  this.minimizeBox = false;
   48                  this.cell = min(1024/W, 640/H);                                       41                  this.cell = min(1024/W, 640/H);
   49                  this.clientSize = Size(W*cell, H*cell);                               42                  this.clientSize = Size(W*cell, H*cell);
   50          }                                                                             43          }
   51                                                                                        44  
                                                                                        >    45          int          cell;
   52          Font         font;                                                            46          Font         font;
   53          Color[char]  colors;                                                          47          Color[char]  colors;
   54          string[char] render;                                                          48          string[char] render;
   55          Graphics     graphicContext;                                                  49          Graphics     graphicContext;
   56                                                                                        50  
   57          void setup_resources(in Game g)                                               51          void setup_resources(in Game g)
   58          {                                                                             52          {
   59                  this.graphicContext = new MemoryGraphics(this.clientSize.width,       53                  this.graphicContext = new MemoryGraphics(this.clientSize.width, 
   60                  this.setStyle(ControlStyles.OPAQUE, true);                            54                  this.setStyle(ControlStyles.OPAQUE, true);
   61                  this.font = new Font("MS Gothic", cell-2, GraphicsUnit.PIXEL);        55                  this.font = new Font("MS Gothic", cell-2, GraphicsUnit.PIXEL);
   62                  this.backColor = Color(255,255,255);                                  56                  this.backColor = Color(255,255,255);
   63                  this.colors['#'] =                                                    57                  this.colors['#'] =
   64                  this.colors['.'] = Color(255,191,127);                                58                  this.colors['.'] = Color(255,191,127);
   65                  this.colors['*'] = Color(255,127,127);                           |    59                  this.colors['*'] =
                                                                                        >    60                  this.colors['@'] = Color(255,127,127);
   66                  this.colors['R'] = Color(128,128,0);                                  61                  this.colors['R'] = Color(128,128,0);
                                                                                        >    62                  this.colors['r'] = Color(100,128,255);
   67                  this.colors['d'] = Color(255,0,0);                                    63                  this.colors['d'] = Color(255,0,0);
   68                  this.colors['\\'] =                                                   64                  this.colors['\\'] =
   69                  this.colors['L'] =                                                    65                  this.colors['L'] =
   70                  this.colors['O'] = Color(127,255,127);                                66                  this.colors['O'] = Color(127,255,127);
   71                  this.colors['w'] = Color(204,229,255);                                67                  this.colors['w'] = Color(204,229,255);
   72                  this.colors['W'] =                                                    68                  this.colors['W'] =
   73                  this.colors['!'] = Color(159,159,159);                                69                  this.colors['!'] = Color(159,159,159);
   74                  foreach(char c; 'A'..'J') this.colors[c] = Color(142,142,255);        70                  foreach(char c; 'A'..'J') this.colors[c] = Color(142,142,255);
   75                  foreach(char c; '1'..':') this.colors[c] = Color(255,142,255);        71                  foreach(char c; '1'..':') this.colors[c] = Color(255,142,255);
   76                  this.render['#'] = "■";                                               72                  this.render['#'] = "■";
   77                  this.render['*'] = "✹";                                               73                  this.render['*'] = "✹";
                                                                                        >    74                  this.render['@'] = "❁";
   78                  this.render['.'] = "♒";                                               75                  this.render['.'] = "♒";
   79                  this.render['\\'] = "λ";                                              76                  this.render['\\'] = "λ";
   80                  this.render['R'] = "☃";                                               77                  this.render['R'] = "☃";
                                                                                        >    78                  this.render['r'] = "☃";
   81                  this.render['d'] = "☠";                                               79                  this.render['d'] = "☠";
   82                  this.render['L'] = "☒";                                               80                  this.render['L'] = "☒";
   83                  this.render['O'] = "☐";                                               81                  this.render['O'] = "☐";
   84                  this.render['W'] = "ꔣ";                                               82                  this.render['W'] = "ꔣ";
   85                  this.render['!'] = "✄";                                               83                  this.render['!'] = "✄";
                                                                                        >    84                  foreach(char c; g.tr.source_list)
   86                  foreach(char c; 'A'..'J') this.render[c] = [cast(dchar)('☢'+g.tr |    85                          this.render[c] = [cast(dchar)('☢'+g.tr.target_of(c)-'1')
                                                                                        >    86                  foreach(char c; g.tr.target_list)
   87                  foreach(char c; '1'..':') this.render[c] = [cast(dchar)('☢'+c-'1 |    87                          this.render[c] = [cast(dchar)('☢'+c-'1')].to!string();
   88                  this.paint ~= (Control c, PaintEventArgs ev) {                        88                  this.paint ~= (Control c, PaintEventArgs ev) {
   89                          graphicContext.copyTo(ev.graphics, Rect(0,0,this.clientS      89                          graphicContext.copyTo(ev.graphics, Rect(0,0,this.clientS
   90                  };                                                                    90                  };
   91          }                                                                             91          }
   92                                                                                        92  
   93          void draw(in Game g)                                                          93          void draw(in Game g)
   94          {                                                                             94          {
................................................................................................................................................................................

   99                  graphicContext.fillRectangle(this.backColor, Rect(0,0,scrW,scrH)      99                  graphicContext.fillRectangle(this.backColor, Rect(0,0,scrW,scrH)
  100                                                                                       100  
  101                  // Fill water.                                                       101                  // Fill water.
  102                  int w = g.water_level();                                             102                  int w = g.water_level();
  103                  graphicContext.fillRectangle(this.colors['w'], Rect(0, scrH-cell     103                  graphicContext.fillRectangle(this.colors['w'], Rect(0, scrH-cell
  104                                                                                       104  
  105                  // Paint map.                                                        105                  // Paint map.
  106                  for(int y=1; y<=g.H; ++y)                                        |   106                  for(int y=1; y<=g.map.H; ++y)
  107                  for(int x=1; x<=g.W; ++x) {                                      |   107                  for(int x=1; x<=g.map.W; ++x) {
  108                          Rect r = Rect(cell*(x-1), scrH-cell*y, cell, cell);          108                          Rect r = Rect(cell*(x-1), scrH-cell*y, cell, cell);
  109                          char c = g[y,x];                                         |   109                          char c = g.map[y,x];
  110                          if( c != ' ' ) {                                             110                          if( c != ' ' ) {
  111                                  if( c == 'R' && g.dead )                         |   111                                  if( c == 'R' )
  112                                          c = 'd';                                 |   112                                          c = (g.dead ? 'd' : g.cleared ? 'r' : 'R
  113                                  graphicContext.drawText(this.render[c], font, th     113                                  graphicContext.drawText(this.render[c], font, th
  114                          }                                                            114                          }
  115                  }                                                                    115                  }
  116                                                                                       116  
  117                  // Update textual info.                                              117                  // Update textual info.
  118                  this.text = .text(                                                   118                  this.text = .text(
  119                          "Score: ", g.score,                                          119                          "Score: ", g.score,
  120                          " Air: ", g.hp,                                              120                          " Air: ", g.hp,
  121                          " Tide: ", g.water_until_rise,                               121                          " Tide: ", g.water_until_rise,
  122                          " Wadler: ", g.hige_until_rise,                              122                          " Wadler: ", g.hige_until_rise,
  123                          " Razor: ", g.num_razor);                                |   123                          " Razor: ", g.map.razor);
  124                  invalidate();                                                        124                  invalidate();
  125          }                                                                            125          }
  126                                                                                       126  
  127  private:                                                                             127  private:
  128          void setup_keyhandling()                                                 |   128          void setup_keyhandling(void delegate(char c) command)
  129          {                                                                            129          {
  130                  noMessageFilter();                                                   130                  noMessageFilter();
  131                  this.keyDown ~= &my_keydown;                                     |   131                  this.keyDown ~= (Control c, KeyEventArgs ev) {
  132          }                                                                        <
  133                                                                                   <
  134          void do_manual_command(char c)                                           |   132                          void do_manual_command(char c)
  135          {                                                                        |   133                          {
  136                  solver.force(c);                                                 |   134                                  solver.force(c);
  137                  fn(c);                                                           |   135                                  command(c);
  138          }                                                                        |   136                          }
  139                                                                                   <
  140          void my_keydown(Control c, KeyEventArgs ev)                              <
  141          {                                                                        <
  142                  switch(ev.keyCode)                                               |   137                          switch(ev.keyCode)
  143                  {                                                                |   138                          {
  144                  case Keys.DOWN:  do_manual_command('D'); break;                  |   139                          case Keys.DOWN:  do_manual_command('D'); break;
  145                  case Keys.UP:    do_manual_command('U'); break;                  |   140                          case Keys.UP:    do_manual_command('U'); break;
  146                  case Keys.LEFT:  do_manual_command('L'); break;                  |   141                          case Keys.LEFT:  do_manual_command('L'); break;
  147                  case Keys.RIGHT: do_manual_command('R'); break;                  |   142                          case Keys.RIGHT: do_manual_command('R'); break;
  148                  case Keys.W:     do_manual_command('W'); break;                  |   143                          case Keys.W:     do_manual_command('W'); break;
  149                  case Keys.S:     do_manual_command('S'); break;                  |   144                          case Keys.S:     do_manual_command('S'); break;
  150                  case Keys.A:     do_manual_command('A'); break;                  |   145                          case Keys.A:     do_manual_command('A'); break;
  151                  case Keys.G:     fn(solver.single_step()); break;                |   146                          case Keys.G:     command(solver.single_step()); break;
  152                  default:         break;                                          |   147                          default:         break;
  153                  }                                                                |   148                          }
                                                                                        >   149                  };
  154          }                                                                            150          }
  155                                                                                       151  
  156          Solver solver;                                                               152          Solver solver;
  157  }                                                                                    153  }

Modified src/gui_main.d from [05082d0f328d756c] to [4124e840a1a49af9].

                                                                                        >     1  import util;
    1  import gui;                                                                            2  import gui;
    2  import output;                                                                         3  import output;
    3  import driver;                                                                         4  import driver;
    4  import solver;                                                                         5  import solver;
    5  import std.stdio;                                                                <
    6  pragma(lib, "dfl.lib");                                                                6  pragma(lib, "dfl.lib");
    7                                                                                         7  
    8  void main(string[] args)                                                         |     8  void main(string[] argv)
    9  {                                                                                      9  {
                                                                                        >    10          bool automate = (argv.length>=2 && std.string.indexOf(argv[1],"auto")>=0
                                                                                        >    11  
   10          Driver d = new Driver(stdin);                                            |    12          auto d = new Driver(stdin);
   11          d.addObserver!(GuardedOutput)();                                              13          d.addObserver!(GuardedOutput)();
   12          auto g = d.addObserver!(GUI!MainSolver)();                               |    14          d.addObserver!(GUI!MainSolver)().run(&d.command, automate);
   13          g.set_fn(&d.command);                                                    <
   14          g.run();                                                                 <
   15  }                                                                                     15  }

Added src/main.d version [51a9d789eb377d34]

                                                                                        >     1  import util;
                                                                                        >     2  import game;
                                                                                        >     3  import output;
                                                                                        >     4  import driver;
                                                                                        >     5  import solver;
                                                                                        >     6  
                                                                                        >     7  class CUI(Solver) : GameObserver
                                                                                        >     8  {
                                                                                        >     9          this(in Game g) { solver = new Solver(g); }
                                                                                        >    10          Solver solver;
                                                                                        >    11          bool fin;
                                                                                        >    12          override void on_game_changed(char c, in Game g, bool finished) { fin = 
                                                                                        >    13  }
                                                                                        >    14  
                                                                                        >    15  class ForSafety : GameObserver
                                                                                        >    16  {
                                                                                        >    17          this(in Game g)
                                                                                        >    18          {
                                                                                        >    19                  if(g.map.W*g.map.H <= 1000)
                                                                                        >    20                  {
                                                                                        >    21                          try {
                                                                                        >    22                                  score_log ~= g.score;
                                                                                        >    23                                  auto fast_solver = new FastSolver(g);
                                                                                        >    24                                  foreach(_; 0..g.map.W*g.map.H) {
                                                                                        >    25                                          char c = fast_solver.single_step();
                                                                                        >    26                                          if(c=='A') break;
                                                                                        >    27                                          const(Game) gg = fast_solver.current_gam
                                                                                        >    28                                          log ~= c;
                                                                                        >    29                                          score_log ~= gg.score;
                                                                                        >    30                                          if(gg.cleared || gg.dead) break;
                                                                                        >    31                                  }
                                                                                        >    32                          } catch {
                                                                                        >    33                                  log = null;
                                                                                        >    34                                  score_log = null;
                                                                                        >    35                          }
                                                                                        >    36                  }
                                                                                        >    37          }
                                                                                        >    38          override void on_game_changed(char c, in Game g, bool finished) {}
                                                                                        >    39          string log;
                                                                                        >    40          long[] score_log;
                                                                                        >    41  }
                                                                                        >    42  
                                                                                        >    43  void main()
                                                                                        >    44  {
                                                                                        >    45          auto d = new Driver(stdin);
                                                                                        >    46          auto o = d.addObserver!(GuardedOutput)();
                                                                                        >    47          auto c = d.addObserver!(CUI!MainSolver)();
                                                                                        >    48          auto f = d.addObserver!(ForSafety)();
                                                                                        >    49          o.safety_data(f.log, f.score_log);
                                                                                        >    50          while(!c.fin)
                                                                                        >    51                  d.command(c.solver.single_step());
                                                                                        >    52  }

Modified src/output.d from [e2d0d7db868c3a44] to [bdd3d4d83c822b4b].

   31          override void on_game_changed(char c, in Game g, bool finished)               31          override void on_game_changed(char c, in Game g, bool finished)
   32          {                                                                             32          {
   33                  if(flushed)                                                           33                  if(flushed)
   34                          return;                                                       34                          return;
   35                                                                                        35  
   36                  log ~= c;                                                             36                  log ~= c;
   37                  score_log ~= g.score;                                                 37                  score_log ~= g.score;
   38                  if(finished || log.length+1==g.W*g.H)                            |    38                  if(finished || log.length+1==g.map.W*g.map.H)
   39                          flush();                                                      39                          flush();
                                                                                        >    40                  if(log.length+1==g.map.W*g.map.H)
                                                                                        >    41                          application_exit();
                                                                                        >    42          }
                                                                                        >    43  
                                                                                        >    44          void safety_data(string s_log, long[] s_score_log) {
                                                                                        >    45                  this.s_log = s_log;
                                                                                        >    46                  this.s_score_log = s_score_log;
   40          }                                                                             47          }
   41                                                                                        48  
   42  private:                                                                              49  private:
   43          string log;                                                                   50          string log;
   44          long[] score_log;                                                             51          long[] score_log;
   45          bool   flushed;                                                               52          bool   flushed;
   46                                                                                        53  
                                                                                        >    54          string s_log;
                                                                                        >    55          long[] s_score_log;
                                                                                        >    56  
   47          void flush()                                                                  57          void flush()
   48          {                                                                             58          {
   49                  if(flushed)                                                           59                  if(flushed)
   50                          return;                                                       60                          return;
   51                                                                                        61  
   52                  Tuple!(long, int) cand;                                          |    62                  Tuple!(long, int, immutable(char)*) cand;
   53                  cand[0] = long.min;                                                   63                  cand[0] = long.min;
   54                                                                                        64  
   55                  for(int i=0; i<score_log.length; ++i)                                 65                  for(int i=0; i<score_log.length; ++i)
   56                          if(cand[0] < score_log[i])                                    66                          if(cand[0] < score_log[i])
   57                                  cand = tuple(score_log[i],i);                    |    67                                  cand = tuple(score_log[i],i,log.ptr);
                                                                                        >    68                  for(int i=0; i<s_score_log.length; ++i)
                                                                                        >    69                          if(cand[0] < s_score_log[i])
                                                                                        >    70                                  cand = tuple(s_score_log[i],i,s_log.ptr);
   58                                                                                        71  
   59                  std.c.stdio.printf("%.*sA\n", cand[1], log.ptr);                 |    72                  std.c.stdio.printf("%.*sA\n", cand[1], cand[2]);
   60                  std.c.stdio.fflush(std.c.stdio.stdout);                               73                  std.c.stdio.fflush(std.c.stdio.stdout);
   61                  flushed = true;                                                       74                  flushed = true;
   62          }                                                                             75          }
   63                                                                                        76  
   64  private:                                                                              77  private:
   65          static __gshared GuardedOutput g_output;                                      78          static __gshared GuardedOutput g_output;
   66                                                                                        79  

Modified src/solver.d from [22c356ff1975e92f] to [da568e3b806540de].

                                                                                        >     1  //
                                                                                        >     2  // http://en.wikipedia.org/wiki/F%C5%ABrinkazan
                                                                                        >     3  //
    1  import util;                                                                           4  import util;
    2  import game;                                                                           5  import game;
    3                                                                                         6  
    4  class Solver_0                                                                   |     7  interface Solver
                                                                                        >     8  {
                                                                                        >     9          // this(in Game g);
                                                                                        >    10          char single_step();
                                                                                        >    11          void force(char c);
                                                                                        >    12  }
                                                                                        >    13  
                                                                                        >    14  
                                                                                        >    15  bool is_spacy(char c)
                                                                                        >    16  {
                                                                                        >    17          return c==' ' || c=='.' || c=='R' || c=='!' || c=='\\' || c=='O';
                                                                                        >    18  }
                                                                                        >    19  
                                                                                        >    20  bool is_rocky(char c)
                                                                                        >    21  {
                                                                                        >    22          return c=='*' || c=='@';
                                                                                        >    23  }
                                                                                        >    24  
                                                                                        >    25  bool is_true_space(char c)
                                                                                        >    26  {
                                                                                        >    27          return c==' ';
                                                                                        >    28  }
                                                                                        >    29  
                                                                                        >    30  bool is_trampoline_source(char c)
                                                                                        >    31  {
                                                                                        >    32          return 'A'<=c && c<='I';
                                                                                        >    33  }
                                                                                        >    34  
                                                                                        >    35  bool is_rocklambda(char c)
                                                                                        >    36  {
                                                                                        >    37          return is_rocky(c) || c=='\\';
                                                                                        >    38  }
                                                                                        >    39  
                                                                                        >    40  Tuple!(string,int) death_move(in Game g)
                                                                                        >    41  {
                                                                                        >    42          // TODO: S
                                                                                        >    43  
                                                                                        >    44          string death;
                                                                                        >    45          int breath;
                                                                                        >    46          int y = g.map.robot.y;
                                                                                        >    47          int x = g.map.robot.x;
                                                                                        >    48          int[5] dy_=[+1,-1,0,0,0];
                                                                                        >    49          int[5] dx_=[0,0,-1,+1,0];
                                                                                        >    50          char[] ds=['U','D','L','R','W'];
                                                                                        >    51          for(int i=0; i<5; ++i)
                                                                                        >    52          {
                                                                                        >    53                  bool after_move_death(int y, int x, char tr_tgt)
                                                                                        >    54                  {
                                                                                        >    55                          bool is_spacy_t(char c) {
                                                                                        >    56                                  if(is_true_space(c) || c=='R' || c==tr_tgt)
                                                                                        >    57                                          return true;
                                                                                        >    58                                  return ('A'<=c && c<='I' && g.tr.target_of(c)==t
                                                                                        >    59                          }
                                                                                        >    60  
                                                                                        >    61                          // check water
                                                                                        >    62                          if( g.map[y,x]!='O' && g.hp==0 && y<=g.water_level )
                                                                                        >    63                                  return true;
                                                                                        >    64  
                                                                                        >    65                          // check falling rock.
                                                                                        >    66                          int yy=y+1, xx=x;
                                                                                        >    67                          if( is_spacy_t(g.map[yy, xx]) )
                                                                                        >    68                          {
                                                                                        >    69                                  if( is_rocky(g.map[yy+1,xx]) )
                                                                                        >    70                                          return true;
                                                                                        >    71                                  if( is_spacy_t(g.map[yy+1,xx]) && is_rocky(g.map
                                                                                        >    72                                          if( is_spacy_t(g.map[yy+1,xx+2]) && is_s
                                                                                        >    73                                                  return false;
                                                                                        >    74                                          return true;
                                                                                        >    75                                  }
                                                                                        >    76                                  if( is_spacy_t(g.map[yy+1,xx]) && is_rocky(g.map
                                                                                        >    77                                          if(g.hige_until_rise == 1 && g.map[yy+1,
                                                                                        >    78                                                  return false;
                                                                                        >    79                                          return true;
                                                                                        >    80                                  }
                                                                                        >    81                          }
                                                                                        >    82                          return false;
                                                                                        >    83                  }
                                                                                        >    84  
                                                                                        >    85                  int dy=dy_[i], dx=dx_[i];
                                                                                        >    86                  if( is_spacy(g.map[y+dy,x+dx]) || dy==0 && is_rocky(g.map[y,x+dx
                                                                                        >    87                  {
                                                                                        >    88                          if( after_move_death(y+dy, x+dx, char.init) )
                                                                                        >    89                                  death ~= ds[i];
                                                                                        >    90                          else if(ds[i] != 'W')
                                                                                        >    91                                  breath ++;
                                                                                        >    92                  }
                                                                                        >    93                  else if( is_trampoline_source(g.map[y+dy,x+dx]) )
                                                                                        >    94                  {
                                                                                        >    95                          Pos p = g.tr.target_pos(g.map[y+dy,x+dx]);
                                                                                        >    96                          if( after_move_death(p.y, p.x, g.tr.target_of(g.map[y+dy
                                                                                        >    97                                  death ~= ds[i];
                                                                                        >    98                          else
                                                                                        >    99                                  breath ++;
                                                                                        >   100                  }
                                                                                        >   101                  else
                                                                                        >   102                  {
                                                                                        >   103                          death ~= ds[i];
                                                                                        >   104                  }
                                                                                        >   105          }
                                                                                        >   106  
                                                                                        >   107          return tuple(death, breath);
                                                                                        >   108  }
                                                                                        >   109  
                                                                                        >   110  class Queue(T)
                                                                                        >   111  {
                                                                                        >   112          alias Tuple!(T,int) t;
                                                                                        >   113  
                                                                                        >   114          t[] cur, next;
                                                                                        >   115  
                                                                                        >   116          void push(T v, int p) { (cur.empty ? cur : next) ~= tuple(v,p); }
                                                                                        >   117          bool empty() { return cur.empty; }
                                                                                        >   118          t pop() {
                                                                                        >   119                  t v = cur[0]; cur = cur[1..$];
                                                                                        >   120                  if(cur.empty) { cur = next; next = null; }
                                                                                        >   121                  return v;
                                                                                        >   122          }
                                                                                        >   123  }
                                                                                        >   124  
                                                                                        >   125  ///
                                                                                        >   126  /// Solver "Mountain":  be immovable like a mountain.
                                                                                        >   127  ///
                                                                                        >   128  class 不動如山 : Solver
    5  {                                                                                    129  {
    6          this(in Game g) {}                                                           130          this(in Game g) {}
    7          char single_step() { return 'W'; }                                           131          char single_step() { return 'W'; }
    8          void force(char c) {}                                                        132          void force(char c) {}
    9  }                                                                                    133  }
   10                                                                                       134  
   11  class Solver_1                                                                   <
                                                                                        >   135  ///
                                                                                        >   136  /// Solver "Forest": shows contemplation.
                                                                                        >   137  ///
                                                                                        >   138  class 徐如林 : Solver
   12  {                                                                                    139  {
   13          int wait_count = 0;                                                          140          int wait_count = 0;
   14          int choke_count = 0;                                                         141          int choke_count = 0;
   15                                                                                       142  
   16          Game g;                                                                      143          Game g;
   17          this(in Game g)                                                              144          this(in Game g)
   18          {                                                                            145          {
   19                  this.g = g.clone();                                                  146                  this.g = g.clone();
   20                  forbidden_cell = new bool[][](g.H+2, g.W+2);                     |   147                  forbidden_cell = new bool[][](g.map.H+2, g.map.W+2);
   21          }                                                                            148          }
   22                                                                                       149  
   23          char single_step()                                                           150          char single_step()
   24          {                                                                            151          {
   25                  Tuple!(string,int) de = death_move(g);                               152                  Tuple!(string,int) de = death_move(g);
   26                  char c = act(g, de[0], de[1]);                                       153                  char c = act(g, de[0], de[1]);
   27                  force(c);                                                            154                  force(c);
................................................................................................................................................................................

   30                                                                                       157  
   31          void force(char c)                                                           158          void force(char c)
   32          {                                                                            159          {
   33                  if(c != 'A')                                                         160                  if(c != 'A')
   34                          g.command(c);                                                161                          g.command(c);
   35          }                                                                            162          }
   36                                                                                       163  
   37          Tuple!(string,int) death_move(const(Game) g)                             <
   38          {                                                                        <
   39                  string death;                                                    <
   40                  int choice = 0;                                                  <
   41                  foreach(char c; "UDLRW") {                                       <
   42                          Game gg = g.clone();                                     <
   43                          gg.command(c);                                           <
   44                          if( !gg.cleared && gg.dead )                             <
   45                                  death ~= c;                                      <
   46                          else if( gg.robot != g.robot )                           <
   47                                  choice++;                                        <
   48                          else if( c != 'W' ) // meaningless move                  <
   49                                  death ~= c;                                      <
   50                  }                                                                <
   51                  return tuple(death, choice);                                     <
   52          }                                                                        <
   53                                                                                   <
   54          Tuple!(Pos, int)[] log;                                                      164          Tuple!(Pos, int)[] log;
   55          bool[][] forbidden_cell;                                                     165          bool[][] forbidden_cell;
   56                                                                                       166  
   57          char act(const(Game) g, string death, int breath)                            167          char act(const(Game) g, string death, int breath)
   58          {                                                                            168          {
                                                                                        >   169                  foreach(char c; "UDLR")
                                                                                        >   170                          if( death.count(c)==0 && is_one_way_load(g,c) )
                                                                                        >   171                                  return c;
                                                                                        >   172  
   59                  const Pos    ro = g.robot;                                       |   173                  const Pos    ro = g.map.robot;
   60                  const Pos    li = g.lift;                                        |   174                  const Pos    li = g.map.lift;
   61                  Pos[] la = g.lambdas();                                          |   175                  Pos[] la = g.map.lambdas();
   62                  sort!((Pos a,Pos b){                                                 176                  sort!((Pos a,Pos b){
   63                          int ad=abs(a.y-li.y)+abs(a.x-li.x);                          177                          int ad=abs(a.y-li.y)+abs(a.x-li.x);
   64                          int bd=abs(b.y-li.y)+abs(b.x-li.x);                          178                          int bd=abs(b.y-li.y)+abs(b.x-li.x);
   65                          return ad>bd;;                                               179                          return ad>bd;;
   66                  })(la);                                                              180                  })(la);
   67                  Pos[] ra = g.razors();                                           |   181                  Pos[] ra = g.map.razors();
   68                  const(Pos)[] hi = g.higes();                                     |   182                  const(Pos)[] hi = g.map.objects('W');
   69                                                                                       183  
   70                  Tuple!(char,int)[] cand;                                             184                  Tuple!(char,int)[] cand;
   71                  char c = 'W';                                                        185                  char c = 'W';
   72                  if( la.empty ) {                                                 |   186                  if( g.map.collected_lambda == g.map.total_lambda ) {
   73                          cand = search(g, ro, [li], death);                           187                          cand = search(g, ro, [li], death);
   74                  } else {                                                         |   188                  } else if( !la.empty ){
   75                          cand ~= search(g, ro, la~ra, death);                         189                          cand ~= search(g, ro, la~ra, death);
   76                  }                                                                    190                  }
   77                                                                                       191  
   78                  // 'higesori' mode                                                   192                  // 'higesori' mode
   79                  if( !hi.empty && g.num_razor>0 ) {                               |   193                  if( !hi.empty && g.map.razor>0 ) {
   80                          int his = 0;                                                 194                          int his = 0;
   81                          for(int dy=-1; dy<=+1; ++dy)                                 195                          for(int dy=-1; dy<=+1; ++dy)
   82                          for(int dx=-1; dx<=+1; ++dx)                                 196                          for(int dx=-1; dx<=+1; ++dx)
   83                                  if(g[ro.y+dy,ro.x+dx] == 'W')                    |   197                                  if(g.map[ro.y+dy,ro.x+dx] == 'W')
   84                                          his++;                                       198                                          his++;
   85                                                                                       199  
   86                          if(his>=2 || his==hi.length)                                 200                          if(his>=2 || his==hi.length)
   87                                  cand = [tuple('S',int.max)];                         201                                  cand = [tuple('S',int.max)];
   88                          if(cand.empty) {                                             202                          if(cand.empty) {
   89                                  const(Pos)[] tgt;                                    203                                  const(Pos)[] tgt;
   90                                  for(int y=1; y<=g.H; ++y)                        |   204                                  for(int y=1; y<=g.map.H; ++y)
   91                                  for(int x=1; x<=g.W; ++x)                        |   205                                  for(int x=1; x<=g.map.W; ++x)
   92                                          if(g[y,x]=='.'||g[y,x]==' ') {           |   206                                          if(g.map[y,x]=='.'||g.map[y,x]==' ') {
   93                                                  his = 0;                             207                                                  his = 0;
   94                                                  for(int dy=-1; dy<=+1; ++dy)         208                                                  for(int dy=-1; dy<=+1; ++dy)
   95                                                  for(int dx=-1; dx<=+1; ++dx)         209                                                  for(int dx=-1; dx<=+1; ++dx)
   96                                                          if(g[y+dy,x+dx] == 'W')  |   210                                                          if(g.map[y+dy,x+dx] == '
   97                                                                  his++;               211                                                                  his++;
   98                                                  if(his>=2)                           212                                                  if(his>=2)
   99                                                          tgt ~= new Pos(y,x);         213                                                          tgt ~= new Pos(y,x);
  100                                          }                                            214                                          }
  101                                  cand ~= search(g, ro, tgt, death, true);             215                                  cand ~= search(g, ro, tgt, death, true);
  102                          }                                                            216                          }
  103                  }                                                                    217                  }
                                                                                        >   218  
                                                                                        >   219                  // 'horo-push' mode
                                                                                        >   220                  if(cand.empty) {
                                                                                        >   221                          Pos[] horo = g.map.objects('@');
                                                                                        >   222                          Pos[] tgt;
                                                                                        >   223                          foreach(p; horo)
                                                                                        >   224                                  if((g.map[p.y,p.x-1]==' '||g.map[p.y,p.x-1]=='R'
                                                                                        >   225                                     (g.map[p.y,p.x+1]==' '||g.map[p.y,p.x+1]=='R'
                                                                                        >   226                                   ||(g.map[p.y-1,p.x]==' '||g.map[p.y-1,p.x]=='R'
                                                                                        >   227                                          tgt ~= p;
                                                                                        >   228  
                                                                                        >   229                          for(int y=1; y<=g.map.H; ++y)
                                                                                        >   230                          for(int x=1; x<=g.map.W; ++x)
                                                                                        >   231                                  if(g.map[y,x]=='.')
                                                                                        >   232                                          if(is_rocky(g.map[y+1,x])||is_rocky(g.ma
                                                                                        >   233                                           ||is_rocky(g.map[y,x+1])||is_rocky(g.ma
                                                                                        >   234                                                  tgt ~= new Pos(y,x);
                                                                                        >   235  
                                                                                        >   236                          if(!tgt.empty)
                                                                                        >   237                                  cand ~= search(g, ro, tgt, death, true);
                                                                                        >   238                  }
  104                                                                                       239  
  105                  // 'dig' mode                                                        240                  // 'dig' mode
  106                  if(cand.empty) {                                                     241                  if(cand.empty) {
  107                          const(Pos)[] tgt;                                        |   242                          Pos[] tgt;
  108                          for(int y=1; y<=g.H; ++y)                                |   243                          for(int y=1; y<=g.map.H; ++y)
  109                          for(int x=1; x<=g.W; ++x)                                |   244                          for(int x=1; x<=g.map.W; ++x)
  110                                  if(g[y,x]=='.')                                  |   245                                  if(g.map[y,x]=='.')
  111                                          if(g[y+1,x]=='*'||g[y+1,x-1]=='*'||g[y+1 |   246                                          if(is_rocky(g.map[y+1,x])||is_rocky(g.ma
  112                                           ||g[y,x+1]=='*'||g[y,x-1]=='*')         |   247                                           ||is_rocky(g.map[y,x+1])||is_rocky(g.ma
  113                                                  tgt ~= new Pos(y,x);                 248                                                  tgt ~= new Pos(y,x);
  114                          cand ~= search(g, ro, tgt, death, true);                     249                          cand ~= search(g, ro, tgt, death, true);
  115                  }                                                                    250                  }
  116                                                                                       251  
  117                  if(cand.empty) {                                                     252                  if(cand.empty) {
  118                          choke_count++;                                               253                          choke_count++;
  119                          cand ~= tuple('W',int.max);                                  254                          cand ~= tuple('W',int.max);
................................................................................................................................................................................

  133                                  }                                                    268                                  }
  134                  }                                                                    269                  }
  135                                                                                       270  
  136                  if(c == 'W')                                                         271                  if(c == 'W')
  137                          wait_count++;                                                272                          wait_count++;
  138                  else                                                                 273                  else
  139                          wait_count = 0;                                              274                          wait_count = 0;
                                                                                        >   275                  if(wait_count==2)
                                                                                        >   276                          c = 'A';
  140                  if(choke_count >= g.H)                                           |   277                  if(choke_count >= g.map.H)
  141                          c = 'A';                                                     278                          c = 'A';
  142                                                                                       279  
  143                  bool[char] choice;                                                   280                  bool[char] choice;
  144                  foreach(t; cand)                                                     281                  foreach(t; cand)
  145                          choice[t[0]] = true;                                         282                          choice[t[0]] = true;
  146                  log ~= tuple(ro.clone(), cast(int)choice.length);                    283                  log ~= tuple(ro.clone(), cast(int)choice.length);
  147                  if(log.length > 5)                                                   284                  if(log.length > 5)
................................................................................................................................................................................

  155                  }                                                                    292                  }
  156                                                                                       293  
  157                  return c;                                                            294                  return c;
  158          }                                                                            295          }
  159                                                                                       296  
  160          Tuple!(char,int)[] search(in Game g, in Pos s, in Pos[] gs, string death     297          Tuple!(char,int)[] search(in Game g, in Pos s, in Pos[] gs, string death
  161          {                                                                            298          {
                                                                                        >   299                  bool very_danger(int y, int x)
                                                                                        >   300                  {
                                                                                        >   301                          if(g.map[y,x] == ' ' || g.map[y,x] == 'R')
                                                                                        >   302                                  return false;
                                                                                        >   303                          if(is_rocky(g.map[y+1,x]))
                                                                                        >   304                                  return true;
                                                                                        >   305                          return false;
                                                                                        >   306                  }
  162                  bool danger(int y, int x)                                            307                  bool danger(int y, int x)
  163                  {                                                                    308                  {
  164                          if(g[y,x] == ' ' || g[y,x] == 'R')                       |   309                          if(g.map[y,x] == ' ' || g.map[y,x] == 'R')
  165                                  return false;                                        310                                  return false;
  166                          if(g[y+1,x] == '*')                                      |   311                          if(is_rocky(g.map[y+1,x]))
                                                                                        >   312                                  return true;
                                                                                        >   313                          if(is_rocky(g.map[y+1,x-1]) && (g.map[y,x-1]=='\\'||is_r
                                                                                        >   314                            && (g.map[y+1,x]==' '||g.map[y+1,x]=='R'))
  167                                  return true;                                         315                                  return true;
  168                          if(g[y+1,x-1]=='*' && (g[y,x-1]=='\\'||g[y,x-1]=='*') && |   316                          if(is_rocky(g.map[y+1,x+1]) && is_rocky(g.map[y,x+1]) &&
  169                                  return true;                                         317                                  return true;
  170                          if(g[y+1,x+1]=='*' && (g[y,x+1]=='*') && (g[y+1,x]==' '| |   318                          if(is_rocky(g.map[y,x-1]) && (g.map[y-1,x-1]=='\\'||is_r
                                                                                        >   319                            && (g.map[y-1,x]==' '||g.map[y-1,x]=='R'))
  171                                  return true;                                         320                                  return true;
  172                          if(g[y,x-1]=='*' && (g[y-1,x-1]=='\\'||g[y-1,x-1]=='*')  |   321                          if(is_rocky(g.map[y,x+1]) && is_rocky(g.map[y-1,x+1]) &&
  173                                  return true;                                     <
  174                          if(g[y,x+1]=='*' && (g[y-1,x+1]=='*') && (g[y-1,x]==' '| <
  175                                  return true;                                         322                                  return true;
  176                          return false;                                                323                          return false;
  177                  }                                                                    324                  }
  178                                                                                       325  
  179                  // avoid directly below '*'                                          326                  // avoid directly below '*'
  180                  Tuple!(char,int)[] tryA() {                                          327                  Tuple!(char,int)[] tryA() {
  181                          const(Pos)[] q;                                              328                          const(Pos)[] q;
  182                          foreach(p; gs)                                               329                          foreach(p; gs)
  183                                  if(!danger(p.y,p.x))                             |   330                                  if(!very_danger(p.y,p.x))
  184                                          q ~= p;                                      331                                          q ~= p;
  185                          bool[][] v = new bool[][](g.H+2, g.W+2);                 |   332                          bool[][] v = new bool[][](g.map.H+2, g.map.W+2);
  186                          foreach(p; q) v[p.y][p.x]=true;                              333                          foreach(p; q) v[p.y][p.x]=true;
                                                                                        >   334                          bool first_step = true;
  187                          for(int step=1; q.length; ++step) {                          335                          for(int step=1; q.length; ++step) {
  188                                  Pos[] q2;                                            336                                  Pos[] q2;
  189                                  foreach(p; q) {                                      337                                  foreach(p; q) {
  190                                          int[] yyy=[p.y-1,p.y+1,p.y,p.y];         |   338                                          int[] yyy=[p.y-1,p.y,p.y,p.y+1];
  191                                          int[] xxx=[p.x,p.x,p.x-1,p.x+1];         |   339                                          int[] xxx=[p.x,p.x-1,p.x+1,p.x];
                                                                                        >   340                                          string sss="URLD";
  192                                          for(int i=0; i<yyy.length; ++i) {        |   341                                          for(int i=0; i<yyy.length; ++i) if(!firs
  193                                                  int y = yyy[i];                      342                                                  int y = yyy[i];
  194                                                  int x = xxx[i];                      343                                                  int x = xxx[i];
  195                                                  if('1'<=g[y,x]&&g[y,x]<='9') {   |   344                                                  if('1'<=g.map[y,x]&&g.map[y,x]<=
  196                                                          foreach(ppp; g.trampolin |   345                                                          foreach(ppp; g.tr.source
  197                                                                  yyy ~= ppp.y;        346                                                                  yyy ~= ppp.y;
  198                                                                  xxx ~= ppp.x;        347                                                                  xxx ~= ppp.x;
  199                                                          }                            348                                                          }
  200                                                          continue;                    349                                                          continue;
  201                                                  }                                    350                                                  }
  202                                                  if(v[y][x]) continue;                351                                                  if(v[y][x]) continue;
  203                                                  if(y==s.y && x==s.x && i<4) {        352                                                  if(y==s.y && x==s.x && i<4) {
  204                                                          char c = "UDRL"[i];      |   353                                                          char c = sss[i];
  205                                                          if( death.count(c) == 0      354                                                          if( death.count(c) == 0 
  206                                                                  return [tuple(c,     355                                                                  return [tuple(c,
  207                                                  } else if(forbidden_cell[y][x]){     356                                                  } else if(forbidden_cell[y][x]){
  208                                                  } else if(g[y,x]==' '||g[y,x]==' |   357                                                  } else if(g.map[y,x]==' '||g.map
  209                                                          if(danger(y,x))              358                                                          if(danger(y,x))
  210                                                                  continue;            359                                                                  continue;
  211                                                          q2 ~= new Pos(y,x);          360                                                          q2 ~= new Pos(y,x);
  212                                                          v[y][x]=true;                361                                                          v[y][x]=true;
  213                                                  }                                    362                                                  }
  214                                          }                                            363                                          }
  215                                  }                                                    364                                  }
                                                                                        >   365                                  first_step = false;
  216                                  q = q2;                                              366                                  q = q2;
  217                          }                                                            367                          }
  218                          return [];                                                   368                          return [];
  219                  }                                                                    369                  }
  220                                                                                       370  
  221                  // any empty space is my ground                                      371                  // any empty space is my ground
  222                  Tuple!(char,int)[] tryB() {                                          372                  Tuple!(char,int)[] tryB() {
  223                          const(Pos)[] q;                                              373                          const(Pos)[] q;
  224                          foreach(p; gs) q ~= p;                                       374                          foreach(p; gs) q ~= p;
  225                          bool[][] v = new bool[][](g.H+2, g.W+2);                 |   375                          bool[][] v = new bool[][](g.map.H+2, g.map.W+2);
  226                          foreach(p; q) v[p.y][p.x]=true;                              376                          foreach(p; q) v[p.y][p.x]=true;
                                                                                        >   377                          bool first_step = true;
  227                          for(int step=10; q.length; ++step) {                     |   378                          for(int step=8; q.length; ++step) {
  228                                  Pos[] q2;                                            379                                  Pos[] q2;
  229                                  foreach(p; q) {                                      380                                  foreach(p; q) {
  230                                          int[] yyy=[p.y-1,p.y+1,p.y,p.y];         |   381                                          int[] yyy=[p.y-1,p.y,p.y,p.y+1];
  231                                          int[] xxx=[p.x,p.x,p.x-1,p.x+1];         |   382                                          int[] xxx=[p.x,p.x-1,p.x+1,p.x];
                                                                                        >   383                                          string sss="URLD";
  232                                          for(int i=0; i<yyy.length; ++i) {        |   384                                          for(int i=0; i<yyy.length; ++i) if(!firs
  233                                                  int y = yyy[i];                      385                                                  int y = yyy[i];
  234                                                  int x = xxx[i];                      386                                                  int x = xxx[i];
  235                                                  if('1'<=g[y,x]&&g[y,x]<='9') {   |   387                                                  if('1'<=g.map[y,x]&&g.map[y,x]<=
  236                                                          foreach(ppp; g.trampolin |   388                                                          foreach(ppp; g.tr.source
  237                                                                  yyy ~= ppp.y;        389                                                                  yyy ~= ppp.y;
  238                                                                  xxx ~= ppp.x;        390                                                                  xxx ~= ppp.x;
  239                                                          }                            391                                                          }
  240                                                          continue;                    392                                                          continue;
  241                                                  }                                    393                                                  }
  242                                                  if(v[y][x]) continue;                394                                                  if(v[y][x]) continue;
  243                                                  if(y==s.y && x==s.x && i<4) {        395                                                  if(y==s.y && x==s.x && i<4) {
  244                                                          char c = "UDRL"[i];      |   396                                                          char c = sss[i];
  245                                                          if( death.count(c) == 0      397                                                          if( death.count(c) == 0 
  246                                                                  return [tuple(c,     398                                                                  return [tuple(c,
  247                                                  } else if(forbidden_cell[y][x]){     399                                                  } else if(forbidden_cell[y][x]){
  248                                                  } else if(g[y,x]==' '||g[y,x]==' |   400                                                  } else if(g.map[y,x]==' '||g.map
  249                                                          q2 ~= new Pos(y,x);          401                                                          q2 ~= new Pos(y,x);
  250                                                          v[y][x]=true;                402                                                          v[y][x]=true;
  251                                                  }                                    403                                                  }
  252                                          }                                            404                                          }
  253                                  }                                                    405                                  }
                                                                                        >   406                                  first_step = false;
  254                                  q = q2;                                              407                                  q = q2;
  255                          }                                                            408                          }
  256                          return [];                                                   409                          return [];
  257                  }                                                                    410                  }
  258                                                                                       411  
  259                  // push rocks!                                                       412                  // push rocks!
  260                  Tuple!(char,int)[] tryC() {                                          413                  Tuple!(char,int)[] tryC() {
  261                          const(Pos)[] q;                                              414                          const(Pos)[] q;
  262                          foreach(p; gs) q ~= p;                                       415                          foreach(p; gs) q ~= p;
  263                          bool[][] v = new bool[][](g.H+2, g.W+2);                 |   416                          bool[][] v = new bool[][](g.map.H+2, g.map.W+2);
  264                          foreach(p; q) v[p.y][p.x]=true;                              417                          foreach(p; q) v[p.y][p.x]=true;
                                                                                        >   418                          bool first_step = true;
  265                          for(int step=20; q.length; ++step) {                         419                          for(int step=20; q.length; ++step) {
  266                                  Pos[] q2;                                            420                                  Pos[] q2;
  267                                  foreach(p; q) {                                      421                                  foreach(p; q) {
  268                                          int[] yyy=[p.y-1,p.y+1,p.y,p.y];         |   422                                          int[] yyy=[p.y-1,p.y,p.y,p.y+1];
  269                                          int[] xxx=[p.x,p.x,p.x-1,p.x+1];         |   423                                          int[] xxx=[p.x,p.x-1,p.x+1,p.x];
                                                                                        >   424                                          string sss="URLD";
  270                                          for(int i=0; i<yyy.length; ++i) {        |   425                                          for(int i=0; i<yyy.length; ++i) if(!firs
  271                                                  int y = yyy[i];                      426                                                  int y = yyy[i];
  272                                                  int x = xxx[i];                      427                                                  int x = xxx[i];
  273                                                  if(g[p] == '*') {                |   428                                                  if(is_rocky(g.map[p])) {
  274                                                          if(i>=4)continue;            429                                                          if(i>=4)continue;
  275                                                          if(y!=p.y)continue;          430                                                          if(y!=p.y)continue;
  276                                                          if(g[y,p.x+(p.x-x)]!=' ' |   431                                                          if(g.map[y,p.x+(p.x-x)]!
  277                                                  }                                    432                                                  }
  278                                                  if('1'<=g[y,x]&&g[y,x]<='9') {   |   433                                                  if('1'<=g.map[y,x]&&g.map[y,x]<=
  279                                                          foreach(ppp; g.trampolin |   434                                                          foreach(ppp; g.tr.source
  280                                                                  yyy ~= ppp.y;        435                                                                  yyy ~= ppp.y;
  281                                                                  xxx ~= ppp.x;        436                                                                  xxx ~= ppp.x;
  282                                                          }                            437                                                          }
  283                                                          continue;                    438                                                          continue;
  284                                                  }                                    439                                                  }
  285                                                  if(v[y][x]) continue;                440                                                  if(v[y][x]) continue;
  286                                                  if(y==s.y && x==s.x && i<4) {        441                                                  if(y==s.y && x==s.x && i<4) {
  287                                                          char c = "UDRL"[i];      |   442                                                          char c = sss[i];
  288                                                          if( death.count(c) == 0      443                                                          if( death.count(c) == 0 
  289                                                                  return [tuple(c,     444                                                                  return [tuple(c,
  290                                                  } else if(forbidden_cell[y][x]){     445                                                  } else if(forbidden_cell[y][x]){
  291                                                  } else if(g[y,x]==' '||g[y,x]==' |   446                                                  } else if(g.map[y,x]==' '||g.map
  292                                                          q2 ~= new Pos(y,x);          447                                                          q2 ~= new Pos(y,x);
  293                                                          v[y][x]=true;                448                                                          v[y][x]=true;
  294                                                  }                                    449                                                  }
  295                                          }                                            450                                          }
  296                                  }                                                    451                                  }
                                                                                        >   452                                  first_step = false;
  297                                  q = q2;                                              453                                  q = q2;
  298                          }                                                            454                          }
  299                          return [];                                                   455                          return [];
  300                  }                                                                    456                  }
  301                  return (danger_ok ? [] : tryA()) ~ tryB() ~ tryC();                  457                  return (danger_ok ? [] : tryA()) ~ tryB() ~ tryC();
  302          }                                                                            458          }
  303  }                                                                                <
  304                                                                                       459  
  305  class Solver_2(Solver)                                                           <
  306  {                                                                                <
  307          string plan;                                                             <
  308          bool plan_broken = true;                                                 <
  309                                                                                   <
  310          Game g;                                                                  <
  311          this(in Game g)                                                          |   460          bool is_one_way_load(in Game g, char c)
  312          {                                                                            461          {
  313                  this.g = g.clone();                                              |   462                  Pos p = g.map.robot.clone();
  314                  make_plan(g);                                                    <
  315          }                                                                        <
                                                                                        >   463                  Pos q;
                                                                                        >   464                  if(c=='U') q=new Pos(p.y+1,p.x);
                                                                                        >   465                  if(c=='D') q=new Pos(p.y-1,p.x);
                                                                                        >   466                  if(c=='L') q=new Pos(p.y,p.x-1);
                                                                                        >   467                  if(c=='R') q=new Pos(p.y,p.x+1);
                                                                                        >   468                  char d = g.map[q];
                                                                                        >   469                  if(!(d==' '||d=='.'||d=='!'))
                                                                                        >   470                          return false;
  316                                                                                       471  
  317          Tuple!(Solver,string) run_sub_solver(in Game g)                          |   472                  bool found_lambda = false;
                                                                                        >   473                  int[4] dy=[-1,+1,0,0];
                                                                                        >   474                  int[4] dx=[0,0,+1,-1];
                                                                                        >   475                  for(;;)
  318          {                                                                        |   476                  {
  319                  string log;                                                      <
                                                                                        >   477                          Pos r = null;
                                                                                        >   478                          for(int i=0; i<4; ++i) {
                                                                                        >   479                                  int y=q.y+dy[i];
                                                                                        >   480                                  int x=q.x+dx[i];
                                                                                        >   481                                  if(x==p.x && y==p.y)
                                                                                        >   482                                          continue;
                                                                                        >   483                                  char e = g.map[y,x];
                                                                                        >   484                                  if(e=='#')
                                                                                        >   485                                          continue;
                                                                                        >   486                                  if(e==' '||e=='.'||e=='!'||e=='R'||e=='\\') {
                                                                                        >   487                                          if(r !is null)
                                                                                        >   488                                                  return false;
  320                  auto s = new Solver(g);                                          |   489                                          r = new Pos(y,x);
  321                  while(!g.cleared && !g.dead && plan.length<=g.H*g.W) {           <
  322                          char c = s.single_step();                                <
  323                          if( c == 'A' )                                           <
                                                                                        >   490                                          if(e=='\\')
                                                                                        >   491                                                  found_lambda = true;
                                                                                        >   492                                          continue;
                                                                                        >   493                                  }
                                                                                        >   494                                  return false;
                                                                                        >   495                          }
                                                                                        >   496                          if(r is null)
  324                                  break;                                               497                                  break;
  325                          log ~= c;                                                |   498                          p=q;
                                                                                        >   499                          q=r;
  326                  }                                                                    500                  }
  327                  while(log.length>0 && log[$-1]=='W')                             <
  328                          log.length--;                                            <
  329                  return tuple(s, log);                                            |   501                  return found_lambda;
  330          }                                                                            502          }
                                                                                        >   503  }
  331                                                                                       504  
  332          void make_plan(in Game g) {                                              <
                                                                                        >   505  ///
  333                  plan_broken = false;                                             |   506  /// Solver "Fire": in raiding and plundering other solvers, be like fire.
  334                  Tuple!(Solver,string) x = run_sub_solver(g);                     <
                                                                                        >   507  ///
  335                  plan = x[1];                                                     |   508  class 侵掠如火(SubSolver) : Solver
  336                  if(x[0].g.cleared)                                               <
                                                                                        >   509  {
  337                          return;                                                  |   510          // Parameters.
  338                  modify_plan(g, x[0].g.score);                                    |   511          int            PredictFuture = 10;
  339          }                                                                        <
                                                                                        >   512          const string[] RandomChoicePattern; // PF*RCP exhaustive search for RL s
                                                                                        >   513          const          ReplanLength  = 400; // O(PF*RCP*RL*SubSolver.single_step
  340                                                                                       514  
  341          void modify_plan(in Game ini, long unmod)                                |   515          Game      current_game;
                                                                                        >   516          SubSolver sub_solver;
                                                                                        >   517  
                                                                                        >   518          enum {Tentative, Tentative_Stuck, Fixed};
                                                                                        >   519          string plan;
                                                                                        >   520          int    plan_state;
                                                                                        >   521          int    replan_limit;
                                                                                        >   522          bool   lambda_getter;
                                                                                        >   523          int    clear_improvement = 3;
                                                                                        >   524  
                                                                                        >   525          this(in Game g)
  342          {                                                                            526          {
  343                  int bp = max(0, (cast(int)plan.length)-10);                      <
  344                  Game g = ini.clone();                                            |   527                  current_game = g.clone();
                                                                                        >   528                  plan         = "";
  345                  for(int i=0; i<bp; ++i) g.command(plan[i]);                      |   529                  plan_state   = Tentative;
                                                                                        >   530                  if(g.map.W*g.map.H <= 400) {
                                                                                        >   531                          RandomChoicePattern = ["UU","UD","UL","UR",
                                                                                        >   532                                                 "DU","DD","DL","DR",
                                                                                        >   533                                                 "LU","LD","LL","LR",
                                                                                        >   534                                                 "RU","RD","RL","RR","UUU","UUUU",
                                                                                        >   535                          PredictFuture = 20;
                                                                                        >   536                          clear_improvement = 1;
  346                                                                                   |   537                  }
  347                  Tuple!(string,long) cand = tuple(plan, unmod);                   <
  348                  for(int i=bp; i<plan.length; ++i) {                              <
                                                                                        >   538                  else if(g.map.W*g.map.H <= 4096) {
  349                          foreach(string c; ["U","D","L","R","UD","DU","LR","RL"]) |   539                          RandomChoicePattern = ["UUU","U","D","L","R","UD","DU","
  350                                  if(c[0] != plan[i]) {                            <
  351                                          Tuple!(string,long) zz = try_plan(c, g); <
  352                                          if(cand[1]<zz[1])                        <
  353                                                  cand = tuple(plan[0..i]~c~zz[0], <
                                                                                        >   540                          PredictFuture = 10;
                                                                                        >   541                          clear_improvement = 0;
  354                                  }                                                |   542                  }
  355                          g.command(plan[i]);                                      <
                                                                                        >   543                  else {
                                                                                        >   544                          RandomChoicePattern = ["U","D","L","R"];
                                                                                        >   545                          PredictFuture = 10;
                                                                                        >   546                          clear_improvement = 0;
  356                  }                                                                    547                  }
  357                  plan = cand[0];                                                  <
  358          }                                                                        <
  359                                                                                       548  
  360          Tuple!(string,long) try_plan(string c, in Game g)                        |   549                  replan_limit = PredictFuture;
  361          {                                                                        <
  362                  Game gg = g.clone();                                             <
  363                  foreach(cc;c)gg.command(cc);                                     <
  364                  Tuple!(Solver, string) x = run_sub_solver(gg);                   <
  365                  return tuple(x[1], x[0].g.score);                                <
  366          }                                                                            550          }
  367                                                                                       551  
  368          char single_step() {                                                     |   552          char single_step()
  369                  if(plan_broken)                                                  <
                                                                                        >   553          {
                                                                                        >   554                  if(current_game.dead || current_game.cleared)
                                                                                        >   555                          return 'A';
                                                                                        >   556  
                                                                                        >   557                  // Make enough prediction.
                                                                                        >   558                  while( plan_state==Tentative && plan.length<replan_limit )
                                                                                        >   559                          single_step_predict();
                                                                                        >   560  
                                                                                        >   561                  // If the future is bad, correct.
                                                                                        >   562                  if( plan_state==Tentative_Stuck && plan.length<replan_limit && !
  370                          make_plan(g);                                            |   563                          replan();
                                                                                        >   564  
                                                                                        >   565                  // Follow the predicted plan.
  371                  if(plan.empty)                                                   |   566                  if( plan.empty )
  372                          return 'A';                                                  567                          return 'A';
  373                  char c = plan[0];                                                    568                  char c = plan[0];
  374                  plan = plan[1..$];                                                   569                  plan = plan[1..$];
                                                                                        >   570                  int b_lambda = current_game.map.collected_lambda;
  375                  g.command(c);                                                    |   571                  current_game.command(c);
                                                                                        >   572                  int a_lambda = current_game.map.collected_lambda;
                                                                                        >   573                  if(b_lambda < a_lambda) lambda_getter = false;
  376                  return c;                                                            574                  return c;
  377          }                                                                            575          }
  378                                                                                       576  
  379          void force(char c) {                                                     |   577          void force(char c)
  380                  g.command(c);                                                    <
                                                                                        >   578          {
  381                  if(plan.length==0 || plan[0]!=c) {                               |   579                  if(plan.length>0 && plan[0]==c)
  382                          plan = "";                                               <
                                                                                        >   580                  {
  383                          plan_broken = true;                                      |   581                          // If matching the plan, just go forward.
  384                  }                                                                <
  385                  else                                                             <
  386                          plan = plan[1..$];                                           582                          plan = plan[1..$];
                                                                                        >   583                  }
                                                                                        >   584                  else
                                                                                        >   585                  {
                                                                                        >   586                          // Discard the plan, otherwise.
                                                                                        >   587                          plan_state = Tentative;
                                                                                        >   588                          plan       = "";
                                                                                        >   589                          sub_solver = null;
                                                                                        >   590                  }
                                                                                        >   591                  current_game.command(c);
                                                                                        >   592          }
                                                                                        >   593  
                                                                                        >   594          void single_step_predict()
                                                                                        >   595          {
                                                                                        >   596                  if(sub_solver is null) {
                                                                                        >   597                          sub_solver = new SubSolver(current_game);
                                                                                        >   598                          plan       = "";
                                                                                        >   599                  }
                                                                                        >   600  
                                                                                        >   601                  char c = sub_solver.single_step();
                                                                                        >   602                  if(c == 'A')
                                                                                        >   603                          plan_state = Tentative_Stuck;
                                                                                        >   604                  else {
                                                                                        >   605                          plan ~= c;
                                                                                        >   606                          if(sub_solver.g.cleared) {
                                                                                        >   607                                  if(clear_improvement-->0) {
                                                                                        >   608                                          plan_state = Tentative_Stuck;
                                                                                        >   609                                          replan_limit = min(plan.length-plan.leng
                                                                                        >   610                                  } else {
                                                                                        >   611                                          plan_state = Fixed;
                                                                                        >   612                                  }
                                                                                        >   613                          } else {
                                                                                        >   614                                  plan_state = (sub_solver.g.dead ? Tentative_Stuc
                                                                                        >   615                          }
                                                                                        >   616                  }
                                                                                        >   617          }
                                                                                        >   618  
                                                                                        >   619          void replan()
                                                                                        >   620          {
                                                                                        >   621                  // Try to replace every step of the plan by another move.
                                                                                        >   622                  Game g = current_game.clone();
                                                                                        >   623                  Tuple!(SubSolver, string, int) cand = tuple(sub_solver, plan, Te
                                                                                        >   624                  int insertion_point = plan.length;
                                                                                        >   625                  bool tiebreak_by_turn = false;
                                                                                        >   626                  int consider_length = min(ReplanLength, g.map.W*g.map.H);
                                                                                        >   627                  if(cand[0].g.cleared) consider_length = min(consider_length, can
                                                                                        >   628  
                                                                                        >   629                  for(int i=0; i<plan.length; ++i) {
                                                                                        >   630                          foreach(string prefix; RandomChoicePattern)
                                                                                        >   631                                  if(prefix[0] != plan[i]) {
                                                                                        >   632                                          Tuple!(SubSolver, string, int) r = try_p
                                                                                        >   633                                          r[1] = plan[0..i] ~ prefix ~ r[1];
                                                                                        >   634                                          bool better = false, tbt=false;
                                                                                        >   635                                          if(!cand[0].g.cleared && r[0].g.cleared)
                                                                                        >   636                                                  better = true;
                                                                                        >   637                                          else if(cand[0].g.cleared && r[0].g.clea
                                                                                        >   638                                                  better = cand[0].g.score < r[0].
                                                                                        >   639                                          }
                                                                                        >   640                                          else if(!cand[0].g.cleared && !r[0].g.cl
                                                                                        >   641                                                  if(cand[0].g.map.collected_lambd
                                                                                        >   642                                                          better = true;
                                                                                        >   643                                                  else if(cand[0].g.map.collected_
                                                                                        >   644                                                          if(cand[0].g.dead && !r[
                                                                                        >   645                                                                  better = true;
                                                                                        >   646                                                          else if(cand[0].g.dead =
                                                                                        >   647                                                                  better = (cand[1
                                                                                        >   648                                                                  tbt = true;
                                                                                        >   649                                                          }
                                                                                        >   650                                                  }
                                                                                        >   651                                          }
                                                                                        >   652                                          if(better) {
                                                                                        >   653                                                  cand = r;
                                                                                        >   654                                                  tiebreak_by_turn = true;
                                                                                        >   655                                                  insertion_point = i+prefix.lengt
                                                                                        >   656                                                  if(r[0].g.cleared) consider_leng
                                                                                        >   657                                          }
                                                                                        >   658                                  }
                                                                                        >   659                          g.command(plan[i]);
                                                                                        >   660                  }
                                                                                        >   661  
                                                                                        >   662                  if(cand[2]==Fixed && insertion_point!=plan.length && clear_impro
                                                                                        >   663                          sub_solver   = cand[0];
                                                                                        >   664                          plan         = cand[1];
                                                                                        >   665                          plan_state   = Tentative_Stuck;
                                                                                        >   666                          replan_limit = min(plan.length - insertion_point, Predic
                                                                                        >   667                          lambda_getter = current_game.map.collected_lambda < cand
                                                                                        >   668                  } else {
                                                                                        >   669                          sub_solver   = cand[0];
                                                                                        >   670                          plan         = cand[1];
                                                                                        >   671                          plan_state   = (plan.length < PredictFuture ? Fixed : ca
                                                                                        >   672                          replan_limit = tiebreak_by_turn ? min(PredictFuture, (pl
                                                                                        >   673                          lambda_getter = current_game.map.collected_lambda < cand
                                                                                        >   674                  }
                                                                                        >   675          }
                                                                                        >   676  
                                                                                        >   677          Tuple!(SubSolver, string, int) try_plan(in Game g, string prefix, int co
                                                                                        >   678          {
                                                                                        >   679                  if(consider_length<=0) consider_length = 2;
                                                                                        >   680  
                                                                                        >   681                  SubSolver s = new SubSolver(g);
                                                                                        >   682                  foreach(char c; prefix)
                                                                                        >   683                          s.force(c);
                                                                                        >   684                  string log;
                                                                                        >   685                  int state = Tentative;
                                                                                        >   686                  while(!s.g.cleared && !s.g.dead && log.length<=consider_length) 
                                                                                        >   687                          char c = s.single_step();
                                                                                        >   688                          if( c == 'A' ) {
                                                                                        >   689                                  state = Tentative_Stuck;
                                                                                        >   690                                  break;
                                                                                        >   691                          }
                                                                                        >   692                          log ~= c;
                                                                                        >   693                  }
                                                                                        >   694                  if(s.g.cleared) state = Fixed;
                                                                                        >   695                  else if(s.g.dead) state = Tentative_Stuck;
                                                                                        >   696                  return tuple(s, log, state);
                                                                                        >   697          }
                                                                                        >   698  }
                                                                                        >   699  
                                                                                        >   700  ///
                                                                                        >   701  /// Solver "Wind": let your rapidity be that of the wind.
                                                                                        >   702  ///
                                                                                        >   703  class 疾如風(bool UP) : Solver
                                                                                        >   704  {
                                                                                        >   705          Game g;
                                                                                        >   706          this(in Game g)
                                                                                        >   707          {
                                                                                        >   708                  this.g = g.clone();
                                                                                        >   709          }
                                                                                        >   710  
                                                                                        >   711          string plan;
                                                                                        >   712  
                                                                                        >   713          char single_step()
                                                                                        >   714          {
                                                                                        >   715                  auto dm = death_move(g);
                                                                                        >   716                  if( plan.empty || dm[0].count(plan[0]) ) {
                                                                                        >   717                          plan = think(g, dm[0]);
                                                                                        >   718                          if( plan.empty )
                                                                                        >   719                                  plan = "W";
                                                                                        >   720                  }
                                                                                        >   721  
                                                                                        >   722                  char c = plan[0];
                                                                                        >   723                  plan = plan[1..$];
                                                                                        >   724  
                                                                                        >   725                  if(c == 'W') {
                                                                                        >   726                          wait_counter++;
                                                                                        >   727                          if(dm[0].count(c) || wait_counter>=3) {
                                                                                        >   728                                  c = 'A';
                                                                                        >   729                                  foreach(char cc; "DLRU")
                                                                                        >   730                                          if(dm[0].count(cc) == 0)
                                                                                        >   731                                                  c = cc;
                                                                                        >   732                          }
                                                                                        >   733                          if(wait_counter > 20)
                                                                                        >   734                                  c = 'A';
                                                                                        >   735                  } else {
                                                                                        >   736                          wait_counter = 0;
                                                                                        >   737                  }
                                                                                        >   738                  if(c != 'A')
                                                                                        >   739                          g.command(c);
                                                                                        >   740                  return c;
                                                                                        >   741          }
                                                                                        >   742  
                                                                                        >   743          void force(char c)
                                                                                        >   744          {
                                                                                        >   745                  if(c != 'A')
                                                                                        >   746                          g.command(c);
                                                                                        >   747          }
                                                                                        >   748  
                                                                                        >   749          int wait_counter = 0;
                                                                                        >   750  
                                                                                        >   751          string think(in Game g, string death)
                                                                                        >   752          {
                                                                                        >   753                  auto Q = new Queue!(Tuple!(Pos,Pos));
                                                                                        >   754                  Q.push(tuple(g.map.robot.clone(), g.map.robot.clone()), 0);
                                                                                        >   755                  Pos[][] V = new Pos[][](g.map.H+2, g.map.W+2);
                                                                                        >   756                  while(!Q.empty) {
                                                                                        >   757                          auto tup = Q.pop();
                                                                                        >   758                          Pos  p    = tup[0][0];
                                                                                        >   759                          Pos  prev = tup[0][1];
                                                                                        >   760                          int  dist = tup[1];
                                                                                        >   761                          if(V[p.y][p.x])
                                                                                        >   762                                  continue;
                                                                                        >   763                          V[p.y][p.x] = prev;
                                                                                        >   764                          if(g.map[p]=='\\' || g.map[p]=='O')
                                                                                        >   765                          {
                                                                                        >   766                                  char[] trace;
                                                                                        >   767                                  for(;;) {
                                                                                        >   768                                          Pos q = V[p.y][p.x];
                                                                                        >   769                                          trace ~= (q.y==p.y ? (q.x<p.x ? 'R' : 'L
                                                                                        >   770                                                               (q.y<p.y ? 'U' : 'D
                                                                                        >   771                                          if(q == g.map.robot) {
                                                                                        >   772                                                  reverse(trace);
                                                                                        >   773                                                  return trace.idup;
                                                                                        >   774                                          }
                                                                                        >   775                                          p=q;
                                                                                        >   776                                  }
                                                                                        >   777                          }
                                                                                        >   778  
                                                                                        >   779                          int[4] dy=UP ? [+1,0,0,-1]       : [-1,+1,0,0];
                                                                                        >   780                          int[4] dx=UP ? [0,-1,+1,0]       : [0,0,-1,+1];
                                                                                        >   781                          char[] ds=UP ? ['U','L','R','D'] : ['D','U','L','R'];
                                                                                        >   782                          for(int i=0; i<4; ++i) {
                                                                                        >   783                                  if(g.map.robot==p && death.count(ds[i]))
                                                                                        >   784                                          continue;
                                                                                        >   785                                  int y=p.y+dy[i], x=p.x+dx[i];
                                                                                        >   786                                  if((g.map[y,x]==' '||g.map[y,x]=='\\'||g.map[y,x
                                                                                        >   787                                          Q.push(tuple(new Pos(y,x),p), dist+1);
                                                                                        >   788                                  }
                                                                                        >   789                          }
                                                                                        >   790                  }
                                                                                        >   791  
                                                                                        >   792                  return "";
                                                                                        >   793          }
                                                                                        >   794  }
                                                                                        >   795  
                                                                                        >   796  class Switcher
                                                                                        >   797  {
                                                                                        >   798          this(in Game g)
                                                                                        >   799          {
                                                                                        >   800                  if(g.map.W*g.map.H <= 1600)
                                                                                        >   801                          sub_solver = new 侵掠如火!(徐如林)(g);
                                                                                        >   802                  else
                                                                                        >   803                          sub_solver = new 侵掠如火!(疾如風!(true))(g);
  387          }                                                                            804          }
                                                                                        >   805          char single_step() { return sub_solver.single_step(); }
                                                                                        >   806          void force(char c) { return sub_solver.force(c); }
                                                                                        >   807  
                                                                                        >   808          private Solver sub_solver;
  388  }                                                                                    809  }
  389                                                                                       810  
                                                                                        >   811  alias 侵掠如火!(疾如風!(false)) FastSolver;
                                                                                        >   812  
  390  alias Solver_2!(Solver_1) MainSolver;                                            |   813  alias Switcher MainSolver;
  391  //alias Solver_1 MainSolver;                                                     |   814  //alias 徐如林 MainSolver;

Modified src/util.d from [b76be1f6ad977d56] to [41ba420d0c49ce8d].

    4  public import std.range;                                                               4  public import std.range;
    5  public import std.stdio;                                                               5  public import std.stdio;
    6  public import std.string;                                                              6  public import std.string;
    7  public import std.typecons;                                                            7  public import std.typecons;
    8  public import std.math;                                                                8  public import std.math;
    9  import std.c.stdlib;                                                                   9  import std.c.stdlib;
   10                                                                                        10  
   11  T[] erase(T,V)(T[] xs, V y)                                                      <
   12  {                                                                                <
   13          foreach(i,x; xs)                                                         <
   14                  if(x == y)                                                       <
   15                          return xs[0..i]~xs[i+1..$];                              <
   16          return xs;                                                               <
   17  }                                                                                <
   18                                                                                   <
   19  // To avoide the following ICE:                                                       11  // To avoide the following ICE:
   20  //   src\phobos\std\algorithm.d(4552):                                                12  //   src\phobos\std\algorithm.d(4552):
   21  //     Error: function std.algorithm.count!("a == b",string,char).count               13  //     Error: function std.algorithm.count!("a == b",string,char).count
   22  //     compiler error, parameter 'value', bugzilla 2962?                              14  //     compiler error, parameter 'value', bugzilla 2962?
   23  //     Assertion failure: '0' on line 717 in file 'glue.c'                            15  //     Assertion failure: '0' on line 717 in file 'glue.c'
   24  int count(T,V)(T[] a, V v)                                                            16  int count(T,V)(T[] a, V v)
   25  {                                                                                     17  {

Modified submission/lifter from [5103f55f5323fb3f] to [fd8f637022eb131f].

cannot compute difference between binary files