Aus IBM PC AT, YouTube (siehe Video) , Wikipedia (siehe Artikel) und Sesamstraße haben wir gelernt :

Der Buchstabe Hist der gnadenloseste Buchstabe des Alphabets !

(Auch wenn es tatsächlich aus zwei Elementen in Code Page 437 besteht . Auf diese Weise ist es sogar noch gnadenloser.)

Wie die Außerirdischen in ... ähm ... Außerirdischen verfolgen die Bestien unerbittlich alle, die es wagen würden, sich ihren Eiern zu nähern. Es gibt keine Gründe dafür. Sie müssen sie zerquetschen, wenn Sie nicht zugrunde gehen wollen.

In diesem Szenario gehen wir davon aus, dass Sie Ihr letztes Leben hinter sich haben und einfache Bestien in einem Gelände ohne Eier getroffen haben (wie im Wikipedia-Screenshot). Sie haben keine Zehnertastatur und können sich nur direkt auf / ab / links / rechts bewegen ... aber die Bestien haben anscheinend eine und können sich diagonal bewegen, wenn sie an der Reihe sind.

Die Wahl der Bewegung eines Tieres unter seinen Optionen ist diejenige, die die Entfernung vom Spieler minimiert. Wenn die Abstände gleich sind, wird das Binden bevorzugt mit Links + Oben + Rechts + Unten ausgeführt, aber hier ist die Disambiguierungsmatrix, um es explizit darzustellen ... niedrigste Zahl zum Binden:

1 3 4
2 H 5
6 8 7

Ein Tier schläft nie, aber sie sind glücklicherweise etwas langsamer als der Spieler. Sie bewegen sich alle zwei Runden (geben dem Spieler einen Vorsprung, indem sie ihre Wechsel in der zweiten Runde beginnen). Sie müssen sich bewegen, wenn ein Zug möglich ist, unabhängig davon, ob dies sie weiter vom Spieler entfernt.

Du zerquetschst ein Tier, wenn du einen Zug beweglicher Mauern in eine geschlossene Lücke setzt. Diese einfachen Bestien sind 2 Punkte pro Kopf wert.

Eingang

1. Ein Paar von Ganzzahlen, die die Größe einer Karte in Spalten und dann in Zeilen angeben.

