Licznik Geigera to urządzenie służące do wykrywania promieniowania.

Będziemy tworzyć program liczników Geigera.

Jak wszyscy wiemy, gdy promieniowanie uderza w program komputerowy, losowo usuwa dokładnie 1 bajt. Tak więc program licznika Geigera jest programem, który sam nie robi nic, ale po usunięciu dowolnego bajtu drukowany jest zmodyfikowany program beep, wskazujący obecność promieniowania.

Odpowiedzi będą oceniane w bajtach, przy czym mniej bajtów będzie lepszych. Odpowiedzi muszą mieć co najmniej 1 bajt.

Twój program może drukować beepz końcowym znakiem nowej linii lub drukować pojedynczy znak nowej linii dla pustych danych wyjściowych, o ile robi to konsekwentnie. Program może również użyć innego przypadek dla beeptakich jak BEEP, bEEPlub Beeptak długo, jak robi to konsekwentnie.

Utracone , 303 293 263 253 238 228 bajtów

v^"peeb"<\>"beepvv"((>@@>>%%>>(((((([[[[[[\
>>>>>>>>>//>>>>>>>>>>>>>>/>>/>>>>>>>>>>>>>\\
>>>>>>>>//>>>>\>>>>>>>>>>/>>>>>>>>>>>>>>>>>\\
>/>>>>>>>/>>>>>>>>>>>>\>>>>>>>>>>>>>>>>>>>>>\\
>>>>>>>>>>>>>>>>>>>>>>\\>>>>\>>>>>>>>>>>>>>>>\

Wypróbuj online!

Skrypt weryfikacyjny (zapożyczony z odpowiedzi użytkownika 202729 ). Niestety może to przetestować tylko połowę kodu na raz, ale zapewniam, że przetestowałem cały program.

Och, to było trudne. Zacytuję usuniętą odpowiedź WW:

Lost to chyba najciekawszy język tego wyzwania. W Lost, początkowa lokalizacja i kierunek wskaźnika jest całkowicie losowa, dlatego aby tworzyć deterministyczne programy, musisz wziąć pod uwagę każdą możliwą początkową lokalizację i kierunek. Jednocześnie ze względu na charakter tego wyzwania należy również uwzględnić usunięcie jednego bajtu.

Niestety, jego odpowiedź nie uwzględniała usuwania nowych linii, co wszystko popsuło.

Wyjaśnienie:

(zwróć uwagę, że kilka bajtów może być tu i tam)

Najpierw porozmawiajmy o ogólnej strukturze kodu:

v^^"peeb"<<\/"beepvv"((>>>@@>>%%>>(((((([[[[[[[\       Processing line
>>>>>>>>>>>//>>>>>>>>>>>>>>>>>>>/>>>>>>>>>>>>>>\\      Beep line
>>>>>>>>>//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\\     Back-up beep line
>//>>>>>>>>>>>>>>>>>>>>\\>>>>>>>>>>>>>>>>>>>>>>>>\\    Back-up return line
>>>>>>>>>>>>>>>>>>>>>>>>\\>>>>>>\>>>>>>>>>>>>>>>>>\    Return line

Wszystko oprócz linii technologicznej musi być całkowicie złożone z jednego >lub jednego z nich \/. Czemu? Na przykład usuńmy nową linię:

v^^"peeb"<<\/"beepvv"((>>>@@>>%%>>(((((([[[[[[[\>>>>>>>>>>>//>>>>>>>>>>>>>>>>>>>/>>>>>>>>>>>>>>\\
>>>>>>>>>//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\\
>//>>>>>>>>>>>>>>>>>>>>\\>>>>>>>>>>>>>>>>>>>>>>>>\\
>>>>>>>>>>>>>>>>>>>>>>>>\\>>>>>>\>>>>>>>>>>>>>>>>>\

Pierwsza linia jest teraz znacznie dłuższa niż reszta bloku. Gdyby wskaźnik pojawił się na nie- >\/postaci z ruchem pionowym, utknąłby w nieskończonej pętli.

Największą częścią detektora promieniowania jest sekcja na końcu każdej linii.

 \
 \\
 >\\
 >>\\
 >>>\

Zwykle IP przechodzący przez to z pierwszej linii wychodziłby z ostatniej linii. Jeśli jednak jakikolwiek znak w linii zostanie usunięty, wówczas linia ta przesuwa się w dół o jeden, np .:

 \
 \\
 >\\
 >\\
 >>>\

Zamiast tego IP wychodzi z linii, w której brakuje bajtu (z wyjątkiem ostatniej linii, w której wychodzi z drugiej do ostatniej).

Stamtąd każda z pierwszych czterech linii przekieruje do drugiej linii:

v
>>>>>>>>>>
>>>>>>>>//
>/

Które następnie doprowadzą do jednego z dwóch beepers.

v^"peeb"<<\/"beepvv"((>
>>>>>>>>>>//

Jeśli którykolwiek z bajtów w pierwszym beeperie został usunięty, to zamiast tego przechodzi do drugiego:

v^^"peb"<<\/"beepvv"((>
>>>>>>>>>>>//

Obaj beepprowadzą następnie z powrotem do pierwszej linii i zakończenia@ .

Niektóre inne części:

(((((([[[[[[[Służy do wyczyszczenia stos, gdy wskaźnik zacznie wewnątrz parę cytatów i kończy się przesuwając całą pierwszą linię do stosu. Musi być niestety długi, ponieważ pierwszą linię nowej linii można usunąć, aby pierwsza linia była dwa razy większa. Eksperymentowanie w generowaniu plikubeep arytmetyki za pomocą cytatów zakończyło się dłużej.

\Y i /y rozrzucone po liniach są tam golf bajtów w wierszu górnym kodu poprzez przekierowanie wskaźnik do odpowiednich linii. Ponieważ większość dolnych linii jest tylko wypełniaczem, tylko górna linia jest w stanie grać w golfa. Jeśli ktoś ma jakieś pomysły na krótszy stos odporny na promieniowanie, jaśniejszy niż to, co mam teraz, nie krępuj się komentować.

Sześciokąt , 38 bajtów

.....;p;<>b;e;/<b;e;;p...@@.......;@..

Wypróbuj online!

Program weryfikacji.

Wyjaśnienie

Wykorzystujemy tutaj automatyczne wykrywanie sześciokąta przez Hexagony.

Jeśli nie zostaną usunięte żadne bajty, program ma długość boku 4 i wygląda następująco:

Jeśli jednak bajt zostanie usunięty. Istnieją 2 przypadki.

1. Usunięty bajt następuje po drugim <.

   Wykonanie byłoby następujące:

   

   W @piątej linii są 2 kolejne , więc nawet jeśli jeden z nich zostanie usunięty, IP bezpiecznie trafi w @.

2. Usunięty bajt jest na drugim lub przed drugim <.

   Wtedy druga połowa pozostanie nienaruszona, a adres IP nie będzie już przez to przekierowywany w górę <. Obraz przebiegu wykonania:

   

Sześciokąt , 34 29 bajtów

//..>;e;<b@;p;/|/;e;;\.b@;p<@

Wypróbuj online! Weryfikacja!

Wyjaśnienie:

Oto normalny kod sformatowany w prawidłowy sześciokąt za pomocą HexagonyColorer :

Podwój //na początku zapewnia, że ​​ta ścieżka jest zawsze obrana. Jeśli jakikolwiek znak zostanie usunięty, @zostanie usunięty ze ścieżki, albo zostanie przesunięty do tyłu, albo sam zostanie usunięty:

W tym przypadku usunęliśmy znak po znaku |, co powoduje, że podąża on tą ścieżką, drukując beep:

Jeśli zamiast tego usuniemy znak sprzed |(lub |samego), podążamy za drugą drukarką sygnałów:

Następnie wzięliśmy pod uwagę wszystkie możliwości i beepkorzystamy tylko z nienapromieniowanych części programu.

Samomodyfikujący Brainfuck , 73 63 bajty

<<[[[[<<]]>[[.>>..>>.[,>]]]]   bbeepp+[<<<]>>[[>]>>>.>>..>>.,+]

Wypróbuj online! Weryfikacja!

Spacje w środku kodu reprezentują w rzeczywistości bajty NUL.

Wyjaśnienie:

Kod jest podzielony na dwie sekcje przez 3 NUL bajtów pośrodku. Oba drukują w zasadzie, beepjeśli druga sekcja jest napromieniowana (z kilkoma wyjątkami).

Po pierwsze, <<[[na początku należy upewnić się, że wszystkie ]s są dopasowane w dowolnym momencie. [s nie będzie szukał dopasowania, ]jeśli komórka jest dodatnia, podczas gdy ]s zrobi . Jeśli którykolwiek ]przeskakuje z powrotem do jednego z tych nawiasów, zwykle odskakuje natychmiast, ponieważ komórka jest0 .

Następna część [[<<]]>sprawdza, czy długość sekcji 2 jest równa. Jeśli tak, wykonuje drugą połowę sekcji 1, która drukuje beepprzy użyciu bbeeppna początku sekcji 2.

[[.>>..>>.[,>]]]]

Następnie usuwa całą sekcję 2, więc nie wykonuje się.

W części 2, sprawdzamy, czy długość sekcji 1 i NUL bajtów jest podzielna przez 3z +[<<<]>>.

[[>]>>>.>>..>>.,+]

Podobnie drukujemy beep.

Z80Golf , 53 36 34 bajtów

-16 bajtów dzięki @Lynn
-2 bajtów dzięki @Neil

Ponieważ jest to tylko kod maszynowy Z80, jest w nim wiele niedrukowalnych elementów, więc należy mieć xxd -rodwracalny zrzut heksowy:

00000000: ddb6 2120 10dd b615 280c 003e 62ff 3e65  ..! ....(..>b.>e
00000010: ffff 3e70 ff76 003e 62ff 3e65 ffff 3e70  ..>p.v.>b.>e..>p
00000020: ff76                                     .v

Wypróbuj online! (wyczerpujący tester w Pythonie)

Wyjaśnienie

z80golf to hipotetyczna maszyna Z80 firmy Anarchy Golf, w której call $8000jest putchar, call $8003jest getchar, haltpowoduje wyjście interpretera, program jest umieszczony $0000, a cała inna pamięć jest wypełniona zerami. Uczynienie programów odpornymi na promieniowanie w asemblerze jest dość trudne, ale ogólnie użyteczną techniką jest stosowanie jednobajtowych idempotentnych instrukcji. Na przykład,

or c        ; b1    ; a = a | c

jest tylko jednym bajtem, a a | c | c == a | cwięc można go zabezpieczyć przed promieniowaniem poprzez powtórzenie instrukcji. W przypadku Z80 8-bitowe natychmiastowe ładowanie to dwa bajty (gdzie natychmiastowe jest w drugim bajcie), więc możesz pewnie ładować niektóre wartości do rejestrów. Tak właśnie zrobiłem na początku programu, więc możesz przeanalizować dłuższe warianty, które zarchiwizowałem na dole odpowiedzi, ale potem zrozumiałem, że istnieje prostszy sposób.

Program składa się z dwóch niezależnych ładunków, z których jeden mógł zostać uszkodzony przez promieniowanie. Sprawdzam, czy bajt został usunięty i czy usunięty bajt był przed drugą kopią ładunku, sprawdzając wartości niektórych bezwzględnych adresów pamięci.

Najpierw musimy wyjść, jeśli nie zaobserwowano promieniowania:

    or a, (ix+endbyte) ; dd b6 21 ; a |= memory[ix+0x0021]
    jr nz, midbyte     ; 20 10    ; jump to a halt instruction if not zero

Jeśli jakikolwiek bajt został usunięty, wszystkie bajty zostaną przesunięte i $0020będą zawierać ostatni 76, więc $0021będzie to zero. Możemy sobie pozwolić na promieniowanie początku programu, mimo że praktycznie nie ma redundancji:

• Jeśli przesunięcie skoku $10zostanie usunięte, wówczas promieniowanie zostanie poprawnie wykryte, skok nie zostanie wykonany, a przesunięcie nie będzie miało znaczenia. Pierwszy bajt następnej instrukcji zostanie zużyty, ale ponieważ ma on być odporny na usuwanie bajtów, nie ma to znaczenia.
• Jeśli kod operacji skoku $20zostanie usunięty, wówczas przesunięcie skoku $10zostanie zdekodowane jako djnz $ffe4(pochłanianie następnego bajtu instrukcji jako przesunięcia - patrz wyżej), który jest instrukcją pętli - zmniejszenie B, i przeskoczy, jeśli wynik nie będzie równy zero. Ponieważ ffe4-ffffjest wypełniony zerami nop, a licznik programu się zawija, spowoduje to uruchomienie programu 256 razy, a następnie kontynuację. Dziwi mnie, że to działa.
• Usunięcie $ddspowoduje, że reszta kodu zostanie zdekodowana jako or (hl) / ld ($1020), hl, a następnie przejdzie do następnej części programu. orNie zmieni żadnych ważnych rejestrów, a ponieważ HL wynosi zero w tym momencie zapisu będzie również anulować.
• Usunięcie $b6spowoduje, że reszta dekoduje jako ld ($1020), ixi będzie postępować jak wyżej.
• Usunięcie $21spowoduje, że dekoder zje $20, wywołując djnzzachowanie.

Zauważ, że użycie or a, (ix+*)pozwala zaoszczędzić dwa bajty ld a, (**) / and a / and adzięki zintegrowanemu sprawdzeniu zera.

Teraz musimy zdecydować, którą z dwóch kopii ładunku wykonać:

    or (ix+midbyte)  ; dd b6 15
    jr z, otherimpl  ; 28 0c
    nop              ; 00
    ; first payload
    ld a, 'b'        ; 3e 62
    rst $0038        ; ff
    ld a, 'e'        ; 3e 65
    rst $0038        ; ff
    rst $0038        ; ff
    ld a, 'p'        ; 3e 70
    rst $0038        ; ff
midbyte:
    halt             ; 76
otherimpl:
    nop              ; 00
    ld a, 'b'        ; 3e 62
    ; ...            ; ...
    rst $0038        ; ff
endbyte:
    halt             ; 76

Dwie kopie są oddzielone znakiem nop, ponieważ do wyboru między nimi używany jest skok względny, a promieniowanie mogło przesunąć program w taki sposób, że skok przeskoczyłby o pierwszy bajt za miejscem docelowym. Dodatkowo nop jest kodowany jako zero, co ułatwia wykrycie przesuniętych bajtów. Zauważ, że nie ma znaczenia, który ładunek zostanie wybrany, jeśli sam przełącznik jest uszkodzony, ponieważ wtedy obie kopie są bezpieczne. Upewnijmy się jednak, że nie wskoczy do niezainicjowanej pamięci:

• Usunięcie $ddspowoduje dekodowanie kolejnych dwóch bajtów jako or (hl) / dec d. Clobbers D. Nic wielkiego.
• Usunięcie $b6spowoduje utworzenie nieudokumentowanego dłuższego kodowania dec d. Tak samo jak powyżej.
• Usunięcie $15odczyta $28zamiast tego przesunięcie, a wykonanie będzie kontynuowane od $0c, jak poniżej.
• Kiedy $28znika, $0cdekodowany jest jako inc c. Ładowność nie ma znaczenia c.
• Usuwanie $0c- po to jest nop. W przeciwnym razie pierwszy bajt ładunku zostałby odczytany jako przesunięcie skoku, a program wskoczyłby do niezainicjowanej pamięci.

Sama ładowność jest dość prosta. Myślę, że mały rozmiar sznurka sprawia, że ​​to podejście jest mniejsze niż pętla i w ten sposób łatwiej jest uniezależnić pozycję. eW beeppowtórzeń, więc mogę zgolić jedną ld a. Również dlatego, że cała pamięć pomiędzy $0038i $8000jest wyzerowany, mogę spaść przez niego i używać krótszy rstwariant callinstrukcji, który działa tylko na $0, $8, $10i tak dalej, aż do $38.

Starsze podejścia

64 bajty

00000000: 2e3f 3f2e 3f3f 7e7e a7a7 201f 1e2b 2b1e  .??.??~~.. ..++.
00000010: 2b2b 6b00 7ea7 2814 003e 62cd 0080 3e65  ++k.~.(..>b...>e
00000020: cd00 80cd 0080 3e70 cd00 8076 003e 62cd  ......>p...v.>b.
00000030: 0080 3e65 cd00 80cd 0080 3e70 cd00 8076  ..>e......>p...v

58 bajtów

00000000: 2e39 392e 3939 7e7e a7a7 2019 3a25 00a7  .99.99~~.. .:%..
00000010: 2814 003e 62cd 0080 3e65 cd00 80cd 0080  (..>b...>e......
00000020: 3e70 cd00 8076 003e 62cd 0080 3e65 cd00  >p...v.>b...>e..
00000030: 80cd 0080 3e70 cd00 8076                 ....>p...v

53 bajty

Ten ma wyjaśnienie w historii edycji, ale nie jest inaczej.

00000000: 3a34 00a7 a720 193a 2000 a728 1400 3e62  :4... .: ..(..>b
00000010: cd00 803e 65cd 0080 cd00 803e 70cd 0080  ...>e......>p...
00000020: 7600 3e62 cd00 803e 65cd 0080 cd00 803e  v.>b...>e......>
00000030: 70cd 0080 76                             p...v

Co jeśli: każde niepuste wyjście jest w porządku zamiast sygnału dźwiękowego

1 bajt

v

halts program normalnie, ale jeśli promieniowanie go usunie, pamięć zostanie zapełniona zerami, co spowoduje $8000wykonanie nieskończonej liczby razy i wydrukowanie dużej liczby bajtów zerowych.

> <> , 23 bajty

<|o<"beep"/
>o<"beep"<\

Wypróbuj online! Weryfikacja.

To naprawdę zaskakujące, jak krótko to dostałem. Kończy się błędem.

Wersja bez błędów, 29 bajtów

<<;oooo"beep"/
 ;oooo"beep"<\

Wypróbuj online!

Klein , jedna z każdej topologii, o łącznej długości 291 bajtów

Po zapoznaniu się z odpowiedzią WW przy użyciu 001topologii postanowiłem zobaczyć, jak trudno byłoby wykonać Licznik Geigera dla każdej topologii. (Spoiler: bardzo trudny. Trudno ustalić, dokąd pójdzie wskaźnik bez gestów, które sprawiają, że wyglądam, jakbym zastanawiał się, która ręka jest moją lewą)

Weryfikacja!

(Myślałem też o napisaniu programu, który jest poprawnym licznikiem Geigera we wszystkich topologiach, ale może to wymagać oczekiwania. Jeśli jednak ktoś chce spróbować, oferuję nagrodę w wysokości 500 powtórzeń)

000 i 010, 21 bajtów

<<@"peeb"/
.@"peeb"<\

Wypróbuj 000 online! i wypróbuj 010 online!

Jest to przeniesione z mojego ><>rozwiązania . To oczywiście działa 000, ponieważ jest to domyślna topologia dla większości języków 2D, ale byłem zaskoczony, że to również działa 010.

001 i 011, 26 bajtów

!.<<@"peeb"/
.@"peeb"..<..

Wypróbuj 001 online! i wypróbuj 011 online!

Ten jest kopiowany bezpośrednio z odpowiedzi WW . Dzięki!

100, 21 bajtów

//@"peeb"\
@"peeb".</

Wypróbuj online!

101, 21 bajtów

//@"peeb"/
@"peeb".<!

Wypróbuj online!

110, 26 bajtów

<.<@"peeb"\\
.\@."peeb".\<

Wypróbuj online!

111, 24 bajtów

<<@"peeb"<\
...@"peeb"//

Wypróbuj online!

200, 21 bajtów

<<@"peeb"\
@"peeb".!/

Wypróbuj online!

201, 31 bajtów

\\.\.@"peeb"</./
./...@"peeb"<\

Wypróbuj online!

Zdecydowanie najbardziej denerwujące.

210, 26 bajtów

/\\@"peeb"</\
/@.."peeb"<\

Wypróbuj online!

211,27 bajtów

\\."peeb"((</
!/@@<"peeb"<\

Wypróbuj online!

Jedyny, w którym musiałem poradzić sobie z wejściem do sygnalizatora po prawej stronie.

Samomodyfikujący Brainfuck , 144 102 bajtów

Materiały niedrukowalne są wyświetlane jako sekwencja ucieczki (na przykład \x01).

\xa8<<[[<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<[[[.<-]>[>-]\x01qffb\x00\x00beep\x00]]]<[>]<<[>[-<+>]+<<]>[[>]>>[.>]]\x01

Weryfikacja!

Runiczne Zaklęcia , 29 bajtów

>>yyLL@"peeb"/
     @"peeb"L\

Wypróbuj online!

Zasadniczo taki sam jak odpowiedź Klein 000 lub odpowiedź <<> (zacząłem od Klein). Jedyną konieczną zmianą było włączenie< w Li .na  (tłumaczenie symboli poleceń), wstawienie punktów wejścia IP (potrzeba 2, w przeciwnym razie usunięcie spowodowałoby niekompilację programu) i wstawienie ypolecenia dela, aby uzyskać dwa adresy IP do scalenia (w ten sposób drukując tylko jeden beep), ponownie, wymagając dwóch. Wymagane było również wstawienie dodatkowych NOP, aby zachować takie same długości linii. Klein dogodnie używa również @do „drukowania i kończenia”.

Brak możliwości wykorzystania białych znaków w lewym dolnym rogu, ponieważ wszelkie reflektory zmieniające kierunek hamują zdolność wykrywania promieniowania. np. (26 bajtów, naświetlane y):

/yLL@"peeb"/
\<<  @"peeb"L\

Nie drukuje żadnych danych wyjściowych, ponieważ wygięty segment wejściowy powoduje odbicie z powrotem do terminatora dolnej linii.

Befunge-93 , 55 bajtów

<< >       vv
>,,@#"beep"<"
v  |   _ #-<_
>"peeb",,,,@>

Wypróbuj online! Weryfikacja!

Miałem nadzieję, że będzie trochę mniejszy, ale wąską szyją jest długość beepdrukarki.

Wumpus , 37 34 32 31 bajtów

777*7..@ $o&4"beep"|"@peeb"4&o@

Wypróbuj online! Weryfikacja!

To rozwiązanie wykorzystuje fakt, że . przeskakuje do modułu pozycji na długość programu.

Alternatywnie dla tej samej ilości bajtów

" @o&4"beep"}@
@o&4"beep"}$}  

Wypróbuj online! Weryfikacja!

Ten wykorzystuje różnicę w kierunku wskaźnika dla nieparzystych i parzystych długości linii. (Naprawdę nie wiem, jak działa pierwsza, "gdy nowa linia jest usuwana)

Klein (001), 26 bajtów

!.<<@"peeb"/
.@"peeb"..<..

Wypróbuj online!

Zweryfikować!

Wyjaśnienie

Ten program wykorzystuje unikalną topologię Kleina, w szczególności 001 topologię , czyli butelkę Kleina.

Bez edycji program podąża ścieżką wykonania:

Usunięcie bajtu z programu może mieć wpływ na program na 4 sposoby (każdy w innym kolorze):

Pierwszą rzeczą, na którą należy zwrócić uwagę, jest to, że na początku <<zawsze będzie odchylać ip z lewej strony źródła. Jeśli jeden z nich <zostanie usunięty, drugi zajmuje jego miejsce. Więc jeśli jakikolwiek bajt zostanie usunięty z czerwonej sekcji, zostanie podana następująca ścieżka wykonania:

Jeśli niebieski bajt zostanie usunięty, otrzymamy bardzo prostą ścieżkę:

Jeśli nowa linia zostanie usunięta, otrzymamy ścieżkę:

Żółta ścieżka jest nieco bardziej złożona. Ponieważ dolna linia jest o jeden dłuższa niż górna linia, gdy program zostanie podniesiony do kwadratu na początku wykonywania, na końcu pierwszego wiersza dodawany jest znak wirtualny, aby uzyskać taki sam rozmiar. Jeśli jakikolwiek bajt w drugiej linii zostanie usunięty, linia zostanie skrócona i ten wirtualny znak nie zostanie dodany. Jest to ważne, ponieważ !zwykle przeskakuje wirtualną postać, ale pod jej nieobecność przeskakuje /zamiast niej.

Backhand , 25 21 bajtów

vv""ppeeeebb""jjHH@

Wypróbuj online! Weryfikacja!

Wykorzystuje to zdolność Backhand do zmiany wartości kroku wskaźnika, aby pomijać instrukcję na każdym kroku i starannie rozwiązać problem redunancji. Następnie używa jpolecenia, aby sprawdzić, czy kod jest napromieniowany, przeskakując do ostatniego znaku ( @, zatrzymaj), jeśli nie, i przeskakując do ostatniego ostatniego ( H, zatrzymaj i stos wyjściowy), jeśli tak jest.