Difference From:

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

To:

[9b6bfcd92c] Made directory-less tgz. (user: kinaba, tags: trunk, main-submission, date: 2012-07-16 11:05:46)

Modified icfp-96533632.tgz from [943329c30072989f] to [6a347db0f936a762].

cannot compute difference between binary files

Modified make-submission from [bd7a911c141ae544] to [8013a88aa62e420a].

    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
                                                                                        >     9  cd submission
    4  tar czf icfp-96533632.tgz submission                                             |    10  tar czf ../icfp-96533632.tgz *

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 [256615d4a896c7e1]

                                                                                        >     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 [521705f028ec7e74].

    1  import util;                                                                           1  import util;
    2                                                                                         2  
    3  ////////////////////////////////////////////////////////////////////////////////       3  ////////////////////////////////////////////////////////////////////////////////
    4                                                                                         4  
                                                                                        >     5  bool is_spacy(char c)
                                                                                        >     6  {
                                                                                        >     7          return c==' ' || c=='.' || c=='R' || c=='!' || c=='\\' || c=='O';
                                                                                        >     8  }
                                                                                        >     9  
                                                                                        >    10  bool is_rocky(char c)
                                                                                        >    11  {
                                                                                        >    12          return c=='*' || c=='@';
                                                                                        >    13  }
                                                                                        >    14  
                                                                                        >    15  bool is_true_space(char c)
                                                                                        >    16  {
                                                                                        >    17          return c==' ';
                                                                                        >    18  }
                                                                                        >    19  
                                                                                        >    20  bool is_trampoline_source(char c)
                                                                                        >    21  {
                                                                                        >    22          return 'A'<=c && c<='I';
                                                                                        >    23  }
                                                                                        >    24  
                                                                                        >    25  bool is_rocklambda(char c)
                                                                                        >    26  {
                                                                                        >    27          return is_rocky(c) || c=='\\';
                                                                                        >    28  }
                                                                                        >    29  
                                                                                        >    30  ////////////////////////////////////////////////////////////////////////////////
                                                                                        >    31  
    5  class Pos                                                                             32  class Pos
    6  {                                                                                     33  {
    7          public immutable int y, x;                                                    34          public immutable int y, x;
    8          mixin DeriveCreate;                                                           35          mixin DeriveCreate;
    9          mixin DeriveCompare;                                                          36          mixin DeriveCompare;
   10          mixin DeriveShow;                                                             37          mixin DeriveShow;
   11          Pos clone() const { return cast(Pos) this; }                                  38          Pos clone() const { return cast(Pos) this; }
   12                                                                                        39  
   13  @property:                                                                       |    40  const @property:
   14          Pos wait()  { return this.clone(); }                                          41          Pos wait()  { return this.clone(); }
   15          Pos up()    { return new Pos(y+1, x); }                                       42          Pos up()    { return new Pos(y+1, x); }
   16          Pos down()  { return new Pos(y-1, x); }                                       43          Pos down()  { return new Pos(y-1, x); }
   17          Pos left()  { return new Pos(y, x-1); }                                       44          Pos left()  { return new Pos(y, x-1); }
   18          Pos right() { return new Pos(y, x+1); }                                       45          Pos right() { return new Pos(y, x+1); }
   19          alias wait  W,w;                                                              46          alias wait  W,w;
   20          alias up    U,u;                                                              47          alias up    U,u;
................................................................................................................................................................................

   37          assert( aa[new Pos(1,2)]==2 );                                                64          assert( aa[new Pos(1,2)]==2 );
   38  }                                                                                     65  }
   39                                                                                        66  
   40  ////////////////////////////////////////////////////////////////////////////////      67  ////////////////////////////////////////////////////////////////////////////////
   41                                                                                        68  
   42  class Water                                                                           69  class Water
   43  {                                                                                     70  {
                                                                                        >    71          mixin DeriveShow;
                                                                                        >    72  
                                                                                        >    73  private:
   44          public immutable int base, pace;                                         |    74          immutable int base, pace;
   45          mixin DeriveCreate;                                                           75          mixin DeriveCreate;
   46          mixin DeriveCompare;                                                     <
   47          mixin DeriveShow;                                                        <
   48          Water clone() const { return cast(Water)this; }                          |    76          Water clone() const { return cast(Water) this; }
   49                                                                                        77  
   50          static load(string[string] params)                                            78          static load(string[string] params)
   51          {                                                                             79          {
   52                  return new Water(params.get("Water",    "0").to!int(),                80                  return new Water(params.get("Water",    "0").to!int(),
   53                                   params.get("Flooding", "0").to!int());               81                                   params.get("Flooding", "0").to!int());
   54          }                                                                             82          }
   55                                                                                        83  
   56          int level(int number_of_update) const                                    |    84          int level(int turn) const
   57          {                                                                             85          {
   58                  return pace ? base+(number_of_update/pace) : base;               |    86                  return pace ? base+(turn/pace) : base;
   59          }                                                                             87          }
   60                                                                                        88  
   61          int until_rise(int number_of_update) const                               |    89          int until_rise(int turn) const
   62          {                                                                             90          {
   63                  return pace ? pace-number_of_update%pace : int.max;              |    91                  return pace ? pace-turn%pace : int.max;
   64          }                                                                             92          }
   65  }                                                                                     93  }
   66                                                                                        94  
   67  unittest                                                                              95  unittest
   68  {                                                                                     96  {
   69          Water w = new Water(1, 3);                                                    97          Water w = new Water(1, 3);
   70          assert( 1 == w.level(0) );                                                    98          assert( 1 == w.level(0) );
................................................................................................................................................................................

   84          assert( 1 == w.level(5) );                                                   112          assert( 1 == w.level(5) );
   85  }                                                                                    113  }
   86                                                                                       114  
   87  ////////////////////////////////////////////////////////////////////////////////     115  ////////////////////////////////////////////////////////////////////////////////
   88                                                                                       116  
   89  class Hige                                                                           117  class Hige
   90  {                                                                                    118  {
   91          public immutable int pace;                                               <
   92          mixin DeriveCreate;                                                      <
   93          mixin DeriveCompare;                                                     <
   94          mixin DeriveShow;                                                            119          mixin DeriveShow;
                                                                                        >   120  
                                                                                        >   121  private:
                                                                                        >   122          immutable int pace;
                                                                                        >   123          mixin DeriveCreate;
   95          Hige clone() const { return cast(Hige)this; }                                124          Hige clone() const { return cast(Hige)this; }
   96                                                                                       125  
   97          static load(string[string] params)                                           126          static load(string[string] params)
   98          {                                                                            127          {
   99                  return new Hige(params.get("Growth", "25").to!int());                128                  return new Hige(params.get("Growth", "25").to!int());
  100          }                                                                            129          }
  101                                                                                       130  
................................................................................................................................................................................

  108          {                                                                            137          {
  109                  return pace ? pace-turn%pace : int.max;                              138                  return pace ? pace-turn%pace : int.max;
  110          }                                                                            139          }
  111  }                                                                                    140  }
  112                                                                                       141  
  113  ////////////////////////////////////////////////////////////////////////////////     142  ////////////////////////////////////////////////////////////////////////////////
  114                                                                                       143  
                                                                                        >   144  class Trampoline
                                                                                        >   145  {
                                                                                        >   146          mixin DeriveShow;
                                                                                        >   147  
                                                                                        >   148  private:
                                                                                        >   149          immutable char[]   target_of_;
                                                                                        >   150          immutable char[][] source_of_;
                                                                                        >   151          immutable Pos[]    position_of_;
                                                                                        >   152          immutable char[]   source_list_;
                                                                                        >   153          immutable char[]   target_list_;
                                                                                        >   154          Trampoline clone() const { return cast(Trampoline) this; }
                                                                                        >   155  
                                                                                        >   156          this(in Map m, char[char] tramparam)
                                                                                        >   157          {
                                                                                        >   158                  auto ta = new char['I'+1];
                                                                                        >   159                  auto sr = new char[]['9'+1];
                                                                                        >   160                  auto po = new Pos[max('I','9')+1];
                                                                                        >   161                  char[] sl, tl;
                                                                                        >   162                  foreach(fr,to; tramparam) {
                                                                                        >   163                          ta[fr]  = to;
                                                                                        >   164                          sr[to] ~= fr;
                                                                                        >   165                  }
                                                                                        >   166                  for(int y=1; y<=m.H; ++y)
                                                                                        >   167                  for(int x=1; x<=m.W; ++x) {
                                                                                        >   168                          char c = m[y,x];
                                                                                        >   169                          if('A'<=c && c<='I') {
                                                                                        >   170                                  sl ~= c;
                                                                                        >   171                                  po[c] = new Pos(y,x);
                                                                                        >   172                          }
                                                                                        >   173                          if('1'<=c && c<='9') {
                                                                                        >   174                                  tl ~= c;
                                                                                        >   175                                  po[c] = new Pos(y,x);
                                                                                        >   176                          }
                                                                                        >   177                  }
                                                                                        >   178                  target_of_ = cast(immutable) ta;
                                                                                        >   179                  source_of_ = cast(immutable) sr;
                                                                                        >   180                  position_of_ = cast(immutable) po;
                                                                                        >   181                  source_list_ = cast(immutable) sl;
                                                                                        >   182                  target_list_ = cast(immutable) tl;
                                                                                        >   183          }
                                                                                        >   184  
                                                                                        >   185  public @property const:
                                                                                        >   186          const(char[]) source_list() { return source_list_; }
                                                                                        >   187          const(char[]) target_list() { return target_list_; }
                                                                                        >   188          const(char[]) source_of(char c) { return source_of_[c]; }
                                                                                        >   189          char target_of(char c) { return target_of_[c]; }
                                                                                        >   190          Pos[] source_pos(char c) {
                                                                                        >   191                  Pos[] ps;
                                                                                        >   192                  foreach(s; source_of(c))
                                                                                        >   193                          ps ~= position_of_[s].clone();
                                                                                        >   194                  return ps;
                                                                                        >   195          }
                                                                                        >   196          Pos target_pos(char c) { return position_of_[target_of_[c]].clone(); }
                                                                                        >   197  }
                                                                                        >   198  
                                                                                        >   199  ////////////////////////////////////////////////////////////////////////////////
                                                                                        >   200  
  115  class Map                                                                            201  class Map
  116  {                                                                                    202  {
  117          mixin DeriveShow;                                                            203          mixin DeriveShow;
  118                                                                                       204  
  119          static Map load(string[] raw_data, string[string] params, char[char] tra <
  120          {                                                                        <
  121                  // TODO: choose optimal representation.                          <
  122                  return new Map(raw_data, params, trampo);                        <
  123          }                                                                        <
  124                                                                                   <
  125          char[][] data;                                                           |   205          private char[][] data;
  126          Pos robot;                                                                   206          Pos robot;
  127          Pos lift;                                                                    207          Pos lift;
  128          int waterproof;                                                          |   208          private int waterproof;
  129          Pos[char] tr_target;                                                     |   209          private int collected_razor;
  130          Pos[][char] tr_source;                                                   |   210          int collected_lambda;
  131          const(Hige) hige;                                                        |   211          int total_lambda;
  132          int razor;                                                               |   212          private bool cleared;
                                                                                        >   213          private Pos[] may_update;
  133                                                                                       214  
  134          Map clone() const { return new Map(this); }                              |   215          private Map clone() const { return new Map(this); }
  135          this(in Map m) {                                                         |   216          private this(in Map m) {
  136                  foreach(s; m.data)                                                   217                  foreach(s; m.data)
  137                          this.data ~= s.dup;                                          218                          this.data ~= s.dup;
  138                  this.robot = m.robot.clone();                                    |   219                  this.robot      = m.robot.clone();
  139                  this.lift = m.lift.clone();                                      |   220                  this.lift       = m.lift.clone();
  140                  this.waterproof = m.waterproof;                                      221                  this.waterproof = m.waterproof;
  141                  this.tr_target = cast(Pos[char])m.tr_target;                     |   222                  this.collected_razor  = m.collected_razor;
  142                  this.tr_source = cast(Pos[][char])m.tr_source;                   |   223                  this.collected_lambda = m.collected_lambda;
  143                  this.hige = m.hige.clone();                                      |   224                  this.total_lambda     = m.total_lambda;
  144                  this.razor = m.razor;                                            |   225                  this.cleared    = m.cleared;
                                                                                        >   226                  this.may_update = (cast(Map)m).may_update.dup;
  145          }                                                                            227          }
  146                                                                                       228  
                                                                                        >   229          const {
                                                                                        >   230                  @property {
                                                                                        >   231                          int H() { return data.length; }
                                                                                        >   232                          int W() { return data[0].length; }
                                                                                        >   233                          int num_razor() { return collected_razor; }
                                                                                        >   234  
                                                                                        >   235                          Pos[] razors()  { return objects('!'); }
                                                                                        >   236                          Pos[] lambdas() { return objects('\\'); }
                                                                                        >   237                  }
                                                                                        >   238  
                                                                                        >   239                  Pos[] objects(char c) {
                                                                                        >   240                          Pos[] ans;
                                                                                        >   241                          for(int y=1; y<=H; ++y)
                                                                                        >   242                          for(int x=1; x<=W; ++x)
                                                                                        >   243                                  if(this[y,x] == c)
                                                                                        >   244                                  ans ~= new Pos(y,x);
                                                                                        >   245                          return ans;
                                                                                        >   246                  }
                                                                                        >   247  
                                                                                        >   248                  char opIndex(int y, int x) {
                                                                                        >   249                          --y, --x;
                                                                                        >   250                          if(y<0||H<=y||x<0||W<=x)
                                                                                        >   251                                  return '#';
                                                                                        >   252                          return data[H-1-y][x];
                                                                                        >   253                  }
                                                                                        >   254  
                                                                                        >   255                  char opIndex(in Pos p) {
                                                                                        >   256                          return this[p.y, p.x];
                                                                                        >   257                  }
                                                                                        >   258          }
                                                                                        >   259  
                                                                                        >   260  private:
  147          this(string[] raw_data, string[string] params, char[char] trampo)            261          this(string[] raw_data, string[string] params, char[char] trampo)
  148          {                                                                            262          {
  149                  int width = 0;                                                       263                  int width = 0;
  150                  foreach(r; raw_data)                                                 264                  foreach(r; raw_data)
  151                          width = max(width, r.length);                                265                          width = max(width, r.length);
  152                  foreach(r; raw_data) {                                               266                  foreach(r; raw_data) {
  153                          this.data ~= r.dup;                                          267                          this.data ~= r.dup;
................................................................................................................................................................................

  157                                                                                       271  
  158                  for(int y=1; y<=H; ++y)                                              272                  for(int y=1; y<=H; ++y)
  159                  for(int x=1; x<=W; ++x) {                                            273                  for(int x=1; x<=W; ++x) {
  160                          if(this[y,x] == 'R')                                         274                          if(this[y,x] == 'R')
  161                                  this.robot = new Pos(y,x);                           275                                  this.robot = new Pos(y,x);
  162                          if(this[y,x] == 'L' || this[y,x] == 'O')                     276                          if(this[y,x] == 'L' || this[y,x] == 'O')
  163                                  this.lift = new Pos(y,x);                            277                                  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) {                                        <
                                                                                        >   278                          if(this[y,x] == '\\' || this[y,x] == '@')
                                                                                        >   279                                  total_lambda++;
  169                          char c = this[y,x];                                      |   280                          if(is_rocky(this[y,x]))
  170                          if('1'<=c && c<='9' || 'A'<=c&&c<='I')                   <
  171                                  tr_pos[c] = new Pos(y,x);                        |   281                                  may_update ~= new Pos(y,x);
  172                  }                                                                    282                  }
  173                                                                                       283  
  174                  this.waterproof = params.get("Waterproof", "5").to!int();        |   284                  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();                 |   285                  this.collected_razor = params.get("Razors", "0").to!int();
  183          }                                                                        <
  184                                                                                   <
  185          const @property {                                                        <
  186                  int H() { return data.length; }                                  <
  187                  int W() { return data[0].length; }                               <
  188          }                                                                        <
  189                                                                                   <
  190          const {                                                                  <
  191                  char opIndex(int y, int x)                                       <
  192                  {                                                                <
  193                          // Adjust coordinate to the spec. bottom-left is (1,1).  <
  194                          --y, --x;                                                <
  195                          if(y<0||H<=y||x<0||W<=x)                                 <
  196                                  return '#';                                      <
  197                          return data[H-1-y][x];                                   <
  198                  }                                                                <
  199                                                                                   <
  200                  char opIndex(in Pos p)                                           <
  201                  {                                                                <
  202                          return this[p.y, p.x];                                   <
  203                  }                                                                <
  204          }                                                                            286          }
  205                                                                                       287  
  206          void opIndexAssign(char c, int y, int x)                                     288          void opIndexAssign(char c, int y, int x)
  207          {                                                                            289          {
  208                  // Adjust coordinate to the spec. bottom-left is (1,1).          <
  209                  --y, --x;                                                            290                  --y, --x;
  210                  if(y<0||H<=y||x<0||W<=x)                                             291                  if(y<0||H<=y||x<0||W<=x)
  211                          return;                                                      292                          return;
  212                  data[H-1-y][x] = c;                                                  293                  data[H-1-y][x] = c;
  213          }                                                                            294          }
  214                                                                                       295  
  215          void opIndexAssign(char c, in Pos p)                                         296          void opIndexAssign(char c, in Pos p)
  216          {                                                                            297          {
  217                  this[p.y, p.x] = c;                                                  298                  this[p.y, p.x] = c;
  218          }                                                                            299          }
  219                                                                                       300  
  220          Pos[] objects(char c) const {                                            |   301          bool command(char c, int turn, bool hige_day, in Trampoline tr)
  221                  Pos[] ans;                                                       <
  222                  for(int y=1; y<=H; ++y)                                          <
  223                  for(int x=1; x<=W; ++x)                                          <
  224                          if(this[y,x] == c)                                       <
  225                                  ans ~= new Pos(y,x);                             <
  226                  return ans;                                                      <
  227          }                                                                        <
  228                                                                                   <
  229          Pos[] razors() const { return objects('!'); }                            <
  230          Pos[] lambdas() const { return objects('\\'); }                          <
  231                                                                                   <
  232          bool cleared() const                                                     <
  233          {                                                                            302          {
  234                  for(int y=1; y<=H; ++y)                                          |   303                  switch(c)
  235                  for(int x=1; x<=W; ++x)                                          <
                                                                                        >   304                  {
  236                          if(this[y,x] == 'L' || this[y,x] == 'O')                 |   305                  case 'R': return move( 0, +1, hige_day, tr);
  237                                  return false;                                    |   306                  case 'L': return move( 0, -1, hige_day, tr);
  238                  return true;                                                     |   307                  case 'U': return move(+1,  0, hige_day, tr);
                                                                                        >   308                  case 'D': return move(-1,  0, hige_day, tr);
                                                                                        >   309                  case 'W': return move( 0,  0, hige_day, tr);
                                                                                        >   310                  case 'S': return use_razor(hige_day);
                                                                                        >   311                  default:  assert(false);
                                                                                        >   312                  }
  239          }                                                                            313          }
  240                                                                                       314  
  241          Tuple!(int,bool) command(char c, int turn)                               |   315          bool use_razor(bool hige_day)
  242          {                                                                            316          {
  243                  assert( this[robot] == 'R' );                                    |   317                  if(collected_razor > 0)
  244                  if(c=='R') return move( 0, +1, turn);                            <
  245                  if(c=='L') return move( 0, -1, turn);                            <
  246                  if(c=='U') return move(+1,  0, turn);                            <
  247                  if(c=='D') return move(-1,  0, turn);                            <
  248                  if(c=='W') return move( 0,  0, turn);                            <
  249                  if(c=='S') return use_razor(turn);                               <
  250                  assert(false);                                                   <
  251          }                                                                        <
  252                                                                                   |   318                  {
  253          Tuple!(int, bool) use_razor(int turn)                                    <
  254          {                                                                        <
  255                  if(razor) {                                                      <
  256                          razor--;                                                 |   319                          collected_razor--;
  257                          for(int dy=-1; dy<=+1; ++dy)                                 320                          for(int dy=-1; dy<=+1; ++dy)
  258                          for(int dx=-1; dx<=+1; ++dx)                                 321                          for(int dx=-1; dx<=+1; ++dx)
  259                                  if(this[robot.y+dy,robot.x+dx] == 'W')               322                                  if(this[robot.y+dy,robot.x+dx] == 'W')
  260                                          this[robot.y+dy,robot.x+dx] = ' ';       |   323                                          emptify(new Pos(robot.y+dy,robot.x+dx));
  261                  }                                                                    324                  }
                                                                                        >   325                  return update(hige_day);
                                                                                        >   326          }
  262                                                                                       327  
  263                  bool dead = update(turn);                                        |   328          // Register a position that may become empty in the last turn.
  264                  return tuple(0,dead);                                            |   329          void emptify(Pos p)
                                                                                        >   330          {
                                                                                        >   331                  this[p] = ' ';
                                                                                        >   332                  for(int dy=0;  dy<=+1; ++dy)
                                                                                        >   333                  for(int dx=-1; dx<=+1; ++dx)
                                                                                        >   334                          may_update ~= new Pos(p.y+dy, p.x+dx);
  265          }                                                                            335          }
  266                                                                                       336  
  267          Tuple!(int, bool) move(int dy, int dx, int turn)                         |   337          bool move(int dy, int dx, bool hige_day, in Trampoline tr)
  268          {                                                                            338          {
  269                  int y = robot.y;                                                 |   339                  Pos next = new Pos(robot.y+dy, robot.x+dx);
  270                  int x = robot.x;                                                 |   340                  int y=robot.y, x=robot.x;
  271                  int lambda = 0;                                                  <
                                                                                        >   341  
  272                  if( '\\' == this[y+dy,x+dx] )                                    |   342                  if( '\\' == this[next] ) collected_lambda++;
  273                          lambda++;                                                |   343                  if(  '!' == this[next] ) collected_razor++;
  274                  if( '!' == this[y+dy,x+dx] )                                     |   344                  if( 'O'  == this[next] ) cleared = true;
  275                          razor++;                                                 <
                                                                                        >   345  
  276                  if( " \\!.O".count(this[y+dy,x+dx])==1 ) {                       |   346                  if( is_spacy(this[next]) )
  277                          this[y,x]=' ';                                           <
                                                                                        >   347                  {
  278                          this[y+dy,x+dx]='R';                                     |   348                          emptify(robot);
  279                          robot = new Pos(y+dy,x+dx);                              |   349                          robot = next;
                                                                                        >   350                          this[next] = 'R';
                                                                                        >   351                  }
  280                  } else if(dy==0 && '*'==this[y+dy,x+dx] && ' '==this[y+dy*2,x+dx |   352                  else if(dy==0 && is_rocky(this[next]) && ' '==this[y+dy*2,x+dx*2
  281                          this[y,x]=' ';                                           <
  282                          this[y+dy,x+dx]='R';                                     <
                                                                                        >   353                  {
                                                                                        >   354                          char rock  = this[next];
                                                                                        >   355                          emptify(robot);
                                                                                        >   356                          robot = next;
                                                                                        >   357                          this[next]          = 'R';
  283                          this[y+dy*2,x+dx*2]='*';                                 |   358                          this[y+dy*2,x+dx*2] = rock;
  284                          robot = new Pos(y+dy,x+dx);                              |   359                          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') {        <
  286                          this[y,x]=' ';                                           <
  287                          Pos tp = tr_target[this[y+dy,x+dx]];                     <
                                                                                        >   360                  }
                                                                                        >   361                  else if(is_trampoline_source(this[next]))
                                                                                        >   362                  {
                                                                                        >   363                          emptify(robot);
                                                                                        >   364                          Pos tp = tr.target_pos(this[next]);
  288                          foreach(p; tr_source[this[tp]])                          |   365                          foreach(p; tr.source_pos(this[tp]))
  289                                  this[p] = ' ';                                   <
                                                                                        >   366                                  emptify(p);
  290                          this[tp] = 'R';                                              367                          this[tp] = 'R';
  291                          robot = tp;                                              |   368                          robot    = tp;
  292                  }                                                                    369                  }
  293                  bool dead = update(turn);                                        |   370                  return update(hige_day);
  294                  return tuple(lambda,dead);                                       <
  295          }                                                                            371          }
  296                                                                                       372  
  297          bool update(int turn)                                                    |   373          bool update(bool hige_day)
  298          {                                                                            374          {
                                                                                        >   375                  // Write after all the updates are processed.
                                                                                        >   376                  Tuple!(int,int,char)[] write_buffer;
                                                                                        >   377                  void write(int y, int x, char c) { write_buffer ~= tuple(y,x,c);
                                                                                        >   378                  void writep(Pos p, char c) { write_buffer ~= tuple(0+p.y,0+p.x,c
                                                                                        >   379                  scope(exit) {
                                                                                        >   380                          may_update.length = 0;
                                                                                        >   381                          foreach(wr; write_buffer) {
                                                                                        >   382                                  this[wr[0],wr[1]] = wr[2];
                                                                                        >   383                                  if(is_rocky(wr[2]))
                                                                                        >   384                                          may_update ~= new Pos(wr[0],wr[1]);
                                                                                        >   385                                  if(wr[2]==' ')
                                                                                        >   386                                          emptify(new Pos(wr[0], wr[1]));
                                                                                        >   387                          }
                                                                                        >   388                  }
                                                                                        >   389  
                                                                                        >   390                  if(collected_lambda == total_lambda)
                                                                                        >   391                          if(this[lift]=='L')
                                                                                        >   392                                  this[lift] = 'O';
                                                                                        >   393  
  299                  bool dead = false;                                                   394                  bool dead = false;
                                                                                        >   395                  if( hige_day ) {
                                                                                        >   396                          for(int y=1; y<=H; ++y)
                                                                                        >   397                          for(int x=1; x<=W; ++x)
                                                                                        >   398                                  if(this[y,x]=='W')
                                                                                        >   399                                          may_update ~= new Pos(y,x);
                                                                                        >   400                  }
  300                                                                                       401  
  301                  char[][] next;                                                   |   402                  sort(may_update);
  302                  foreach(y,s; data)                                               |   403                  foreach(p; may_update) {
  303                          next ~= s.dup;                                           |   404                          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);                                    <
                                                                                        >   405                          char rock = this[p];
  315                          if(this[p]=='*') {                                       |   406                          if(is_rocky(this[p])) {
  316                                  if(this[p.D]==' ') {                                 407                                  if(this[p.D]==' ') {
  317                                          access(p)  =' ';                         |   408                                          writep(p, ' ');
  318                                          access(p.D)='*';                         |   409                                          writep(p.D, (rock=='@'&&this[p.D.D]!=' '
  319                                          if(robot == p.D.D)                           410                                          if(robot == p.D.D)
  320                                                  dead=true;                           411                                                  dead=true;
  321                                  }                                                    412                                  }
  322                                  else if((this[p.D]=='*' || this[p.D]=='\\') && t |   413                                  else if((is_rocky(this[p.D]) || this[p.D]=='\\')
  323                                          access(p)=' ';                           |   414                                          writep(p, ' ');
  324                                          access(p.R.D)='*';                       |   415                                          writep(p.R.D,(rock=='@'&&this[p.R.D.D]!=
  325                                          if(robot == p.R.D.D)                         416                                          if(robot == p.R.D.D)
  326                                                  dead=true;                           417                                                  dead=true;
  327                                  }                                                    418                                  }
  328                                  else if(this[p.D]=='*' && this[p.L]==' ' && this |   419                                  else if(is_rocky(this[p.D]) && this[p.L]==' ' &&
  329                                          access(p)=' ';                           |   420                                          writep(p, ' ');
  330                                          access(p.L.D)='*';                       |   421                                          writep(p.L.D, (rock=='@'&&this[p.L.D.D]!
  331                                          if(robot == p.L.D.D)                         422                                          if(robot == p.L.D.D)
  332                                                  dead=true;                           423                                                  dead=true;
  333                                  }                                                    424                                  }
  334                          }                                                            425                          }
  335                          else if(this[p]=='L') {                                  <
  336                                  if(!lambda)                                      <
  337                                          access(p) = 'O';                         <
  338                          }                                                        <
  339                          else if(this[p]=='W') {                                      426                          else if(this[p]=='W') {
  340                                  if( hige.is_growing_turn(turn) )                 |   427                                  if(hige_day) {
  341                                          for(int dy=-1; dy<=+1; ++dy)                 428                                          for(int dy=-1; dy<=+1; ++dy)
  342                                          for(int dx=-1; dx<=+1; ++dx)                 429                                          for(int dx=-1; dx<=+1; ++dx)
  343                                                  if(this[p.y+dy,p.x+dx] == ' ')   |   430                                                  if(this[p.y+dy,p.x+dx] == ' ') {
  344                                                          access(new Pos(p.y+dy,p. |   431                                                          write(p.y+dy,p.x+dx,'W')
                                                                                        >   432                                                          if(robot.y==p.y+dy-1 && 
                                                                                        >   433                                                                  dead = false; //
  345                          }                                                        |   434                                                  }
  346                  }                                                                |   435                                  }
  347                  data = next;                                                     <
  348                  return dead;                                                     <
  349          }                                                                        <
  350  }                                                                                <
  351                                                                                   <
  352  //////////////////////////////////////////////////////////////////////////////// <
  353                                                                                   <
  354  class Game                                                                       <
  355  {                                                                                <
  356  public:                                                                          <
  357          this(File input)                                                         <
  358          {                                                                        <
  359                  // Read map data                                                 <
  360                  string[] map_data_lines;                                         <
  361                  for(string line; !(line=input.readln().chomp()).empty; )         <
  362                          map_data_lines ~= line;                                  <
  363                                                                                   <
  364                  // H*W                                                           <
  365                  H_ = map_data_lines.length;                                      <
  366                  W_ = 0;                                                          <
  367                  foreach(mdl; map_data_lines)                                     <
  368                          W_ = max(W_, mdl.length);                                <
  369                                                                                   <
  370                  // Copy to modifiable buffer and adjust coordinates.             <
  371                  raw_data_ = new char[][H_+1];                                    <
  372                  foreach(i,mdl; map_data_lines) {                                 <
  373                          char[] buf = new char[mdl.length+1];                     <
  374                          buf[0] = '#';                                            <
  375                          buf[1..$] = mdl[];                                       <
  376                          raw_data_[H_-i] = buf;                                   <
  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                          }                                                            436                          }
  420                  }                                                                    437                  }
  421                                                                                       438  
  422                  // Read other parameters                                         |   439                  return dead;
  423                  for(string line; !(line=input.readln()).empty; )                 <
                                                                                        >   440          }
                                                                                        >   441  }
  424                  {                                                                |   442  
  425                          string[] ss = line.split();                              <
  426                          if( ss.length == 2 )                                     <
  427                                  switch(ss[0])                                    <
                                                                                        >   443  ////////////////////////////////////////////////////////////////////////////////
  428                                  {                                                |   444  
  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                                  }                                                <
  436                          if( ss.length == 4 && ss[0]=="Trampoline" && ss[2]=="tar <
                                                                                        >   445  class Game
  437                          {                                                        |   446  {
  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;                       <
                                                                                        >   447          mixin DeriveShow;
  442                          }                                                        |   448  
                                                                                        >   449          private {
                                                                                        >   450                  Map map_;
                                                                                        >   451                  Water water_;
                                                                                        >   452                  Hige hige_;
                                                                                        >   453                  Trampoline tr_;
                                                                                        >   454                  int  turn = 0;
                                                                                        >   455                  bool dead_ = false;
                                                                                        >   456                  int  under_water = 0;
  443                  }                                                                |   457          }
  444                                                                                       458  
  445                  air_left_ = max_air_;                                            |   459          Game clone() const { return new Game(this); }
                                                                                        >   460          this(in Game g) {
                                                                                        >   461                  map_   = g.map_.clone();
                                                                                        >   462                  water_ = g.water_.clone();
                                                                                        >   463                  hige_  = g.hige_.clone();
                                                                                        >   464                  tr_    = g.tr_.clone();
                                                                                        >   465                  turn   = g.turn;
                                                                                        >   466                  dead_  = g.dead_;
                                                                                        >   467                  under_water = g.under_water;
  446          }                                                                            468          }
  447                                                                                       469  
  448          @property const {                                                        |   470          this(File input)
  449                  int H() { return H_; }                                           <
                                                                                        >   471          {
  450                  int W() { return W_; }                                           |   472                  string[]       raw_data;
  451                  char trampoline(char c) { return (c in trampoline_ ? trampoline_ |   473                  string[string] params;
  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                          }                                                        |   474  
  458                          return pp;                                               <
                                                                                        >   475                  // Raw map data; read until empty line.
                                                                                        >   476                  for(string line; !(line=input.readln().chomp()).empty; )
                                                                                        >   477                          raw_data ~= line;
  459                  }                                                                |   478  
                                                                                        >   479                  // Additional commands; read until EOF.
                                                                                        >   480                  char[char] trampo;
                                                                                        >   481                  for(string line; !(line=input.readln()).empty; ) {
  460                  int water_level() {                                              |   482                          string[] ss = line.split();
  461                          return water_pace_ ? water_base_ + turn_/water_pace_ : w |   483                          if( ss.length == 2 )
  462                  }                                                                <
                                                                                        >   484                                  params[ss[0]] = ss[1];
  463                  int water_until_rise() {                                         |   485                          if( ss.length == 4 && ss[0]=="Trampoline" && ss[2]=="tar
  464                          return water_pace_ ? water_pace_ - turn_%water_pace_ : i |   486                                  trampo[ss[1][0]] = ss[3][0];
  465                  }                                                                    487                  }
  466                  int hige_until_rise() {                                          <
  467                          return hige_pace_ ? hige_pace_ - turn_%hige_pace_ : int. <
  468                  }                                                                |   488  
                                                                                        >   489                  this.map_   = new Map(raw_data, params, trampo);
                                                                                        >   490                  this.water_ = Water.load(params);
  469                  bool is_hige_turn() {                                            |   491                  this.hige_  = Hige.load(params);
  470                          return hige_pace_ ? turn_%hige_pace_ == hige_pace_-1 : f |   492                  this.tr_    = new Trampoline(this.map, trampo);
  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          }                                                                            493          }
  503                                                                                       494  
  504  public:                                                                          <
  505          void command(char c)                                                         495          void command(char c)
  506          {                                                                            496          {
                                                                                        >   497                  assert(c != 'A');
  507                  if(dead || cleared)                                                  498                  if(dead || cleared)
  508                          return;                                                      499                          return;
  509                                                                                       500  
  510                  if(c == 'U') command_move(+1, 0);                                |   501                  // TODO: clarify the event order
  511                  if(c == 'D') command_move(-1, 0);                                |   502                  bool dead_now = map_.command(c, turn, hige.is_growing_turn(turn)
  512                  if(c == 'L') command_move(0, -1);                                |   503                  if( dead_now )
  513                  if(c == 'R') command_move(0, +1);                                |   504                          dead_ = true;
  514                  if(c == 'S') use_razor();                                        <
  515                  if(c == 'W') {}                                                  <
  516                                                                                   <
  517                  if(!cleared)                                                     |   505                  if(!map.cleared) {
  518                  {                                                                <
  519                          map_update();                                            <
                                                                                        >   506                          if( map.robot.y <= water_level )
  520                          water_update();                                          |   507                                  ++under_water;
                                                                                        >   508                          else
                                                                                        >   509                                  under_water = 0;
                                                                                        >   510                          if( under_water > map.waterproof )
                                                                                        >   511                                  dead_ = true;
  521                  }                                                                    512                  }
  522                  turn_ ++;                                                        |   513                  turn += 1;
  523          }                                                                            514          }
  524                                                                                       515  
  525          void command_move(int dy, int dx)                                        |   516  @property const:
  526          {                                                                        |   517          long score()           { return map.collected_lambda*(dead?25L:cleared?7
  527                  int y = robot_pos_.y, x = robot_pos_.x;                          <
  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);                               <
  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;                                                  <
  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          }                                                                        <
  625                                                                                   <
  626          void map_update()                                                        <
  627          {                                                                        <
  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() )                              |   518          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;                                                       <
                                                                                        >   519          int water_until_rise() { return water.until_rise(turn); }
                                                                                        >   520          int hige_until_rise()  { return hige.until_rise(turn); }
                                                                                        >   521          int hp()               { return map.waterproof - under_water; }
  782          bool cleared_ = false;                                                   |   522          bool cleared()         { return map.cleared; }
  783          bool dead_    = false;                                                   <
  784          bool[Pos] may_update_;                                                   <
                                                                                        >   523          bool dead()            { return dead_; }
                                                                                        >   524          const(Map)        map()   { return map_; }
                                                                                        >   525          const(Water)      water() { return water_; }
                                                                                        >   526          const(Hige)       hige()  { return hige_; }
                                                                                        >   527          const(Trampoline) tr()    { return tr_; }
  785  }                                                                                    528  }

Modified src/gui.d from [e84cacd6262f93a7] to [91ff36ba7e144853].

    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                  }
                                                                                        >    27                  this.startPosition = FormStartPosition.CENTER_SCREEN;
   32                  Application.run(this);                                                28                  Application.run(this);
   33          }                                                                             29          }
   34                                                                                        30  
   35          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)
   36          {                                                                             32          {
   37                  draw(g);                                                              33                  draw(g);
   38          }                                                                             34          }
   39                                                                                        35  
   40  private:                                                                              36  private:
   41          int cell;                                                                <
   42                                                                                   <
   43          void setup_size(int W, int H)                                                 37          void setup_size(int W, int H)
   44          {                                                                             38          {
   45                  this.formBorderStyle = FormBorderStyle.FIXED_DIALOG;                  39                  this.formBorderStyle = FormBorderStyle.FIXED_DIALOG;
   46                  this.maximizeBox = false;                                             40                  this.maximizeBox = false;
   47                  this.minimizeBox = false;                                             41                  this.minimizeBox = false;
   48                  this.cell = min(1024/W, 640/H);                                       42                  this.cell = min(1024/W, 640/H);
   49                  this.clientSize = Size(W*cell, H*cell);                               43                  this.clientSize = Size(W*cell, H*cell);
   50          }                                                                             44          }
   51                                                                                        45  
                                                                                        >    46          int          cell;
   52          Font         font;                                                            47          Font         font;
   53          Color[char]  colors;                                                          48          Color[char]  colors;
   54          string[char] render;                                                          49          string[char] render;
   55          Graphics     graphicContext;                                                  50          Graphics     graphicContext;
   56                                                                                        51  
   57          void setup_resources(in Game g)                                               52          void setup_resources(in Game g)
   58          {                                                                             53          {
   59                  this.graphicContext = new MemoryGraphics(this.clientSize.width,       54                  this.graphicContext = new MemoryGraphics(this.clientSize.width, 
   60                  this.setStyle(ControlStyles.OPAQUE, true);                            55                  this.setStyle(ControlStyles.OPAQUE, true);
   61                  this.font = new Font("MS Gothic", cell-2, GraphicsUnit.PIXEL);        56                  this.font = new Font("MS Gothic", cell-2, GraphicsUnit.PIXEL);
   62                  this.backColor = Color(255,255,255);                                  57                  this.backColor = Color(255,255,255);
   63                  this.colors['#'] =                                                    58                  this.colors['#'] =
   64                  this.colors['.'] = Color(255,191,127);                                59                  this.colors['.'] = Color(255,191,127);
   65                  this.colors['*'] = Color(255,127,127);                           |    60                  this.colors['*'] =
                                                                                        >    61                  this.colors['@'] = Color(255,127,127);
   66                  this.colors['R'] = Color(128,128,0);                                  62                  this.colors['R'] = Color(128,128,0);
                                                                                        >    63                  this.colors['r'] = Color(100,128,255);
   67                  this.colors['d'] = Color(255,0,0);                                    64                  this.colors['d'] = Color(255,0,0);
   68                  this.colors['\\'] =                                                   65                  this.colors['\\'] =
   69                  this.colors['L'] =                                                    66                  this.colors['L'] =
   70                  this.colors['O'] = Color(127,255,127);                                67                  this.colors['O'] = Color(127,255,127);
   71                  this.colors['w'] = Color(204,229,255);                                68                  this.colors['w'] = Color(204,229,255);
   72                  this.colors['W'] =                                                    69                  this.colors['W'] =
   73                  this.colors['!'] = Color(159,159,159);                                70                  this.colors['!'] = Color(159,159,159);
   74                  foreach(char c; 'A'..'J') this.colors[c] = Color(142,142,255);        71                  foreach(char c; 'A'..'J') this.colors[c] = Color(142,142,255);
   75                  foreach(char c; '1'..':') this.colors[c] = Color(255,142,255);        72                  foreach(char c; '1'..':') this.colors[c] = Color(255,142,255);
   76                  this.render['#'] = "■";                                               73                  this.render['#'] = "■";
   77                  this.render['*'] = "✹";                                               74                  this.render['*'] = "✹";
                                                                                        >    75                  this.render['@'] = "❁";
   78                  this.render['.'] = "♒";                                               76                  this.render['.'] = "♒";
   79                  this.render['\\'] = "λ";                                              77                  this.render['\\'] = "λ";
   80                  this.render['R'] = "☃";                                               78                  this.render['R'] = "☃";
                                                                                        >    79                  this.render['r'] = "☃";
   81                  this.render['d'] = "☠";                                               80                  this.render['d'] = "☠";
   82                  this.render['L'] = "☒";                                               81                  this.render['L'] = "☒";
   83                  this.render['O'] = "☐";                                               82                  this.render['O'] = "☐";
   84                  this.render['W'] = "ꔣ";                                               83                  this.render['W'] = "ꔣ";
   85                  this.render['!'] = "✄";                                               84                  this.render['!'] = "✄";
                                                                                        >    85                  foreach(char c; g.tr.source_list)
   86                  foreach(char c; 'A'..'J') this.render[c] = [cast(dchar)('☢'+g.tr |    86                          this.render[c] = [cast(dchar)('☢'+g.tr.target_of(c)-'1')
                                                                                        >    87                  foreach(char c; g.tr.target_list)
   87                  foreach(char c; '1'..':') this.render[c] = [cast(dchar)('☢'+c-'1 |    88                          this.render[c] = [cast(dchar)('☢'+c-'1')].to!string();
   88                  this.paint ~= (Control c, PaintEventArgs ev) {                        89                  this.paint ~= (Control c, PaintEventArgs ev) {
   89                          graphicContext.copyTo(ev.graphics, Rect(0,0,this.clientS      90                          graphicContext.copyTo(ev.graphics, Rect(0,0,this.clientS
   90                  };                                                                    91                  };
   91          }                                                                             92          }
   92                                                                                        93  
   93          void draw(in Game g)                                                          94          void draw(in Game g)
   94          {                                                                             95          {
................................................................................................................................................................................

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

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 [a342d9597f1d9525].

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

   30                                                                                       131  
   31          void force(char c)                                                           132          void force(char c)
   32          {                                                                            133          {
   33                  if(c != 'A')                                                         134                  if(c != 'A')
   34                          g.command(c);                                                135                          g.command(c);
   35          }                                                                            136          }
   36                                                                                       137  
   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;                                                      138          Tuple!(Pos, int)[] log;
   55          bool[][] forbidden_cell;                                                     139          bool[][] forbidden_cell;
   56                                                                                       140  
   57          char act(const(Game) g, string death, int breath)                            141          char act(const(Game) g, string death, int breath)
   58          {                                                                            142          {
                                                                                        >   143                  foreach(char c; "UDLR")
                                                                                        >   144                          if( death.count(c)==0 && is_one_way_load(g,c) )
                                                                                        >   145                                  return c;
                                                                                        >   146  
   59                  const Pos    ro = g.robot;                                       |   147                  const Pos    ro = g.map.robot;
   60                  const Pos    li = g.lift;                                        |   148                  const Pos    li = g.map.lift;
   61                  Pos[] la = g.lambdas();                                          |   149                  Pos[] la = g.map.lambdas();
   62                  sort!((Pos a,Pos b){                                                 150                  sort!((Pos a,Pos b){
   63                          int ad=abs(a.y-li.y)+abs(a.x-li.x);                          151                          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);                          152                          int bd=abs(b.y-li.y)+abs(b.x-li.x);
   65                          return ad>bd;;                                               153                          return ad>bd;;
   66                  })(la);                                                              154                  })(la);
   67                  Pos[] ra = g.razors();                                           |   155                  Pos[] ra = g.map.razors();
   68                  const(Pos)[] hi = g.higes();                                     |   156                  const(Pos)[] hi = g.map.objects('W');
   69                                                                                       157  
   70                  Tuple!(char,int)[] cand;                                             158                  Tuple!(char,int)[] cand;
   71                  char c = 'W';                                                        159                  char c = 'W';
   72                  if( la.empty ) {                                                 |   160                  if( g.map.collected_lambda == g.map.total_lambda ) {
   73                          cand = search(g, ro, [li], death);                           161                          cand = search(g, ro, [li], death);
   74                  } else {                                                         |   162                  } else if( !la.empty ){
   75                          cand ~= search(g, ro, la~ra, death);                         163                          cand ~= search(g, ro, la~ra, death);
   76                  }                                                                    164                  }
   77                                                                                       165  
   78                  // 'higesori' mode                                                   166                  // 'higesori' mode
   79                  if( !hi.empty && g.num_razor>0 ) {                               |   167                  if( !hi.empty && g.map.num_razor>0 ) {
   80                          int his = 0;                                                 168                          int his = 0;
   81                          for(int dy=-1; dy<=+1; ++dy)                                 169                          for(int dy=-1; dy<=+1; ++dy)
   82                          for(int dx=-1; dx<=+1; ++dx)                                 170                          for(int dx=-1; dx<=+1; ++dx)
   83                                  if(g[ro.y+dy,ro.x+dx] == 'W')                    |   171                                  if(g.map[ro.y+dy,ro.x+dx] == 'W')
   84                                          his++;                                       172                                          his++;
   85                                                                                       173  
   86                          if(his>=2 || his==hi.length)                                 174                          if(his>=2 || his==hi.length)
   87                                  cand = [tuple('S',int.max)];                         175                                  cand = [tuple('S',int.max)];
   88                          if(cand.empty) {                                             176                          if(cand.empty) {
   89                                  const(Pos)[] tgt;                                    177                                  const(Pos)[] tgt;
   90                                  for(int y=1; y<=g.H; ++y)                        |   178                                  for(int y=1; y<=g.map.H; ++y)
   91                                  for(int x=1; x<=g.W; ++x)                        |   179                                  for(int x=1; x<=g.map.W; ++x)
   92                                          if(g[y,x]=='.'||g[y,x]==' ') {           |   180                                          if(g.map[y,x]=='.'||g.map[y,x]==' ') {
   93                                                  his = 0;                             181                                                  his = 0;
   94                                                  for(int dy=-1; dy<=+1; ++dy)         182                                                  for(int dy=-1; dy<=+1; ++dy)
   95                                                  for(int dx=-1; dx<=+1; ++dx)         183                                                  for(int dx=-1; dx<=+1; ++dx)
   96                                                          if(g[y+dy,x+dx] == 'W')  |   184                                                          if(g.map[y+dy,x+dx] == '
   97                                                                  his++;               185                                                                  his++;
   98                                                  if(his>=2)                           186                                                  if(his>=2)
   99                                                          tgt ~= new Pos(y,x);         187                                                          tgt ~= new Pos(y,x);
  100                                          }                                            188                                          }
  101                                  cand ~= search(g, ro, tgt, death, true);             189                                  cand ~= search(g, ro, tgt, death, true);
  102                          }                                                            190                          }
  103                  }                                                                    191                  }
                                                                                        >   192  
                                                                                        >   193                  // 'horo-push' mode
                                                                                        >   194                  if(cand.empty) {
                                                                                        >   195                          Pos[] horo = g.map.objects('@');
                                                                                        >   196                          Pos[] tgt;
                                                                                        >   197                          foreach(p; horo)
                                                                                        >   198                                  if((g.map[p.y,p.x-1]==' '||g.map[p.y,p.x-1]=='R'
                                                                                        >   199                                     (g.map[p.y,p.x+1]==' '||g.map[p.y,p.x+1]=='R'
                                                                                        >   200                                   ||(g.map[p.y-1,p.x]==' '||g.map[p.y-1,p.x]=='R'
                                                                                        >   201                                          tgt ~= p;
                                                                                        >   202  
                                                                                        >   203                          for(int y=1; y<=g.map.H; ++y)
                                                                                        >   204                          for(int x=1; x<=g.map.W; ++x)
                                                                                        >   205                                  if(g.map[y,x]=='.')
                                                                                        >   206                                          if(is_rocky(g.map[y+1,x])||is_rocky(g.ma
                                                                                        >   207                                           ||is_rocky(g.map[y,x+1])||is_rocky(g.ma
                                                                                        >   208                                                  tgt ~= new Pos(y,x);
                                                                                        >   209  
                                                                                        >   210                          if(!tgt.empty)
                                                                                        >   211                                  cand ~= search(g, ro, tgt, death, true);
                                                                                        >   212                  }
  104                                                                                       213  
  105                  // 'dig' mode                                                        214                  // 'dig' mode
  106                  if(cand.empty) {                                                     215                  if(cand.empty) {
  107                          const(Pos)[] tgt;                                        |   216                          Pos[] tgt;
  108                          for(int y=1; y<=g.H; ++y)                                |   217                          for(int y=1; y<=g.map.H; ++y)
  109                          for(int x=1; x<=g.W; ++x)                                |   218                          for(int x=1; x<=g.map.W; ++x)
  110                                  if(g[y,x]=='.')                                  |   219                                  if(g.map[y,x]=='.')
  111                                          if(g[y+1,x]=='*'||g[y+1,x-1]=='*'||g[y+1 |   220                                          if(is_rocky(g.map[y+1,x])||is_rocky(g.ma
  112                                           ||g[y,x+1]=='*'||g[y,x-1]=='*')         |   221                                           ||is_rocky(g.map[y,x+1])||is_rocky(g.ma
  113                                                  tgt ~= new Pos(y,x);                 222                                                  tgt ~= new Pos(y,x);
  114                          cand ~= search(g, ro, tgt, death, true);                     223                          cand ~= search(g, ro, tgt, death, true);
  115                  }                                                                    224                  }
  116                                                                                       225  
  117                  if(cand.empty) {                                                     226                  if(cand.empty) {
  118                          choke_count++;                                               227                          choke_count++;
  119                          cand ~= tuple('W',int.max);                                  228                          cand ~= tuple('W',int.max);
................................................................................................................................................................................

  133                                  }                                                    242                                  }
  134                  }                                                                    243                  }
  135                                                                                       244  
  136                  if(c == 'W')                                                         245                  if(c == 'W')
  137                          wait_count++;                                                246                          wait_count++;
  138                  else                                                                 247                  else
  139                          wait_count = 0;                                              248                          wait_count = 0;
                                                                                        >   249                  if(wait_count==2)
                                                                                        >   250                          c = 'A';
  140                  if(choke_count >= g.H)                                           |   251                  if(choke_count >= g.map.H)
  141                          c = 'A';                                                     252                          c = 'A';
  142                                                                                       253  
  143                  bool[char] choice;                                                   254                  bool[char] choice;
  144                  foreach(t; cand)                                                     255                  foreach(t; cand)
  145                          choice[t[0]] = true;                                         256                          choice[t[0]] = true;
  146                  log ~= tuple(ro.clone(), cast(int)choice.length);                    257                  log ~= tuple(ro.clone(), cast(int)choice.length);
  147                  if(log.length > 5)                                                   258                  if(log.length > 5)
................................................................................................................................................................................

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

                                                                                        >     1  --------------------------------------------------------------------------------
    1  Team:                                                                                  2  Team:
    2    Dark Integers                                                                        3    Dark Integers
                                                                                        >     4  
    3  Member:                                                                                5  Member:
    4    Kazuhiro Inaba (www.kmonos.net / kiki@kmonos.net)                                    6    Kazuhiro Inaba (www.kmonos.net / kiki@kmonos.net)
                                                                                        >     7  
    5  Language:                                                                        |     8  Programming Language:
    6    D Programming Language (dlang.org)                                                   9    D Programming Language (dlang.org)
                                                                                        >    10  --------------------------------------------------------------------------------
                                                                                        >    11  
                                                                                        >    12  Three types of solvers are combined.
                                                                                        >    13  
                                                                                        >    14   1. Solver "Forest"
                                                                                        >    15        It does breadth first search every turn for taking the game's dynamism
                                                                                        >    16        into account. Basically it tries to rush to the nearest lambda or open
                                                                                        >    17        lift, but if there is no route found, it tries other various options.
                                                                                        >    18        Pushing rocks, digging earth around rocks, wait a while...
                                                                                        >    19        It is slow, but relatively more clever.
                                                                                        >    20  
                                                                                        >    21   2. Solver "Wind"
                                                                                        >    22        It does breadth first search and memorize the computed path. As far as
                                                                                        >    23        possible, it tries to follow the precomputed route. If some obstacle is
                                                                                        >    24        found, it redoes the BFS. It is dumb but fast. So it is used for large
                                                                                        >    25        maps.
                                                                                        >    26  
                                                                                        >    27   3. Solver "Fire"
                                                                                        >    28        It is a kind of "higher-order" solver, that takes another solver and
                                                                                        >    29        creep into it to make it more careful. Precisely speaking, this higher
                                                                                        >    30        order solver runs the subsolver as a 10-20 step lookahead. While no
                                                                                        >    31        problem is found in the lookahed, it behaves exactly as same as the
                                                                                        >    32        sub solver. If there was a problem (i.e., subsolver dead or stuck),
                                                                                        >    33        it tries all the possible perturbations to the lookahead window, and
                                                                                        >    34        re-runs subsolvers many times and chooses the best one.
                                                                                        >    35  
                                                                                        >    36  Fire<Forest> is used for W*H<=1600 instances. Fire<Wind> is used for any
                                                                                        >    37  instances. For smaller maps, the better result of the two is used as the
                                                                                        >    38  final output. In addition, all these outputs are guarded by a sentinel
                                                                                        >    39  who aborts by force the output sequence at the best score position (so
                                                                                        >    40  that left-over run does not make the score worse).
                                                                                        >    41  
                                                                                        >    42  
    7                                                                                        43  
    8  This submission for lightning division is not particulary interseting.           |    44  For the added features, not quite much effort is paid. So if there came a
                                                                                        >    45  map that fully exploits the characteristics of the gadgets, I'll lose :(.
    9                                                                                        46  
   10  - Robot rushes to the nearest lambda (or the open lift) by breadth first search. |    47    Flood:
   11    - Not at all taking into account the dynamics (falling rocks, floods).         |    48       Almost nothing is done for it. The "fire" solver locally takes care
   12    - To mitigate the staticness, the robot avoids the '.' below '*' as much as    |    49       of it, and it is inclided to use "U" during perturbation. Also, "wind"
   13      possible, so that it won't fall new rocks.                                   |    50       solver's BFS is made to like "U" direction in larger maps.
                                                                                        >    51    Trampoline:
                                                                                        >    52       Just treated as one BFS edge.
                                                                                        >    53    Beard:
                                                                                        >    54       No clue. If there is nothing else to do, goes to the place where many
                                                                                        >    55       Wadler's are around, and uses the shaver.
                                                                                        >    56    Higher-order Rocks:
                                                                                        >    57       Tries to push them somehow randomly.
   14                                                                                        58  
   15  - Output routine is 'guarded' by a 'sudden death' or 'stray sheep' detector.     <
   16    That is, if the above search routine was hit by a rock or a water, or it       <
   17    couldn't find a way to the next target and walked in vain, the output guards   <
   18    trims the command history and inserts the 'A'bort at the optimal timing.       <
   19    This is also used for SIGINT handling.                                         <
                                                                                        >    59  
   20                                                                                        60  
   21  - gui.d is a windows GUI for the game, using DFL (http://github.com/Rayerd/dfl)  |    61  Thanks for organizing the contest! I've enjoyed!
   22    it is not compiled into the submitted routine. This is just a helper.          <
   23                                                                                   <
   24  Stay tuned for the full submission, judges!                                      <

Modified submission/lifter from [5103f55f5323fb3f] to [5c2c7e2c00c91cc8].

cannot compute difference between binary files