2. Zeilenanzahl der Eingabezeilen, jede der Spaltengröße ... enthält entweder eine feste Wand ( #), eine bewegliche Wand ( ~), ein Biest ( H), den Spieler ( O) oder nur ein Leerzeichen.

3. Eingabe, die entweder U, D, L, R ist und einen Zugversuch des Spielers anzeigt ... oder W, um einfach zu warten. Beachten Sie, dass der Versuch, eine bewegliche Wand zu drücken, die blockiert ist, eine legale Eingabe ist und nur zu keiner Aktion führt.

Ausgabe

1. aHHHH! wenn die Bestien den Spieler getötet haben ... oder nichts, wenn der Spieler gewonnen hat, ohne dass noch Bestien übrig sind

2. Die Punktzahl

(Hinweis: Zu Debugging- und / oder Unterhaltungszwecken möchten Sie wahrscheinlich den Status bei jedem Schritt ausgeben können. Dies ist jedoch zu lang, um hier einen Beitrag zu verfassen.)

Klarstellungen

• Karten werden garantiert von massiven Wänden begrenzt.

• Die Reihenfolge, wer sich in einer Runde bewegt, ist entscheidend für das Ergebnis. Also: Der Spieler geht immer zuerst, dann erhalten die Bestien eine Reihenfolge basierend auf ihrer anfänglichen Kartenposition, wenn Sie von links nach rechts oben nach unten über den Bildschirm gefegt haben. (Eine Bestie aus Reihe 1 bewegt sich vor einer Bestie aus Reihe 2, und zwei Bestien in derselben Reihe wäre es diejenige mit der niedrigsten Spaltennummer, die sich vor der anderen bewegen würde.)

• Sich diagonal bewegende Bestien können sich in jeden offenen, angrenzenden diagonalen Raum bewegen, unabhängig davon, ob ein Quetschen zwischen den Wänden erforderlich ist.

• Ein Spieler kann eine beliebige Anzahl von beweglichen Wänden in eine Reihe schieben, vorausgesetzt, am anderen Ende befindet sich ein Feld oder ein Tier. Wenn Sie jedoch versuchen, eine Reihe von Mauern in ein Tier zu stoßen, das nicht zwischen Mauern eingeklemmt ist, wird das Tier als Mauer behandelt und der Umzug wird nicht zugelassen.

• Die Zugentscheidung eines Tieres während eines Zuges basiert auf der Position des Spielers zu Beginn des Zuges. Die gewünschte Optimierung der "Entfernung zum Spieler" erfolgt durch eine "Luftlinie" -Berechnung. Jegliche Annäherung, die das gleiche Ergebnis ergibt, gemessen von der Mitte des Quadrats bis zur Mitte des Spielerquadrats, ist in Ordnung.

• Wenn ein Tier nicht in der Lage ist, den ersten Zug in einer Runde zu machen, weil ein Tier mit höherer Priorität seinen Platz eingenommen hat, wird es die nächstbeste Wahl treffen, anstatt an Ort und Stelle zu bleiben (falls ein Zug noch möglich ist).

Musterkoffer

Einfaches Crush

Eingang

5 3
#####
#O~H#
#####
R

Ausgabe

2

Präferenzmatrix -> Tod

Eingang

5 5
#####
#O  #
# ~ #
#  H#
#####
WWDW

Ausgabe

aHHHH!
0

Preference Matrix -> Win

Eingang

5 5
#####
#O  #
# ~ #
#  H#
#####
WRD

Ausgabe

2

Warten auf den Schnitter

Eingang

5 5
#####
#O  #
# ~ #
#  H#
#####
WWW

Ausgabe

aHHHH!
0

Erfolgreiche Niederlage im Wikipedia-Szenario

Eingang

40 23
########################################
#~      ~ ~~  ~  ~ ~~   ~ ~~    ~ ~ ~~ #
#~~ ~          ~~   ~   ~ ~~         ~ #
#~# ~~   ~~~~      ~  ~~~~  ~    ~~~  ~#
# ~        ~   ~ ~~ #~~       ~        #
#~~  ~~~   ~ ~ ~      ~ ~~ ~  ~  ~  ~  #
#     ~~  ~  ~ ~ ~~~       H    ~  #~  #
#  O~  ~  #  ~~~ ~      ~ ~~  ~  ~ ~~  #
#       ~ ~H~~   ~~ ~ #        ~~   ~  #
# ~~         ~ ~~~  ~~   ~~~~      ~  ~#
#~  ~    ~~~  ~   ~        ~   ~ ~~  ~~#
#     ~      # ~ ~~  ~~~   ~ ~ ~ #    ~#
#~ ~ ~~  ~  ~   H     ~~  ~~ ~ ~ ~~~   #
#       ~   ~   ~   ~  ~     ~~~ ~     #
# ~~  ~  ~ ~~   ~       ~ ~ ~     ~    #
#      ~~   ~   ~  ~         ~      ~~ #
#~ ~     #    ~~~~  ~    ~~~H   # ~    #
#  ~   ~ ~   ~        ~          ~~  ~ #
#  ~   ~     #~  ~   ~~  ~  ~         ~#
# ~~ ~ ~  ~~                ~   ~      #
#    ~~~        ~ ~~  ~  ~  ~   ~      #
# ~ ~     ~            ~~   ~   ~  ~   #
########################################
RRRUWWWRRRURWWWWRDRRWWRDWWWWD

Ausgabe

8

Von mir bereitgestellte Karte, bewegt sich und wird von @bobbel ausgegeben, von mir und @Allbeert bestätigt.

Gewinnkriterien

Ich denke, das ist golffähig, also werde ich mit Code-Golfregeln weitermachen, es sei denn, die Leute beschweren sich.

Extra Gutschrift

Spielbare Unicode-Implementierung mit doppelt breiten Zeichen, die dem Bild ähneln!

Perl 6: 741 Zeichen, 758 Bytes

Die Golf-Version ist unten, da es im Grunde Leinen ist. Darüber ist meine vorgolfende Version. Beide sind interaktiv (sie lesen so viele Befehle wie möglich aus der Eingabedatei und verwenden dann STDIN, um Befehle abzurufen). Sie versuchen, die ursprünglichen Zeichen und Farben zu verwenden.

Die Verwendung ist wie folgt perl6 beast.p6 beast-input:

use Term::ANSIColor;
class BeastGame {
    enum BeastParts <None Player Beast M-Wall S-Wall>;

    has @.board;
    has Int $.turn = 0;
    has Int $.score = 0;

    method indices (\matcher) {
        @.board.pairs.map: {
            .key*i X+ .value[].pairs.map: {
                .key if .value ~~ matcher
            }
        }
    }
    multi postcircumfix:<[ ]> (BeastGame \SELF, Complex \c) is rw { SELF.board[c.im][c.re] }

    has Complex $!player;
    method player { $!player = $.indices(Player)[0] }
    method Bool { so $.indices(Player) & $.indices(Beast) }

    method new (@lines) {
        my @board = @lines.map:
            {[ %(' ',<O H ~ #> Z=> None, Player, Beast, M-Wall, S-Wall){ .comb } ]}

        self.bless: :@board
    }
    method gist {
        state @symbol-map = map {colored .key, .value~' on_black'},
            ('  ',<◄► ├┤ ▒▒ ██> Z=> <default cyan red green yellow>);

        @.board.map({ @symbol-map[@$_].join }).join("\n")
    }

    method step ($d) {
        my $direction = %(:W(0), :L(-1+0i), :R(1+0i), :U(-1i), :D(1i)){$d};
        $direction // return self;
        self.move($.player,$direction);

        if ++$!turn %% 2 {
            for $.indices(Beast).eager -> $c {
                for (-1-1i,-1+0i,-1i,1-1i,1+0i,-1+1i,1+1i,1i,0i)\
                        .sort({abs $c + $^d - $!player})
                {
                    last if self.move($c, $_).defined;
                }
            }
        }

        self;
    }
    method move ($cur, $by) {
        return $cur if $by == 0;

        my $to = $cur + $by;
        my &cur-is  = { self[$cur] ~~ $^o }
        my &next-is = { self[$to]  ~~ $^o }
        return if cur-is S-Wall;
        (self[$to], self[$cur]) = (self[$cur], None)
            if next-is None
            # Move wall
            or cur-is Player | M-Wall and next-is M-Wall and self.move($to, $by)
            # Kill Player
            or cur-is Beast  and next-is Player
            # Squish Beast
            or cur-is M-Wall and next-is Beast  and self[$to+$by] ~~ M-Wall|S-Wall and $!score += 2
    }
}
my $width = get.words[1];
my $game  = BeastGame.new(lines[^$width]);
my @commands = '',lines.comb,{$*IN.get.comb}...*;

while $game {
    $game.step: @commands.shift;
    print "\e[2J";
    print "\e[H";
    say $game;
}

say "aHHHH!" unless $game.player;
say $game.score;

Die Golfversion:

my ($u,$s,$m)=0,0;my@b=lines[^get.words[1]].map:{[%(' ',<O H ~ #>Z=>^5){.comb}]}
my@a='',lines.comb,{$*IN.get.comb}...*;sub g(\c)is rw {@b[c.im][c.re]}
my&n=->\o{@b.kv.map:{$^k*i X+$^v[].kv.map:{$^l if $^w==o}}}
my&p={$m=n(1)[0]}
my&M=->$c,$b{my$t=$c+$b;my&c={$^o==g $c}
my&x={$^o==g $t}
c(4)??0!!$b??(($c,$t)».&g=(0,g $c)
if x(0)||c(1|3)&&x(3)&&M($t,$b)||c(2)&&x(1)||c(3)&&x(2)&&2 <g($t+$b)&&($s+=2))!!1}
while n(1)&n(2) {for 1
{M p,%(:W(0),:L(-1),:R(1),:U(-1i),:D(1i)){@a.shift}//last;if $u++%2
{for n(2).eager ->$c{last if M $c,$_
for(-1-1i,-1+0i,-1i,1-1i,1+0i,-1+1i,1+1i,1i,0i).sort({abs $c+$_-$m})}}}
say "\e[2J\e[H",join "\n",map {[~]
(map {"\e[$^v;40m$^k\e[0m"},'  ',<39 ◄► 36 ├┤ 31 ▒▒ 32 ██ 33>)[@$_]},@b}
say "aHHHH!" if !p;say $s;

Frohe Ostern!

Java, 1,843

Mein erster Versuch, dieses Rätsel mit Java zu lösen. Ich weiß, dass es viele Verbesserungen gibt, die es kürzer machen. Aber am Ende klappt es erstmal.

Um es zu versuchen, müssen Sie eine Klasse erstellen Cund den Code einfügen. args[0](Genau genommen a[0]) ist für die Eingabe. Die Druckmethode der Karte ist nicht enthalten, da sie für die Puzzle-Ausgabe nicht erforderlich ist.

class C{static char                    [][]C;static int A=
0,B=0,D=0,E=0,F=0,G                    = 0 ; public static
void main(String[]a                    ){String []b= a[0].
split("\n");int c =                    Byte. decode(b [0].
split(" ")[1]); G=a                    [ 0 ] . replaceAll(
"[^H]","").length()                    ; String d = b [ b.
length - 1 ] ;C=new                    char[c][];for(int e
=1;e<b.length-1;e++                    ) C [ e - 1 ]=b[e].
toCharArray ( ) ; f                    ();boolean X= 0> 1;
for ( char  g : d .                    toCharArray ( ) ) {
switch(g){case 'U':                    h(0,-1);break; case
'D':h(0, 1); break;                    case 'L':h( -1, 0);
break;case'R':h(1,0                    );}if(X)i();X=!X;f(
);}System.out.print                    (D);}static void f(
){for(int a= 0;a<C.                    length;a++)for( int
b=0;b<C[a].length;b                    ++)if(C[a][b]=='O')
{A=b;B= a;}}static void h(int x,int y){E =x;F =y;switch(C[
B +y][A +x]){case 'H':g();break;case ' ':j(A,B);break;case
'~':k();}}static void i(){if(G<1){return;}int[][]l=new int
[G][];int m=0;for(int r=0;r<C.length;r++){for(int c=0;c<C[
r].length; c++){if(C[r][c]=='H'){l[m++]=new int[]{c,r};}}}
for(int[]n:l){o(n[0],n[1]);}} static void o(int a, int b){
int[]c=d (a,b);E=c[0];F =c[1];if(E !=0||F !=0){ j(a,b);} }
static int[]d(int a,int b){int[][]d={{1,3,4},{2,0,5},{6,8,
7},};int[]e=new int[]{0,0};double f=999;for(int r=-1;r<2;r
++){for(int c=-1;c<2;c++){if(C[b+r][a+c]==' '||C[b+r][a+c]
=='O'){int g=a+c-A;                    int h=b+r-B; double
i=Math.sqrt(g*g+h*h                    );if(i<f){e=new int
[]{ c,r};f =i;}else                    if(i==f){if(d[r+1][
c+1]<d[e[1]+1][e[0]                    +1]){e=new int[]{c,
r};}}} }}return e;}                    static void k(){if(
p(E,F,false)){q(E,F                    );} }static void q(
int x,int y){switch                    (C[B+y][A+x]){ case
'~':q(x+E,y+F);case                    'H':case ' ':j(A+x-
E,B+y- F);}} static                    boolean p(int x,int
y,boolean h){switch                    (C[B+y][ A+x]){case
' ':return !h; case                    '~':return h?h:p(x+
E,y +F, false);case                    'H':return h?!h:p(x
+E , y+ F, true) ;}                    return h&&C[B+y][A+
x] == '#' ; }static                    void j(int a,int b)
{char c=C[b][a];if(                    C[b+F][a+E]=='O'){g
();}else if(C[b+F][                    a+E]=='H'){D+=2;G--
;c=C[b][a];C[b][a]=                    ' ';}else{C[b][a]=C
[b+F][a+E];}C[b+F][                    a+E]=c;}static void
g () { System .out.                    print("aHHHH!\n"+D)
;     System      .                    exit  ( 0  ) ;  } }

Um es auszuführen, versuchen Sie zum Beispiel:

root@host:/cygdrive/c/workspace/project/bin> java C "5 5
> #####
> #O  #
> # ~ #
> #  H#
> #####
> WWDW"
aHHHH!
0
root@host:/cygdrive/c/workspace/project/bin>

Ausgabe des letzten großen Szenarios eine Runde bevor ein Tier den Spieler frisst:

████████████████████████████████████████████████████████████████████████████████
██▓▓            ▓▓  ▓▓▓▓    ▓▓    ▓▓  ▓▓▓▓      ▓▓  ▓▓▓▓        ▓▓  ▓▓  ▓▓▓▓  ██
██▓▓▓▓  ▓▓                    ▓▓▓▓      ▓▓      ▓▓  ▓▓▓▓                  ▓▓  ██
██▓▓██  ▓▓▓▓      ▓▓▓▓▓▓▓▓            ▓▓    ▓▓▓▓▓▓▓▓    ▓▓        ▓▓▓▓▓▓    ▓▓██
██  ▓▓                ▓▓      ▓▓  ▓▓▓▓  ██▓▓▓▓              ▓▓                ██
██▓▓▓▓    ▓▓▓▓▓▓      ▓▓  ▓▓  ▓▓            ▓▓  ▓▓▓▓  ▓▓    ▓▓    ▓▓    ▓▓    ██
██          ▓▓▓▓    ▓▓    ▓▓  ▓▓  ▓▓▓▓▓▓                        ▓▓    ██▓▓    ██
██          ▓▓▓▓    ██    ▓▓▓▓▓▓  ▓▓            ▓▓  ▓▓▓▓    ▓▓    ▓▓  ▓▓▓▓    ██
██              ▓▓  ▓▓  ▓▓▓▓      ▓▓▓▓  ▓▓  ██                ▓▓▓▓      ▓▓    ██
██  ▓▓▓▓                  ▓▓  ▓▓▓▓▓▓    ▓▓▓▓  ├┤  ▓▓▓▓▓▓▓▓            ▓▓    ▓▓██
██▓▓    ▓▓    ├┤◄►▓▓▓▓▓▓├┤  ▓▓      ▓▓                ▓▓      ▓▓  ▓▓▓▓    ▓▓▓▓██
██          ▓▓            ██  ▓▓  ▓▓▓▓    ▓▓▓▓▓▓      ▓▓  ▓▓  ▓▓  ██        ▓▓██
██▓▓  ▓▓  ▓▓▓▓    ▓▓    ▓▓                  ▓▓▓▓    ▓▓▓▓  ▓▓  ▓▓  ▓▓▓▓▓▓      ██
██              ▓▓      ▓▓      ▓▓      ▓▓    ▓▓├┤        ▓▓▓▓▓▓  ▓▓          ██
██  ▓▓▓▓    ▓▓    ▓▓  ▓▓▓▓      ▓▓              ▓▓  ▓▓  ▓▓          ▓▓        ██
██            ▓▓▓▓      ▓▓      ▓▓    ▓▓                  ▓▓            ▓▓▓▓  ██
██▓▓  ▓▓          ██        ▓▓▓▓▓▓▓▓    ▓▓        ▓▓▓▓▓▓        ██  ▓▓        ██
██    ▓▓      ▓▓  ▓▓      ▓▓                ▓▓                    ▓▓▓▓    ▓▓  ██
██    ▓▓      ▓▓          ██▓▓    ▓▓      ▓▓▓▓    ▓▓    ▓▓                  ▓▓██
██  ▓▓▓▓  ▓▓  ▓▓    ▓▓▓▓                                ▓▓      ▓▓            ██
██        ▓▓▓▓▓▓                ▓▓  ▓▓▓▓    ▓▓    ▓▓    ▓▓      ▓▓            ██
██  ▓▓  ▓▓          ▓▓                        ▓▓▓▓      ▓▓      ▓▓    ▓▓      ██
████████████████████████████████████████████████████████████████████████████████

Ohne dumme Zeilenabstände: http://pastebin.com/raw.php?i=QhpxKcCT

Der Weg des Spielers endet also nach den Zügen RRDDDRRRWW, denn beim letzten WTreffer geht das Tier links nach rechts, um den Spieler zu fressen.

Ein weiteres Beispiel für die ursprüngliche große Karte, aber andere Züge:

http://pastebin.com/raw.php?i=nBWjC3PZ

Siehe diese Animation: http://youtu.be/0DIhEhjWd6s

Und das letzte Beispiel mit Originalkarte und verschiedenen Zügen (gemäß den neuen Regeln für Tierbewegungen):

http://pastebin.com/raw.php?i=NNmgzx7U

Siehe auf youtube: http://youtu.be/jXPzL88TU2A

C - 1004 984 917

Ahh, die Schönheit von C. Dem Geist der anderen Antwort folgend, habe ich auch versucht, meine zu formatieren :)

Ich stelle mir vor, dass es hier und da noch einige Verbesserungen gibt, aber das Schreiben und Golfen hat wirklich Spaß gemacht. Die Zeichenanzahl enthält alle erforderlichen Leerzeichen und neuen Zeilen.

#define M(y,x,c) {t[y][x]=32;t[p][q]=c;y=p;x=q;}
   #define E {printf("aHHHH!\n%d",Z);exit(0);}
    #define A sqrt(pow(X-Q,2)+pow(Y-P,2))*30
           #define L (char)(m[s]>>8)
            #define G (char)(m[s])
             #define B(b) if(T==b)
              #define J M(Y,X,79)
               #define T t[P][Q]

r,c,X,Y,H,i,j,k,Z,p,q,P,Q,u,v,s,w,m[99],b[8]={
-1,255,65280,65281,1,511,257,256},t[999][999],
x[99],y[99];main(){char N[99];m[85]=b[2];m[68]
=256;m[76]=255; m[82]=1; scanf("%d %d",&c,&r);
for(;P<r;P++)                    for(Q=0;Q<c&&
scanf("%c",&T                    );T-10&&T-13?
Q++:Q){B(79){                    Y=P;X=Q;}B(72
){y[H]=P ;x[H                    ++]=Q;}}scanf
("%s",N);for(                    ;i<strlen(N);
i++){s=N[i];P                    =p=Y+L;Q=q=X+
G;B(32)J B('~')                  {while(P+=L,Q
+=G,T=='~');B                    (72){u=P+L;v=
Q+G;if(t[u][v]                   ==35||t[u][v]
=='~'){Z+=2;T=                   '~';J}}B(32){
T='~';J}}else                    B(72)E if(r=!r)
for(j=0;j<H;j                    ++){P=y[j];Q=
x[j];if(T-72)continue;v=A;s=0;for(k=0;k<8;k++)
{P=y[j]+(char)(b[k]>>8);Q=x[j]+(char)(b[k]);u=
A;B(32)if((c=v-u+99)>s){s=c;q=Q;p=P;}B(79)E}if
(s)M(y[j],x[j],72)}}printf("%d",Z);}//////////

Ich habe dies mit allen Beispielfällen und einigen weiteren getestet, und es scheint ordnungsgemäß zu funktionieren. Wenn jemand eine Situation findet, in der er nicht richtig antwortet, lass es mich bitte wissen.

Die Eingabe erfolgt von stdin und die Ausgabe von stdout. Es erfolgt keine Überprüfung auf Fehleingaben. Und es gibt die Punktzahl zurück, wenn der Spieler gefressen wird oder wenn der Spieler am Leben ist, nachdem alle Bewegungen ausgeführt wurden (auch wenn es noch welche gibt) H.

Ungolfed-Version:

#define M(y,x,c) {t[y][x]=32;t[p][q]=c;y=p;x=q;}
#define E {printf("aHHHH!\n%d",Z);exit(0);}
#define A sqrt(pow(X-Q,2)+pow(Y-P,2))*30
#define L (char)(m[s]>>8)
#define G (char)(m[s])
#define B(b) if(T==b)
#define J M(Y,X,79)
#define T t[P][Q]

r, c, X, Y, H, i, j, k, Z, p, q, P, Q, u, v, s, w, m[99], b[8] = { -1, 255,
        65280, 65281, 1, 511, 257, 256 }, t[999][999], x[99], y[99];
main() {
    char N[99];
    m[85] = b[2];
    m[68] = 256;
    m[76] = 255;
    m[82] = 1;
    scanf("%d %d", &c, &r);
    for (; P < r; P++)
        for (Q = 0; Q < c && scanf("%c", &T);T-10&&T-13?Q++:Q) {
            B(79) {
                Y=P;
                X=Q;
            }
            B(72) {
                y[H]=P;
                x[H++]=Q;
            }
        }

    scanf("%s", N);
    for (; i < strlen(N); i++) {
        s = N[i];
        P = p = Y + L;
        Q = q = X + G;
        B(32)
            J
        B('~') {
            while (P += L, Q += G, T=='~');
            B(72) {
                u=P+L;
                v=Q+G;
                if(t[u][v]==35||t[u][v]=='~') {
                    Z+=2;
                    T='~';
                    J
                }
            }
            B(32) {
                T='~';
                J
            }
        } else B(72)E
        if (r = !r)
            for (j = 0; j < H; j++) {
                P = y[j];
                Q = x[j];
                if (T-72)
                continue;

                v = A;
                s = 0;

                for (k = 0; k < 8; k++) {
                    P = y[j] + (char) (b[k] >> 8);
                    Q = x[j] + (char) (b[k]);
                    u = A;
                    B(32)
                        if ((c = v - u + 99) > s) {
                            s = c;
                            q = Q;
                            p = P;
                        }

                    B(79)
                        E
                }
                if (s)
                    M(y[j], x[j], 72)
            }
    }
    printf("%d", Z);
}