text:
Polycops and Robbers (Cops' Thread)
This is the cops' thread, the robbers' thread is here
A polyglot is a program, that without modification, can run in multiple languages.

Allowed languages
Any language that was made before the challenge and isn't made for the purpose of the challenge, it is allowed, though discouraged, to use languages that are easy to recognize

Cops' Challenge
To write a non-empty program that does one of the following tasks:

Adds two numbers from STDIN
Prints "Hello, World!"
Prints the first 20 terms of the Fibonacci sequence

Then, list the languages it works in (it must do the same thing in all languages). When you first post your answer, it is vulnerable, and robbers will try to find more languages it works in other than the ones you specified. If any robber finds a language, they comment on your question saying they cracked it. You should then edit your question saying it got cracked and list the languages you were missing.

If a week passes by and nobody cracked your submission, you can mark it as safe, no robbers can crack it.

Winning
Most upvoted safe answer is the winner.

Extra rules
Cops must know there is a language that the program runs in other than the ones they wrote, so that there's a guarantee that all answers are possible to crack.
And as always, standard loopholes apply.

You should define what sort of languages you are allowing. Can it be a language newer than the challenge? And it would probably be a good idea for the cop to be able to demonstrate it's a polyglot in yet another language to mark it as safe, so all solutions are crackable.

@Okx I will define what languages are allowed, but I don't understand the rest of your comment.

What is the winning criterion (i.e. how will answers be ranked after they are marked safe)?

@Doorknob Uhh, upvotes?

@dylnan Originally, no, but now that I think of it that's probably a good idea

@JoKing If a submission runs in any language, you can post it, and you should generally list all the languages you thought of except 1 of them

Different versions and different compilers are not different languages, correct?

@Stephen Correct.

The 20th digit of the Fibonacci sequence is the 2 in 233. Is this what you intended?

First time to see a CaR PopCon tbh. And maybe the 3rd task should be changd to "Prints the first 20 terms of Fibonacci sequence"?

@Nitrodon I meant the first 20 terms like Shieru said

Wow, cracked by Jo King while I'm still typing the explanations lol
'<?php '//'; #@ SPELL,WITH,ME, ,H,E,L,L,O, ,W,O,R,L,D,"'Hello, World!'"
$a = "'Hello, World!'";
if ([])
 console.log($a);
else {
 for ($i = 1; $i < strlen($a) - 1; $i++)
  echo($a[$i]);
}
// ?>'

Prints 'Hello, World!' (with single quotes) in both JavaScript and PHP. This should be an easy one to solve.
How this works
'<?php '//'; #@ SPELL,WITH,ME, ,H,E,L,L,O, ,W,O,R,L,D,"'Hello, World!'"
JS treats this line as a string '<?php ' followed by a // comment, and PHP prints ' (outside the tag, so literally), then starts the script with open tag, and a string '//', then a # comment.
$a = "'Hello, World!'";
Both JS and PHP defines the variable a to be the string "'Hello, World!'".
if ([])
 console.log($a);

In JS, since [] is consider truly, console.log($a) is executed and this prints out the string `"'Hello, World!'".
else {
 for ($i = 1; $i < strlen($a) - 1; $i++)
  echo($a[$i]);
}

In PHP, since [] is consider falsy, the for loop is executed and this prints out the characters Hello, World! (notice the absence of quotes) subsequently.
// ?>'
In JS this is a comment, but in PHP the close tag ends the script and the ' after the tag is printed out literally.

Yes, the remaining language is Befunge-93.
'<?php '//'; #@ SPELL,WITH,ME, ,H,E,L,L,O, ,W,O,R,L,D,"'Hello, World!'"
< redirects the IP to the end of the line, then "'Hello, World!'" is pushed in reversed order. After that the 15 ,s are used to output the characters (in normal order because of the double reversal). Finally @ terminates the program.

Cracked

@JoKing lol I was still typing the explanations when you cracked this

By the way, you weren't meant to print it with single quotes

@FireCubez Hmmmm but it's cracked anyway -- It's impossible to tell the cracker to delete his answer, is it? btw I had a pure JS+Befunge-93 one before, but that's just obvious and with too few languages.

@ShieruAsakoto Well it doesn't give you any advantage so it's fine I guess

Wait, don't unknown characters reverse the IP?

I swear even though I’ve seen this answer for 3 weeks this is the first time I realized the polyglot language wasn’t named “Wow”

@FireCubez A number of Befunge-93 interpreters do this, but it isn't part of the specifications. Befunge-98 does reflect though

Can you provide a link to the "Wow" language?

@a'_' The language was not Wow; It was PHP and Befunge-93

Oh I meant JS, PHP and Befunge-93

Almost all Befunges, Safe!
 &<v
@.+<

Try it online!
Starting it off with an easy one. This is adds two numbers from STDIN in every version of Befunge, 93, 96, 97, 98 etc. Thanks to Johnathan Allen for reminding me about Trefunge, Quadfunge, and all those variations as well. This doesn't work in Unefunge though.

The answer is Flobnar!
Try it online!
By the makers of Befunge, Flobnar is described as "what happens when you get Befunge drunk". It uses a lot of the same instructions, but goes backwards in comparison, starting at the @.
....
@...   Start here going left

....
..+<   Sum above the + and below

..&.   Both end up here and get input as a number
....

Implicitly output the return value

I thought someone would have gotten it since I've done a few things in Flobnar recently.

Is there another language you know it works on?

@FireCubez Yes, there is a language without the word funge in it that adds two numbers from STDIN

I was thinking of Trefunge for a second, but it has funge in it. Anyways your answer is safe now since a week has passed

Jelly and M, 15 bytes
+19Ð¡1-4181ḢFḊĊ

Try it online!
Prints the first 20 terms in the Fibonacci sequence.
Hexdump is
1B 21 29 0F 00 21 1D 24 21 28 21 B5 36 B1 B0

Edit: Three weeks and no crack? This shouldn't be too hard...

Congratulations on this being safe!

But what is the working language?

Hello World, Cracked
puts "Hello World!"

List of Languages it works in (minus a few :D):
05AB1E
05AB1E (Legacy)
2sable
Oasis
Ruby
Tcl
Cracked:
Working Language is Foo

Do I have to find all the languages it works in, or just one?

Just one, I'm pretty sure it works in a lot of languages

Ah, shoot, I didn't see Tcl at the end of your answer :(

cracked Always be careful with quotes

why are you so good!

It also works with Crystal.

Python, vulnerable
Also works in Coconut (Thanks BMO!)
Also works in Cython (which is a superset of Python, so why wouldn't it)
Adds two inputs together
(may have some garbage output before the output when run in the second language, let me know if that's not okay)
No longer has garbage output
Hint: The language name is somewhere on this page.
"""
" "- Z B.m " "" "" "" "" "" "" "[ K O.a- F R.d " "" "" "- C P.u- O T.h " "" "" "" "" "" "" "" "" "- T I.q- O K.a " "" "" "- H C.n- G Y.t " "" "" "" "" "" "" "" "> W C.a+ M T.a " "" "< D N.h] V T.r " "" "" "" "" "" "" "" "> D K.b- M S.i " "" "" "" "" "" "" "" ". U Y.u- I J.x " "" "" "" "" "[ X C.e- K U.m " "" "" "> L W.y+ F X.l " "" "" "+ D B.n+ V N.e " "" "" "" "" "" "" "" "" "+ L F.g+ T Q.k " "" "" "" "" "" "" "" "< L Z.f] V I.b " "" "" "" "" "" "" "" "" "> I O.s+ D F.p " "" "" "" "" "" "" "+ D P.g. W B.j" "+ J S.z+ X U.l " "" "+ J A.o+ L V.t " "" "" "" "" "" "" "" "" "+ R P.x+ Y L.j " "" "" "+ H W.s. Q P.l " "" "" "" "" ". N U.d+ C K.l " "" "" "" "" "" "" "" "+ U B.h+ W L.n " "" "" ". X L.k[ Q Y.v " "" "" "- F B.r- B X.z " "" "" "" "" "- M F.t> W L.v " "" "" "" "" "+ O W.x< F W.g " "" "" "" "" "" "] L P.y> M A.m " "" "" "" "" "" "" "- I K.x- F A.i " "" "" "" "" "- Z U.a- M M.t " "" "" "- C L.s. C C.j " "" "" "" "" "" "" "" "" "- T R.u- N U.i " "" "" "" "" "" "" "- U R.p[ F D.x " "" "" "" "" "" "" "" "" "- S P.o> C H.d " "" "" "" "" "" "" "" "+ O W.p+ N W.i " "" "" "" "" "" "" "" "" "+ U A.r< O A.k " "" "" "" "" "" "" "" "" "" "] A M.y> W H.m " "" "" "" "" "" "" "" "" ". G J.g- L M.p " "" "" "" "" "[ J K.k- P E.n " "" "" "" "" "" "" "- S V.y- U U.j " "" "" "" "" "" "" "" "> P T.v+ Z F.h" "< X R.g] J A.d " "" "" "" "" "" "" "" "> A U.f- U G.u " "" "" "" "- P L.o- I V.q " "" "" "" "" "" ". B Y.b+ H Y.r " "" "" "" "" "+ O Y.u+ P N.w " "" ". F K.n- D L.c " "" "" "" "" "- I G.g- D Y.m " "" "" "" "" "" "" "" "" "- B Y.h- S H.x " "" "" "" "- N R.k. K A.n " "" "" "" "" "" "- N F.r- F S.l " "" "" "" "" "" "" "" "" "- Q L.e- L J.f" "- S Q.o- K U.k " "" "- C I.h- A N.s" ". N P.t- D J.b " "" "" "" "" "" "[ I S.t- D A.j " "" "" "" "" "" "- N F.a- Z S.b " "" "" "" "" "> A G.g+ Z N.g " "" "< A K.t] U W.g " "" "" "" "" "" "> V D.b. Y U.j " "" "" "" "" "" "" "" "" "" "+ K F.j+ G M.t " "" "+ J E.c+ X S.i " "" "" "" "" "" "" "+ K F.r+ Z R.e " "" "" "" "" "" "" "" "+ S X.p+ Q R.h " "" "" "" "" "+ E L.p+ J U.p " "" "" "" "" "" "" "" "+ F G.z. K S.s " "" "" "- Y O.k- C P.i " "" "" "" "" "" "" "- H N.v- O C.k " "" "" "" "- S J.x- H O.p " "" "" "- X D.p- W E.h " "" "" "- K F.v- B X.q " "" "" "" "- M Z.a- W E.d " "" "" "" "" "" "" ". N Y.a+ T H.r " "" "" "" "" "" "" "" "" "+ R S.c+ U Q.k " "" "" "" "" "" "" "" "+ U D.s[ U L.o " "" "" "" "- E U.u> V C.l " "" "" "" "" "" "" "" "" "" "+ N U.d+ E H.x " "" "" "" "" "< M W.v] C S.i " "" "" "" "> F U.p+ G F.a " "" "" "" ". G S.c- K C.l " "" "" "" "" "" "[ M J.p- R G.w " "" "> Z M.q+ Z J.e " "" "" "" "+ Y Q.k+ S L.c " "" "" "" "" "+ Q R.i< Y C.l " "" "" "" "" "] L F.h> M K.r " "" "" "" "" "" "" "" ". Z K.q- K R.c " "" "" "" "" "" "" "" "" "" "[ Q R.u- W L.x " "" "" "" "" "" "" "- D C.g- Z T.a " "" "" "" "" "" "" "" "" "" "> L G.u+ R M.h " "" "" "+ G U.c< R C.s " "" "] N D.n> W T.u " "" "" "" "" "" "" "" "- I X.d- W Q.l " "" "" "" "" "" "" ". H Z.a- P C.n " "" "- F P.i- R O.x " "" "- R R.w- J Q.j " "" "- H R.y- C D.y " "" "" "" ". L A.t+ K C.t " "" "" "" "" "" "" "" "" "[ G P.o- N N.j " "" "- Q V.x- S V.b " "" "" "" "> U K.u+ Q F.x " "" "" "" "" "" "< M U.v] P I.c " "" "" "" "" "" "" "" "" "> S U.t. U G.t " "" "" "+ Z N.k[ X Y.t " "" "" "" "- E Y.v> L W.c" "+ K S.g+ S B.h " "" "" "+ K V.a< Z C.z " "" "" "] G C.n> J Z.u " "" "" "" "" "" "" "" ". U K.t- G V.o " "" "" "" "" "- K Z.f[ K J.e " "" "" "" "" "" "" "" "" "" "- J B.l- S N.f " "" "" "" "" "" "" "" "" "- O L.w> G J.z " "" "" "+ X V.y< G F.a " "" "" "" "" "" "" "" "] M V.z> L N.x" "- Z R.r. V R.x " "" "" "" "[ G R.h- D O.g " "" "" "" "" "" "" "> W I.g+ R C.x " "" "" "" "+ S F.h+ B G.m " "" "< B G.f] L D.z " "" "" "" "" "> F O.a+ K M.h " "" "" "" "" "" "+ V F.x. P V.w " "" "" "" "" "" "" "" "" "- C X.z. A L.x " "" "" "" "" "" "" "" "" "+ M J.b+ I O.t " "" "" "" "" "" "+ Z Y.q. N I.h" "- T W.e[ W K.o " "" "" "" "" "" "" "" "" "- S M.a- P O.d " "" "" "" "" "- B T.g> W K.s " "" "" "" "" "" "" "" "+ D V.g< O J.f " "" "" "" "" "" "] O O.r> C Z.f " "" "- W L.b. P F.d " "" "" "" "" "" "" "" "" "" "+ Y P.t[ H O.h " "" "" "" "- O Z.c- C A.z " "" "" "" "" "- X Y.g- O Q.g " "" "" "" "" "" "- N E.n> G C.s " "" "" "" "" "" "" "+ B I.g< Z P.a " "" "" "] H F.y> G J.j " "" "" "" "" "" "+ N R.u. G D.q " "" "" "" "" "" "" "" "- A F.e- P C.i " "" "" "" "- W L.i- L V.d " "" "" "" "" "" "- X P.r- Y S.x " "" "- F C.n- G N.o" "- Z A.q. K Q.j " "" "" "" "" "" "[ S B.n- W C.l " "" "" "" "" "" "" "- N Q.g- O M.h " "" "" "" "" "" "" "" "" "" "> J T.f+ M N.h " "" "" "" "" "" "< O C.w] J E.l " "" "" "" "" "" "" "" "" "" "> F N.c. Z H.d " "" "" "" "" "" "- G M.n- L S.x " "" "" "" "" "" "- S Z.h- C M.l" ". C S.z+ G I.a " "" "" "" "" "" "" "" "[ D W.g- C P.j " "" "- H V.t- C T.p " "" "" "" "- F F.o> Y A.s " "" "" "" "" "" "" "" "" "" "+ O R.g< I V.h " "" "" "" "" "" "] D H.p> H D.j " "" "" "" "" "+ O G.c+ I Z.p " "" "" "" "" "" "" "" "+ S R.f. I J.m " "" "" "" "" "" "+ H Z.l+ X V.h " "" "" "" "" "" "" "[ Y M.m- L O.r " "" "" "" "" "" "" "" "" "" "> B Z.n+ D W.x " "" "" "" "+ Z C.m+ X Q.t " "" "" "" "" "" "" "" "" "" "< S E.w] L Y.n" "> V F.b. V S.z " "" "+ C M.n+ L K.n" "+ S S.y+ S O.b " "" "" "" "" "" "" "" "" "" "+ R G.y+ K X.j " "" "" "" "+ F O.g+ A C.z " "" "+ R L.q. S N.g " "" "" "" "" "" "" "" "" "" "+ X L.x+ C F.x " "" "" "" "" "" "" "+ C O.x. G A.h " "" "" "" "" "" "" "" "" "" "[ Z L.u- A P.o " "" "" "" "- O H.i> U Q.v" "+ F A.d+ E T.n " "" "" "+ B S.o+ F B.y " "" "" "+ L S.r< O X.n " "" "" "" "" "" "" "] C D.h> H O.d " "" "" "" "" "" "+ X O.x+ H Q.b " "" "+ E S.n. M X.q " "" "" "- D S.j- U E.l " "" "" "" "" "" "" "[ H J.g- A R.a " "" "" "" "> T X.s+ D C.d " "" "" "" "" "" "+ G X.p+ I J.l " "" "" "" "" "" "" "" "" "" "+ F K.i< C Q.h" "] X L.c> X V.i " "" "" "" "" "+ B Q.t. S J.j " "" "" "" "" "- L J.v- D C.h " "" "" "" "" "" "- F D.f- R N.u " "" "" "" "" "" "- T Y.p- R S.p " "" "" "" "" "" "" "- V S.y- X U.r " "" "" "" "" "" "" "- H E.r- H O.l" ". I A.a+ C S.u " "" "" "" "" "" "" "" "" "+ S B.q+ L N.j " "" "" "" "" "" "" "+ B F.u+ L X.r " "" "" "" "" "" "" "+ V C.b. K P.l" "- U K.l[ P S.q " "" "" "" "" "" "" "- Z E.u- P M.s " "" "" "" "" "" "- I P.z- A W.f " "" "" "" "> W A.x+ S B.l " "" "" "" "" "" "< P H.m] T C.l " "" "" "" "" "" "" "" "" "" "> D N.o+ H T.w " "" "" "+ H X.n+ S Y.g " "" "" "" "" ". L C.b- M N.h " "" "" "" "" "- D B.q- X C.s " "" "" "" "" "" "[ D Y.o- L W.z " "" "" "> D N.n+ C P.o " "" "" "" "" "+ A V.a+ X X.w " "" "" "" "" "+ L T.l< V K.s" "] C E.f> C I.o " "" "" "" "" "" "" "" "" "" ". O C.a- L B.a " "" "- E Q.c- I F.h " "" "" "" "" "" "- A Y.q- K T.a" "- C Y.h- F A.e " "" "" "" "" "" "- M D.h- L I.z " "" "" "" "" "- X G.c- M F.x " "" "" "" "- P U.s. N F.f " "" "" "" "" "" "" "" "" "+ A E.c+ F B.k " "" "" "" "" "" "" "+ Q K.f+ W I.y " "" "" "" "" "+ E S.a+ R S.o " "" "" "+ N Y.a. J G.u " "" "+ L V.i+ X T.y " "" "" "+ S F.l+ O Y.i " "" "" "" "" "" "" "" "" "" "+ Q V.e+ S Q.l " "" "" "" "" "" "" ". O A.g+ W S.r " "" "" "" "" "" "" "" "" "+ Z D.e[ N A.l " "" "" "" "- A D.b> I K.a " "" "" "" "" "" "+ E U.c+ E O.x " "" "" "" "" "" "" "" "+ P D.h< G K.g " "" "" "" "" "] G X.b> H W.g " "" "" "" "" "" "" "" "+ K D.c+ H B.f " "" "" ". K Z.e+ M P.p " "" "" "" "" "" "" "" "" ". A L.n- O B.m" "- P T.z- C S.w " "" "" "" "" "" "" "" "- Q Y.e[ I N.g " "" "- X A.q> Y L.i" "+ I Y.u+ T A.w " "" "+ B Z.t< W U.z " "" "" "" "" "" "" "] R S.i> U S.a " "" "" "" "" "" "" "" "" ". O T.a- M D.f " "" "" "" "" "" "- H U.s- V O.g " "" "" "" "" "" "" "" "- O H.p- O L.v " "" "" "" "" "" "" "" "" "" "- X R.b- U V.w " "" "" "" "" "" "- G H.w- E R.n " "" "" "" "" "" "" "" "" "" "- R J.c- H S.p " "" "" "" "- J A.x. F W.h " "" "" "" "" "" "" "" "" "[ J R.s- F R.c " "" "" "" "" "" "" "> L H.w+ Z A.z " "" "" "" "+ Z O.s+ S D.u " "" "" "" "" "" "" "" "< B C.k] J F.k" "> P C.t+ H C.q " "" "" "" "" "" "" "" "" "+ N B.e. V S.t " "" "" "" "" "[ Q M.p- M C.m " "" "" "" "" "" "" "- B A.r- Q C.y " "" "" "> F D.t+ A G.r " "" "< A V.d] X H.m " "" "" "" "" "" "" "" "> J E.x- Y P.d " "" "- E T.h- P I.p " "" "" "" "" "" "" "" "- R O.f. I B.f" "+ P M.n+ N L.j " "+ N Z.c[ Y V.z " "" "" "- K G.k> D F.u " "" "" "+ L D.e+ W I.k " "" "" "" "" "" "+ P M.k< X Y.y " "" "" "" "" "" "] O L.n> Q K.e " "" "" "" "+ R M.t+ C B.i " "" "" ". E J.g+ I C.a " "" "" "" "" "" "" "" "" "" "+ C C.k+ B I.e " "" "" "" "" "" "" "" "" "+ T U.d+ K D.x " "" "" "" "" "" "" "+ F K.p+ M O.h " "" "" "" "" "" "" "+ Q H.e. M Z.a " "" "" "" "+ I Q.m+ W M.d " "" "" "" "+ A I.y+ G H.u " "" "" "" "" "" "" "+ E U.j. Z W.z " "" "" "" "" "" "" "" "" "- G X.r- R V.h " "" "- I P.a- M X.d " "" "" "" "" "" "" "" "" "- V M.q- C M.z " "" "" "" "" "" "- P K.l- N L.r " "" "" "" "" "" ". L D.t- G A.f " "" "" "" "" "" "" "" "" "" "[ T J.f- M X.p " "" "" "" "" "" "" "- V P.t- G Z.f " "" "> T O.h+ S Q.r " "" "" "" "" "" "" "" "" "< Z S.r] D P.v " "" "" "" "" "" "" "> G Q.n- F M.v " "" "" "" "" "" "" "" "" "- P Z.g. N S.d " "" "" "" "" "" "" "" "" "" "+ E G.x[ U N.t " "" "" "- R J.z> Y Y.e " "" "" "" "" "" "" "" "+ V N.x+ V U.s " "" "" "" "" "+ W P.s< S P.m " "" "" "" "" "" "" "" "] G O.x> X J.d " "" "" "" "" "" "+ X E.l. Z T.o " "" "" "" "+ T N.l+ L U.t " "" "" "" "+ C L.i+ Z M.g" "+ M K.k+ E P.p " "" "" "" "" "+ P T.l+ S Z.h" ". F W.k- Q D.q " "[ O I.r+ K W.r " "" "" "+ J B.x> F A.s " "" "" "" "" "" "" "" "" "- Y D.b- O H.r " "" "" "" "" "" "- W N.a< H S.e" "] N F.o> Q I.y " "" "" "" "" "" "+ B V.w. Q G.b " "" "" "- J R.i[ B M.j" "- Q R.a- K V.v " "" "" "- M S.b> W O.i " "" "" "" "" "" "" "" "" "+ C D.t+ T X.o " "" "" "" "" "" "" "" "" "< S C.m] T F.f " "" "" "" "" "" "" "" "" "" "> E Q.z- O B.w " "" "" "" "" "" "" ". Z T.a+ X L.t" "+ H U.f+ B E.x " "" "" "" "" "" "" "" "+ K A.c+ A E.p " "" "" "" "" "+ S N.v+ P P.h " "" "" "" "" "" "" "" "+ R C.f+ I I.y " "" "" "" "" "" "" "" "" "+ N C.h. U P.x " "" "" "" "" "" "" "- D Q.c- I K.k " "" "" "" "" "" "" "" "" "- U U.c- A X.j " "" "" "" "" "" "" "" "" "" "- N B.u. A J.p " "" "" "" "" "[ N K.j+ L H.t " "" "" "" "" "+ D E.j> T Q.c" "- B U.z- A N.e " "" "" "- C J.k< D O.n " "" "" "" "" "" "" "" "" "] O U.c> Z J.e " "" "" "" "" "" "+ K E.m+ B O.p" ". H S.l[ T N.r " "- Z M.e> D Q.i " "" "" "" "" "" "" "" "+ K B.v+ S P.o " "" "" "" "" "+ Q O.w< Y D.o " "" "" "" "] I C.n> R H.i " "" "" "" "" "" "" "- I F.z. L Q.t " "" "[ W U.q- A C.q " "" "" "" "- H U.l- V P.f " "" "" "- J Z.n> C Y.j " "" "" "" "" "" "" "+ E Y.b< J Q.g " "" "" "" "" "" "] F W.x> X H.c " "" "+ Z X.r+ O K.g " "" "" "" "+ Y Q.f. X Z.d " "" "" "" "" "" "" "[ O G.z- F K.u " "" "> P Z.o+ M D.s " "" "" "" "" "" "" "" "+ L G.h+ Z M.l " "" "" "" "" "" "" "" "" "" "< J L.y] O U.x " "" "" "" "" "> L K.q+ P U.c " "" "" "" ". F H.l+ X W.j " "" "" "" "" "" "" "+ N I.x. U A.u " "" "" "" "" "" "" "" "- Y B.m[ X W.a " "" "" "" "" "" "" "" "" "" "- B X.u- V G.w " "" "" "" "" "- D N.d> M Q.g " "" "" "" "" "" "" "" "+ I I.w< E P.u " "" "] F V.k> I U.s " "" "" "" "" "" "" "- F P.b- B H.u " "" "" "" "" "" ". J X.n+ G E.e " "" "" "" "" "" "" "" "" "" ". U J.t[ T C.l " "" "" "" "" "- O K.g> T L.r " "" "" "" "" "" "" "" "+ W A.a+ O Z.g " "" "+ A N.e< Q N.q " "" "" "" "" "] W U.k> Y J.w " "" "" "" "" "" "" "" "" "+ V V.k+ Y L.w " "" "" "" ". S V.k+ P C.h " "" "" "" "" "" "+ C G.v+ N F.d " "" "" "" "" "" "" "" "" "" "+ K P.u+ R J.z " "" "+ E R.y+ I I.p " "" "" "" "" "" "" "" "" "" "+ Y H.z+ G U.v " "" "+ T E.o+ G S.g " "" "" "" ". S A.u. Z X.n " "" "- L S.x[ M X.z " "" "" "" "" "" "" "" "" "- V Z.e- S C.p " "" "" "" "" "- T H.m> E B.m " "" "" "" "" "" "" "" "" "" "+ Q T.t< N Z.g " "" "" "] R I.y> B J.k " "" "" "" "" ". V V.r- L T.x " "" "" "" "" "" "" "" "[ L Z.s- T Y.p " "" "" "" "" "" "- N A.p- W X.q " "" "" "" "" "" "" "- M D.t> Z Y.r " "" "" "" "+ B Q.u< L C.m" "] V R.j> Z D.y " "+ A C.j+ P S.w " "" "" "" ". V K.r- E N.s " "" "" "" "" "- C F.n- Q B.p " "" "" "" "" "" "[ R E.d- H Y.r " "" "" "" "" "" "> H D.v+ X E.h" "+ V R.j+ C C.m " "+ C Q.j< Q X.b " "" "" "" "" "" "" "" "" "] Y J.g> K Y.s " "" "" "" "" "" "" "" ". T R.i- K R.f " "" "" "" "" "" "" "" "- B U.o- Z I.n " "" "" "" "" "" "" "" "- I X.s- G D.p" "- B C.i- K G.c " "- V G.i- P Y.f " "" "" "" "- V G.t- U D.s " "" "" "" "" "" "" "" "" "- K P.f. F X.m " "" "" "" "" "- O B.l- S C.e " "" "" "" "" "" "- B K.l. D Z.f " "" "- U K.m- J F.z " "" "" "" "[ H N.l- D G.i " "" "" "" "" "" "" "" "" "- Y T.u- Z R.s " "" "> Z O.p+ D V.g" "< Q W.w] W K.w " "" "" "" "" "" "> O V.l- I A.w " "" "" "" "" "" "" ". B L.j+ H C.k " "" "" "" "" "" "" "+ B W.w[ H T.q " "" "" "" "" "" "" "" "- Z F.z- H S.u" "- K B.j> M T.w " "" "" "" "" "" "" "+ Q N.d+ G K.a " "" "" "" "" "" "< W U.e] H M.u " "" "" "" "" "> B Q.u. O J.r " "" "" "" "" "" "" "" "- Z G.n- H K.i " "" "" "" "" "" "" "" "" "- I E.j- X U.y " "" "" "" "" "- L O.u- J D.h " "" "" "- X F.q- P J.v " "" "- E T.u- X M.c " "" "" "" "" "- S P.y. U S.z " "" "" "" "" "" "" "" "" "+ E C.l+ S N.y " "" "+ T N.r+ J F.s " "" "" "" "" "" "" "" "+ U I.x+ I P.o " "" "" "" "+ F Z.e+ P E.k " "" "" "" "" "" "" "+ G J.k+ X Y.w " "" "" "" "" "" "" "+ Z Z.d+ Y B.b " "" "+ F A.d. R W.p " "" "" "- M A.z- Y R.l " "" "" "" "" "" "" "- Z L.a- E X.h " "" "" "" "" "" "" "" "" "" "- I G.d- H J.b " "" "- U E.n. H X.k " "" "" "- V E.s- S F.h " "" "" "" "[ L A.x- A C.l " "" "" "" "- P O.q- X J.x " "" "" "> M X.u+ W H.s " "" "" "< H T.p] V U.o " "" "" "" "" "> P Z.v- C K.a " "" "" "- U J.p. V N.l " "" "" "" "" "" "" "" "" "" "[ L T.u- N K.d " "" "" "" "" "" "" "" "" "> I G.u+ Z N.g " "" "" "" "" "" "" "" "" "" "+ H K.j+ M S.h " "" "" "" "" "" "" "" "< F M.t] D J.z " "" "" "" "" "" "" "> E K.d+ J M.c " "" "" "" "" "" "" "" "" "+ O M.u. A P.k " "" "" "" "" "" "" "" "" "+ R V.v+ U I.e " "" "+ Z C.m+ L L.m " "" "" "" "" "+ B Z.d+ O R.s " "" "" "" "" "" ". B D.m- W R.x " "" "" "" "" "" "" "" "- W H.b. S R.g " "" "- Y N.a- P L.b " "" "" "" "" "" "" "" "[ T M.k- D H.x " "" "" "" "" "" "" "" "" "- P I.s- U A.z " "" "" "" "> E B.m+ O I.t " "" "" "" "" "< T N.c] A D.t " "" "" "> Q I.y- Z P.y " "" "" "" "" "" "" "" "" ". M B.t- N E.j " "" "" "- K T.z- Y S.p " "" "" "" "" "" "" "" "[ D J.x- V R.z" "> R Q.i+ C G.h " "" "+ Z V.a+ U C.n " "" "" "" "" "" "" "" "+ D U.s< W C.x " "" "" "" "" "" "] F A.j> J L.h " "" "" "" "" "" ". N U.r- R F.n " "" "" "" "" "- V N.s- T L.n " "" "" "" "- V E.i- T G.n" "- O M.r- Z A.g " "" "" "" "" "" "" "- A Q.h- S Z.n " "" "" "" "" "" "- Q G.q- L X.p " "" "- Z D.k. M C.a" "- P M.e- V S.u " "" "" "" "" "" "" "- S I.k- B W.o " "" "" "" "" "" "" "" "" "" "- C W.o- U U.m " "" "" "" "" "" "" "" "" "- V C.o. Q F.i " "" "" "" "" "" "" "" "" "" "- P N.w- S Y.l " "" "" "" "" "" "" "" "" "" "[ J R.h- D A.k " "" "" "" "" "" "" "" "" "" "- N A.o- Q L.g " "" "> P L.c+ L T.n " "" "" "" "" "" "" "< O W.o] P O.v " "" "" "" "" "" "> K G.h- T O.j " "" "" "" "" ". P J.u[ O W.x " "" "" "" "" "" "- I F.c- N Z.c" "- S U.e- L D.y " "" "" "" "" "" "" "" "" "" "> E Y.l+ X Y.l " "" "" "" "" "" "< L S.q] P K.c " "" "" "" "" "" "" "> D V.l+ M F.a " "" "" "" "" "" "" "" "+ F F.f+ C N.z " "" "" "" "" "" "" "" ". E D.d- P J.p " "" "" "" "" "" "- Q Z.c- E T.w " "" "" "" "" "[ O E.t- C G.w " "" "" "" "" "" "> D F.a+ S X.d " "" "" "" "+ V Z.a+ O V.x " "" "" "" "" "" "" "" "" "+ I Z.z< N H.f " "" "" "" "" "] E L.n> U V.m " "" "" "" ". G E.r- P T.n " "" "" "" "" "" "- H U.p- N J.v " "" "" "" "" "" "" "" "" "" "- D W.g- Q P.f " "" "" "" "" "" "- I S.w- L L.d " "" "" "" "" "" "" "" "- O S.j- I W.u " "" "" "" "" "" "" "" "- F J.m- Q D.s " "" "" "- T C.v. F L.z " "" "" "" "" "" "" "" "+ C J.k. Z B.m " "" "" "" "" "" "" "" "" "" "+ Y J.r+ B G.n " "" "" "" "" "" "" "" "" "+ P P.c+ T F.x " "" "" "" "" "" "" "" "" "" "+ U A.k+ A W.x " "" "" "" "" "" "" "" "" "+ L R.s+ U U.b " "" "" "" "" "" "" "" "+ Z B.t+ C J.g " "" "" "" ". Z Q.v+ Q W.l " "" "" "[ M C.i- J A.p" "- N V.p- V V.s " "" "- V O.v> M C.w " "" "" "" "" "" "" "" "+ M O.f< I U.j" "] A G.b> Z D.z " "" "" "" "" "+ O J.h+ X K.u " "" "" "" "" "" "" "+ Y I.r. Y E.u " "" "" "" "" "" "" "" "" "- V P.s- R I.g " "" "- Q J.u[ V I.e " "" "" "" "" "- D B.g- C Z.f " "" "" "" "" "" "" "- C E.f- U K.k " "" "" "" "" "" "" "" "" "- Z P.e> D N.y " "" "" "" "" "+ V K.k+ A J.b" "< C E.l] B E.t " "" "" "> D R.p. D L.a " "" "" "" "+ A H.q+ H Y.w " "" "" "" "+ K A.o. M X.k " "" "" "" "- M C.o- B N.c " "" "- F T.w- J F.u " "" "" "" "" "- N Q.i- W K.j " "" "" "- D V.q. E W.g " "" "" "+ C X.p+ R T.y" "+ R P.j+ B S.a " "" "+ D B.i. M G.c" "+ N B.l[ I N.x " "" "" "" "" "" "" "" "" "- Z R.w- P W.n " "" "" "" "" "" "" "" "- C B.h- R P.m " "" "" "" "> S I.t+ H L.n " "" "" "" "" "" "" "" "< G O.e] T Z.w " "" "" "" "" "" "> A Q.k+ N V.q " "" "" "" "" "+ E S.y+ D C.n " "" "" "" ". U E.f- Z A.p" "[ Y C.q- D O.p " "" "" "" "" "" "" "- D R.g- M A.k " "" "" "" "" "> Q D.j+ D E.r " "" "" "" "+ W W.p< E T.y " "" "" "" "" "" "" "" "" "] V P.g> G E.x " "" "" "- L O.p. S P.r " "" "" "" "" "" "" "" "+ B F.q+ G X.x " "" "" "" "" "" "" "" "" "" "+ W X.q+ O E.o" "+ E Z.v. Q G.w " "[ H H.n- C F.x " "" "" "- N L.j- Z N.t " "" "" "" "" "" "" "" "- L G.e- F Y.y " "" "" "" "" "" "" "" "> C L.l+ T R.l " "" "" "" "" "" "" "" "" "" "+ Q F.e< Z D.g " "" "" "" "" "" "" "" "" "" "] W I.i> S T.z " "" "" "" "+ V Z.s+ Y W.r " "" "" "" "" "" "" "" ". R C.e+ O A.d " "" "" "" "" "" "" "" "" "+ J P.b[ H W.i " "" "" "" "" "" "- L F.u- H D.k" "- H Q.w> L Y.c " "" "" "" "" "" "" "" "+ B F.p+ J U.y " "" "" "< X U.c] N E.p " "" "" "" "" "" "" "" "" "> W M.k. J W.n " "" "" "> C K.i- T R.l " "" "" "" "" "" "" "" "" "" "[ S A.c- D W.w " "" "" "" "" "" "" "" "" "" "- R I.g- M F.p " "" "" "" "" "" "" "" "" "> I V.e+ Q U.j " "" "" "< T U.p] I C.j " "" "" "" "" "> W E.t- U O.y " "" "" "" "" "- I S.l. H M.t " "" "" "" "[ A Z.w- F H.x " "" "" "" "" "" "" "" "" "- M A.p- S J.k " "" "" "" "" "" "" "" "" "" "> F X.s+ F A.a" "< P A.c] I G.r " "" "> Y W.m- K F.l " "" "" "" "" "" "" "- V W.e. G Q.u " "" "" "" "" "" "" "" "" "" "+ S C.t+ F W.y " "" "" "" "+ I S.v. N Y.k " "" "" "" "" "" "" "" "" "" ". U Q.f+ V K.f " "" "+ N S.m+ W Y.u " "" "" "+ X X.j+ I I.m " "" "" "" "" "" "+ V I.g+ B Z.f" ". Q Q.q- L A.e " "" "" "" "" "" "[ F O.w- Z K.v " "" "- P I.b- M X.r " "" "" "" "" "" "- H O.n> I R.e " "" "" "+ V S.b< P U.a " "" "" "" "] Y G.g> S C.l " "" "" "" "" "" "" "" "" "+ X I.z+ P I.n"+ Q E.q" ""- Z B.m " "" "" "" "" "" "" "[ K O.a- F R.d " "" "" "- C P.u- O T.h " "" "" "" "" "" "" "" "" "- T I.q- O K.a " "" "" "- H C.n- G Y.t " "" "" "" "" "" "" "" "> W C.a+ M T.a " "" "< D N.h] V T.r " "" "" "" "" "" "" "" "> D K.b- M S.i " "" "" "" "" "" "" "" ". U Y.u- I J.x " "" "" "" "" "[ X C.e- K U.m " "" "" "> L W.y+ F X.l " "" "" "+ D B.n+ V N.e " "" "" "" "" "" "" "" "" "+ L F.g+ T Q.k " "" "" "" "" "" "" "" "< L Z.f] V I.b " "" "" "" "" "" "" "" "" "> I O.s+ D F.p " "" "" "" "" "" "" "+ D P.g. W B.j" "+ J S.z+ X U.l " "" "+ J A.o+ L V.t " "" "" "" "" "" "" "" "" "+ R P.x+ Y L.j " "" "" "+ H W.s. Q P.l " "" "" "" "" ". N U.d+ C K.l " "" "" "" "" "" "" "" "+ U B.h+ W L.n " "" "" ". X L.k[ Q Y.v " "" "" "- F B.r- B X.z " "" "" "" "" "- M F.t> W L.v " "" "" "" "" "+ O W.x< F W.g " "" "" "" "" "" "] L P.y> M A.m " "" "" "" "" "" "" "- I K.x- F A.i " "" "" "" "" "- Z U.a- M M.t " "" "" "- C L.s. C C.j " "" "" "" "" "" "" "" "" "- T R.u- N U.i " "" "" "" "" "" "" "- U R.p[ F D.x " "" "" "" "" "" "" "" "" "- S P.o> C H.d " "" "" "" "" "" "" "" "+ O W.p+ N W.i " "" "" "" "" "" "" "" "" "+ U A.r< O A.k " "" "" "" "" "" "" "" "" "" "] A M.y> W H.m " "" "" "" "" "" "" "" "" ". G J.g- L M.p " "" "" "" "" "[ J K.k- P E.n " "" "" "" "" "" "" "- S V.y- U U.j " "" "" "" "" "" "" "" "> P T.v+ Z F.h" "< X R.g] J A.d " "" "" "" "" "" "" "" "> A U.f- U G.u " "" "" "" "- P L.o- I V.q " "" "" "" "" "" ". B Y.b+ H Y.r " "" "" "" "" "+ O Y.u+ P N.w " "" ". F K.n- D L.c " "" "" "" "" "- I G.g- D Y.m " "" "" "" "" "" "" "" "" "- B Y.h- S H.x " "" "" "" "- N R.k. K A.n " "" "" "" "" "" "- N F.r- F S.l " "" "" "" "" "" "" "" "" "- Q L.e- L J.f" "- S Q.o- K U.k " "" "- C I.h- A N.s" ". N P.t- D J.b " "" "" "" "" "" "[ I S.t- D A.j " "" "" "" "" "" "- N F.a- Z S.b " "" "" "" "" "> A G.g+ Z N.g " "" "< A K.t] U W.g " "" "" "" "" "" "> V D.b. Y U.j " "" "" "" "" "" "" "" "" "" "+ K F.j+ G M.t " "" "+ J E.c+ X S.i " "" "" "" "" "" "" "+ K F.r+ Z R.e " "" "" "" "" "" "" "" "+ S X.p+ Q R.h " "" "" "" "" "+ E L.p+ J U.p " "" "" "" "" "" "" "" "+ F G.z. K S.s " "" "" "- Y O.k- C P.i " "" "" "" "" "" "" "- H N.v- O C.k " "" "" "" "- S J.x- H O.p " "" "" "- X D.p- W E.h " "" "" "- K F.v- B X.q " "" "" "" "- M Z.a- W E.d " "" "" "" "" "" "" ". N Y.a+ T H.r " "" "" "" "" "" "" "" "" "+ R S.c+ U Q.k " "" "" "" "" "" "" "" "+ U D.s[ U L.o " "" "" "" "- E U.u> V C.l " "" "" "" "" "" "" "" "" "" "+ N U.d+ E H.x " "" "" "" "" "< M W.v] C S.i " "" "" "" "> F U.p+ G F.a " "" "" "" ". G S.c- K C.l " "" "" "" "" "" "[ M J.p- R G.w " "" "> Z M.q+ Z J.e " "" "" "" "+ Y Q.k+ S L.c " "" "" "" "" "+ Q R.i< Y C.l " "" "" "" "" "] L F.h> M K.r " "" "" "" "" "" "" "" ". Z K.q- K R.c " "" "" "" "" "" "" "" "" "" "[ Q R.u- W L.x " "" "" "" "" "" "" "- D C.g- Z T.a " "" "" "" "" "" "" "" "" "" "> L G.u+ R M.h " "" "" "+ G U.c< R C.s " "" "] N D.n> W T.u " "" "" "" "" "" "" "" "- I X.d- W Q.l " "" "" "" "" "" "" ". H Z.a- P C.n " "" "- F P.i- R O.x " "" "- R R.w- J Q.j " "" "- H R.y- C D.y " "" "" "" ". L A.t+ K C.t " "" "" "" "" "" "" "" "" "[ G P.o- N N.j " "" "- Q V.x- S V.b " "" "" "" "> U K.u+ Q F.x " "" "" "" "" "" "< M U.v] P I.c " "" "" "" "" "" "" "" "" "> S U.t. U G.t " "" "" "+ Z N.k[ X Y.t " "" "" "" "- E Y.v> L W.c" "+ K S.g+ S B.h " "" "" "+ K V.a< Z C.z " "" "" "] G C.n> J Z.u " "" "" "" "" "" "" "" ". U K.t- G V.o " "" "" "" "" "- K Z.f[ K J.e " "" "" "" "" "" "" "" "" "" "- J B.l- S N.f " "" "" "" "" "" "" "" "" "- O L.w> G J.z " "" "" "+ X V.y< G F.a " "" "" "" "" "" "" "" "] M V.z> L N.x" "- Z R.r. V R.x " "" "" "" "[ G R.h- D O.g " "" "" "" "" "" "" "> W I.g+ R C.x " "" "" "" "+ S F.h+ B G.m " "" "< B G.f] L D.z " "" "" "" "" "> F O.a+ K M.h " "" "" "" "" "" "+ V F.x. P V.w " "" "" "" "" "" "" "" "" "- C X.z. A L.x " "" "" "" "" "" "" "" "" "+ M J.b+ I O.t " "" "" "" "" "" "+ Z Y.q. N I.h" "- T W.e[ W K.o " "" "" "" "" "" "" "" "" "- S M.a- P O.d " "" "" "" "" "- B T.g> W K.s " "" "" "" "" "" "" "" "+ D V.g< O J.f " "" "" "" "" "" "] O O.r> C Z.f " "" "- W L.b. P F.d " "" "" "" "" "" "" "" "" "" "+ Y P.t[ H O.h " "" "" "" "- O Z.c- C A.z " "" "" "" "" "- X Y.g- O Q.g " "" "" "" "" "" "- N E.n> G C.s " "" "" "" "" "" "" "+ B I.g< Z P.a " "" "" "] H F.y> G J.j " "" "" "" "" "" "+ N R.u. G D.q " "" "" "" "" "" "" "" "- A F.e- P C.i " "" "" "" "- W L.i- L V.d " "" "" "" "" "" "- X P.r- Y S.x " "" "- F C.n- G N.o" "- Z A.q. K Q.j " "" "" "" "" "" "[ S B.n- W C.l " "" "" "" "" "" "" "- N Q.g- O M.h " "" "" "" "" "" "" "" "" "" "> J T.f+ M N.h " "" "" "" "" "" "< O C.w] J E.l " "" "" "" "" "" "" "" "" "" "> F N.c. Z H.d " "" "" "" "" "" "- G M.n- L S.x " "" "" "" "" "" "- S Z.h- C M.l" ". C S.z+ G I.a " "" "" "" "" "" "" "" "[ D W.g- C P.j " "" "- H V.t- C T.p " "" "" "" "- F F.o> Y A.s " "" "" "" "" "" "" "" "" "" "+ O R.g< I V.h " "" "" "" "" "" "] D H.p> H D.j " "" "" "" "" "+ O G.c+ I Z.p " "" "" "" "" "" "" "" "+ S R.f. I J.m " "" "" "" "" "" "+ H Z.l+ X V.h " "" "" "" "" "" "" "[ Y M.m- L O.r " "" "" "" "" "" "" "" "" "" "> B Z.n+ D W.x " "" "" "" "+ Z C.m+ X Q.t " "" "" "" "" "" "" "" "" "" "< S E.w] L Y.n" "> V F.b. V S.z " "" "+ C M.n+ L K.n" "+ S S.y+ S O.b " "" "" "" "" "" "" "" "" "" "+ R G.y+ K X.j " "" "" "" "+ F O.g+ A C.z " "" "+ R L.q. S N.g " "" "" "" "" "" "" "" "" "" "+ X L.x+ C F.x " "" "" "" "" "" "" "+ C O.x. G A.h " "" "" "" "" "" "" "" "" "" "[ Z L.u- A P.o " "" "" "" "- O H.i> U Q.v" "+ F A.d+ E T.n " "" "" "+ B S.o+ F B.y " "" "" "+ L S.r< O X.n " "" "" "" "" "" "" "] C D.h> H O.d " "" "" "" "" "" "+ X O.x+ H Q.b " "" "+ E S.n. M X.q " "" "" "- D S.j- U E.l " "" "" "" "" "" "" "[ H J.g- A R.a " "" "" "" "> T X.s+ D C.d " "" "" "" "" "" "+ G X.p+ I J.l " "" "" "" "" "" "" "" "" "" "+ F K.i< C Q.h" "] X L.c> X V.i " "" "" "" "" "+ B Q.t. S J.j " "" "" "" "" "- L J.v- D C.h " "" "" "" "" "" "- F D.f- R N.u " "" "" "" "" "" "- T Y.p- R S.p " "" "" "" "" "" "" "- V S.y- X U.r " "" "" "" "" "" "" "- H E.r- H O.l" ". I A.a+ C S.u " "" "" "" "" "" "" "" "" "+ S B.q+ L N.j " "" "" "" "" "" "" "+ B F.u+ L X.r " "" "" "" "" "" "" "+ V C.b. K P.l" "- U K.l[ P S.q " "" "" "" "" "" "" "- Z E.u- P M.s " "" "" "" "" "" "- I P.z- A W.f " "" "" "" "> W A.x+ S B.l " "" "" "" "" "" "< P H.m] T C.l " "" "" "" "" "" "" "" "" "" "> D N.o+ H T.w " "" "" "+ H X.n+ S Y.g " "" "" "" "" ". L C.b- M N.h " "" "" "" "" "- D B.q- X C.s " "" "" "" "" "" "[ D Y.o- L W.z " "" "" "> D N.n+ C P.o " "" "" "" "" "+ A V.a+ X X.w " "" "" "" "" "+ L T.l< V K.s" "] C E.f> C I.o " "" "" "" "" "" "" "" "" "" ". O C.a- L B.a " "" "- E Q.c- I F.h " "" "" "" "" "" "- A Y.q- K T.a" "- C Y.h- F A.e " "" "" "" "" "" "- M D.h- L I.z " "" "" "" "" "- X G.c- M F.x " "" "" "" "- P U.s. N F.f " "" "" "" "" "" "" "" "" "+ A E.c+ F B.k " "" "" "" "" "" "" "+ Q K.f+ W I.y " "" "" "" "" "+ E S.a+ R S.o " "" "" "+ N Y.a. J G.u " "" "+ L V.i+ X T.y " "" "" "+ S F.l+ O Y.i " "" "" "" "" "" "" "" "" "" "+ Q V.e+ S Q.l " "" "" "" "" "" "" ". O A.g+ W S.r " "" "" "" "" "" "" "" "" "+ Z D.e[ N A.l " "" "" "" "- A D.b> I K.a " "" "" "" "" "" "+ E U.c+ E O.x " "" "" "" "" "" "" "" "+ P D.h< G K.g " "" "" "" "" "] G X.b> H W.g " "" "" "" "" "" "" "" "+ K D.c+ H B.f " "" "" ". K Z.e+ M P.p " "" "" "" "" "" "" "" "" ". A L.n- O B.m" "- P T.z- C S.w " "" "" "" "" "" "" "" "- Q Y.e[ I N.g " "" "- X A.q> Y L.i" "+ I Y.u+ T A.w " "" "+ B Z.t< W U.z " "" "" "" "" "" "" "] R S.i> U S.a " "" "" "" "" "" "" "" "" ". O T.a- M D.f " "" "" "" "" "" "- H U.s- V O.g " "" "" "" "" "" "" "" "- O H.p- O L.v " "" "" "" "" "" "" "" "" "" "- X R.b- U V.w " "" "" "" "" "" "- G H.w- E R.n " "" "" "" "" "" "" "" "" "" "- R J.c- H S.p " "" "" "" "- J A.x. F W.h " "" "" "" "" "" "" "" "" "[ J R.s- F R.c " "" "" "" "" "" "" "> L H.w+ Z A.z " "" "" "" "+ Z O.s+ S D.u " "" "" "" "" "" "" "" "< B C.k] J F.k" "> P C.t+ H C.q " "" "" "" "" "" "" "" "" "+ N B.e. V S.t " "" "" "" "" "[ Q M.p- M C.m " "" "" "" "" "" "" "- B A.r- Q C.y " "" "" "> F D.t+ A G.r " "" "< A V.d] X H.m " "" "" "" "" "" "" "" "> J E.x- Y P.d " "" "- E T.h- P I.p " "" "" "" "" "" "" "" "- R O.f. I B.f" "+ P M.n+ N L.j " "+ N Z.c[ Y V.z " "" "" "- K G.k> D F.u " "" "" "+ L D.e+ W I.k " "" "" "" "" "" "+ P M.k< X Y.y " "" "" "" "" "" "] O L.n> Q K.e " "" "" "" "+ R M.t+ C B.i " "" "" ". E J.g+ I C.a " "" "" "" "" "" "" "" "" "" "+ C C.k+ B I.e " "" "" "" "" "" "" "" "" "+ T U.d+ K D.x " "" "" "" "" "" "" "+ F K.p+ M O.h " "" "" "" "" "" "" "+ Q H.e. M Z.a " "" "" "" "+ I Q.m+ W M.d " "" "" "" "+ A I.y+ G H.u " "" "" "" "" "" "" "+ E U.j. Z W.z " "" "" "" "" "" "" "" "" "- G X.r- R V.h " "" "- I P.a- M X.d " "" "" "" "" "" "" "" "" "- V M.q- C M.z " "" "" "" "" "" "- P K.l- N L.r " "" "" "" "" "" ". L D.t- G A.f " "" "" "" "" "" "" "" "" "" "[ T J.f- M X.p " "" "" "" "" "" "" "- V P.t- G Z.f " "" "> T O.h+ S Q.r " "" "" "" "" "" "" "" "" "< Z S.r] D P.v " "" "" "" "" "" "" "> G Q.n- F M.v " "" "" "" "" "" "" "" "" "- P Z.g. N S.d " "" "" "" "" "" "" "" "" "" "+ E G.x[ U N.t " "" "" "- R J.z> Y Y.e " "" "" "" "" "" "" "" "+ V N.x+ V U.s " "" "" "" "" "+ W P.s< S P.m " "" "" "" "" "" "" "" "] G O.x> X J.d " "" "" "" "" "" "+ X E.l. Z T.o " "" "" "" "+ T N.l+ L U.t " "" "" "" "+ C L.i+ Z M.g" "+ M K.k+ E P.p " "" "" "" "" "+ P T.l+ S Z.h" ". F W.k- Q D.q " "[ O I.r+ K W.r " "" "" "+ J B.x> F A.s " "" "" "" "" "" "" "" "" "- Y D.b- O H.r " "" "" "" "" "" "- W N.a< H S.e" "] N F.o> Q I.y " "" "" "" "" "" "+ B V.w. Q G.b " "" "" "- J R.i[ B M.j" "- Q R.a- K V.v " "" "" "- M S.b> W O.i " "" "" "" "" "" "" "" "" "+ C D.t+ T X.o " "" "" "" "" "" "" "" "" "< S C.m] T F.f " "" "" "" "" "" "" "" "" "" "> E Q.z- O B.w " "" "" "" "" "" "" ". Z T.a+ X L.t" "+ H U.f+ B E.x " "" "" "" "" "" "" "" "+ K A.c+ A E.p " "" "" "" "" "+ S N.v+ P P.h " "" "" "" "" "" "" "" "+ R C.f+ I I.y " "" "" "" "" "" "" "" "" "+ N C.h. U P.x " "" "" "" "" "" "" "- D Q.c- I K.k " "" "" "" "" "" "" "" "" "- U U.c- A X.j " "" "" "" "" "" "" "" "" "" "- N B.u. A J.p " "" "" "" "" "[ N K.j+ L H.t " "" "" "" "" "+ D E.j> T Q.c" "- B U.z- A N.e " "" "" "- C J.k< D O.n " "" "" "" "" "" "" "" "" "] O U.c> Z J.e " "" "" "" "" "" "+ K E.m+ B O.p" ". H S.l[ T N.r " "- Z M.e> D Q.i " "" "" "" "" "" "" "" "+ K B.v+ S P.o " "" "" "" "" "+ Q O.w< Y D.o " "" "" "" "] I C.n> R H.i " "" "" "" "" "" "" "- I F.z. L Q.t " "" "[ W U.q- A C.q " "" "" "" "- H U.l- V P.f " "" "" "- J Z.n> C Y.j " "" "" "" "" "" "" "+ E Y.b< J Q.g " "" "" "" "" "" "] F W.x> X H.c " "" "+ Z X.r+ O K.g " "" "" "" "+ Y Q.f. X Z.d " "" "" "" "" "" "" "[ O G.z- F K.u " "" "> P Z.o+ M D.s " "" "" "" "" "" "" "" "+ L G.h+ Z M.l " "" "" "" "" "" "" "" "" "" "< J L.y] O U.x " "" "" "" "" "> L K.q+ P U.c " "" "" "" ". F H.l+ X W.j " "" "" "" "" "" "" "+ N I.x. U A.u " "" "" "" "" "" "" "" "- Y B.m[ X W.a " "" "" "" "" "" "" "" "" "" "- B X.u- V G.w " "" "" "" "" "- D N.d> M Q.g " "" "" "" "" "" "" "" "+ I I.w< E P.u " "" "] F V.k> I U.s " "" "" "" "" "" "" "- F P.b- B H.u " "" "" "" "" "" ". J X.n+ G E.e " "" "" "" "" "" "" "" "" "" ". U J.t[ T C.l " "" "" "" "" "- O K.g> T L.r " "" "" "" "" "" "" "" "+ W A.a+ O Z.g " "" "+ A N.e< Q N.q " "" "" "" "" "] W U.k> Y J.w " "" "" "" "" "" "" "" "" "+ V V.k+ Y L.w " "" "" "" ". S V.k+ P C.h " "" "" "" "" "" "+ C G.v+ N F.d " "" "" "" "" "" "" "" "" "" "+ K P.u+ R J.z " "" "+ E R.y+ I I.p " "" "" "" "" "" "" "" "" "" "+ Y H.z+ G U.v " "" "+ T E.o+ G S.g " "" "" "" ". S A.u. Z X.n " "" "- L S.x[ M X.z " "" "" "" "" "" "" "" "" "- V Z.e- S C.p " "" "" "" "" "- T H.m> E B.m " "" "" "" "" "" "" "" "" "" "+ Q T.t< N Z.g " "" "" "] R I.y> B J.k " "" "" "" "" ". V V.r- L T.x " "" "" "" "" "" "" "" "[ L Z.s- T Y.p " "" "" "" "" "" "- N A.p- W X.q " "" "" "" "" "" "" "- M D.t> Z Y.r " "" "" "" "+ B Q.u< L C.m" "] V R.j> Z D.y " "+ A C.j+ P S.w " "" "" "" ". V K.r- E N.s " "" "" "" "" "- C F.n- Q B.p " "" "" "" "" "" "[ R E.d- H Y.r " "" "" "" "" "" "> H D.v+ X E.h" "+ V R.j+ C C.m " "+ C Q.j< Q X.b " "" "" "" "" "" "" "" "" "] Y J.g> K Y.s " "" "" "" "" "" "" "" ". T R.i- K R.f " "" "" "" "" "" "" "" "- B U.o- Z I.n " "" "" "" "" "" "" "" "- I X.s- G D.p" "- B C.i- K G.c " "- V G.i- P Y.f " "" "" "" "- V G.t- U D.s " "" "" "" "" "" "" "" "" "- K P.f. F X.m " "" "" "" "" "- O B.l- S C.e " "" "" "" "" "" "- B K.l. D Z.f " "" "- U K.m- J F.z " "" "" "" "[ H N.l- D G.i " "" "" "" "" "" "" "" "" "- Y T.u- Z R.s " "" "> Z O.p+ D V.g" "< Q W.w] W K.w " "" "" "" "" "" "> O V.l- I A.w " "" "" "" "" "" "" ". B L.j+ H C.k " "" "" "" "" "" "" "+ B W.w[ H T.q " "" "" "" "" "" "" "" "- Z F.z- H S.u" "- K B.j> M T.w " "" "" "" "" "" "" "+ Q N.d+ G K.a " "" "" "" "" "" "< W U.e] H M.u " "" "" "" "" "> B Q.u. O J.r " "" "" "" "" "" "" "" "- Z G.n- H K.i " "" "" "" "" "" "" "" "" "- I E.j- X U.y " "" "" "" "" "- L O.u- J D.h " "" "" "- X F.q- P J.v " "" "- E T.u- X M.c " "" "" "" "" "- S P.y. U S.z " "" "" "" "" "" "" "" "" "+ E C.l+ S N.y " "" "+ T N.r+ J F.s " "" "" "" "" "" "" "" "+ U I.x+ I P.o " "" "" "" "+ F Z.e+ P E.k " "" "" "" "" "" "" "+ G J.k+ X Y.w " "" "" "" "" "" "" "+ Z Z.d+ Y B.b " "" "+ F A.d. R W.p " "" "" "- M A.z- Y R.l " "" "" "" "" "" "" "- Z L.a- E X.h " "" "" "" "" "" "" "" "" "" "- I G.d- H J.b " "" "- U E.n. H X.k " "" "" "- V E.s- S F.h " "" "" "" "[ L A.x- A C.l " "" "" "" "- P O.q- X J.x " "" "" "> M X.u+ W H.s " "" "" "< H T.p] V U.o " "" "" "" "" "> P Z.v- C K.a " "" "" "- U J.p. V N.l " "" "" "" "" "" "" "" "" "" "[ L T.u- N K.d " "" "" "" "" "" "" "" "" "> I G.u+ Z N.g " "" "" "" "" "" "" "" "" "" "+ H K.j+ M S.h " "" "" "" "" "" "" "" "< F M.t] D J.z " "" "" "" "" "" "" "> E K.d+ J M.c " "" "" "" "" "" "" "" "" "+ O M.u. A P.k " "" "" "" "" "" "" "" "" "+ R V.v+ U I.e " "" "+ Z C.m+ L L.m " "" "" "" "" "+ B Z.d+ O R.s " "" "" "" "" "" ". B D.m- W R.x " "" "" "" "" "" "" "" "- W H.b. S R.g " "" "- Y N.a- P L.b " "" "" "" "" "" "" "" "[ T M.k- D H.x " "" "" "" "" "" "" "" "" "- P I.s- U A.z " "" "" "" "> E B.m+ O I.t " "" "" "" "" "< T N.c] A D.t " "" "" "> Q I.y- Z P.y " "" "" "" "" "" "" "" "" ". M B.t- N E.j " "" "" "- K T.z- Y S.p " "" "" "" "" "" "" "" "[ D J.x- V R.z" "> R Q.i+ C G.h " "" "+ Z V.a+ U C.n " "" "" "" "" "" "" "" "+ D U.s< W C.x " "" "" "" "" "" "] F A.j> J L.h " "" "" "" "" "" ". N U.r- R F.n " "" "" "" "" "- V N.s- T L.n " "" "" "" "- V E.i- T G.n" "- O M.r- Z A.g " "" "" "" "" "" "" "- A Q.h- S Z.n " "" "" "" "" "" "- Q G.q- L X.p " "" "- Z D.k. M C.a" "- P M.e- V S.u " "" "" "" "" "" "" "- S I.k- B W.o " "" "" "" "" "" "" "" "" "" "- C W.o- U U.m " "" "" "" "" "" "" "" "" "- V C.o. Q F.i " "" "" "" "" "" "" "" "" "" "- P N.w- S Y.l " "" "" "" "" "" "" "" "" "" "[ J R.h- D A.k " "" "" "" "" "" "" "" "" "" "- N A.o- Q L.g " "" "> P L.c+ L T.n " "" "" "" "" "" "" "< O W.o] P O.v " "" "" "" "" "" "> K G.h- T O.j " "" "" "" "" ". P J.u[ O W.x " "" "" "" "" "" "- I F.c- N Z.c" "- S U.e- L D.y " "" "" "" "" "" "" "" "" "" "> E Y.l+ X Y.l " "" "" "" "" "" "< L S.q] P K.c " "" "" "" "" "" "" "> D V.l+ M F.a " "" "" "" "" "" "" "" "+ F F.f+ C N.z " "" "" "" "" "" "" "" ". E D.d- P J.p " "" "" "" "" "" "- Q Z.c- E T.w " "" "" "" "" "[ O E.t- C G.w " "" "" "" "" "" "> D F.a+ S X.d " "" "" "" "+ V Z.a+ O V.x " "" "" "" "" "" "" "" "" "+ I Z.z< N H.f " "" "" "" "" "] E L.n> U V.m " "" "" "" ". G E.r- P T.n " "" "" "" "" "" "- H U.p- N J.v " "" "" "" "" "" "" "" "" "" "- D W.g- Q P.f " "" "" "" "" "" "- I S.w- L L.d " "" "" "" "" "" "" "" "- O S.j- I W.u " "" "" "" "" "" "" "" "- F J.m- Q D.s " "" "" "- T C.v. F L.z " "" "" "" "" "" "" "" "+ C J.k. Z B.m " "" "" "" "" "" "" "" "" "" "+ Y J.r+ B G.n " "" "" "" "" "" "" "" "" "+ P P.c+ T F.x " "" "" "" "" "" "" "" "" "" "+ U A.k+ A W.x " "" "" "" "" "" "" "" "" "+ L R.s+ U U.b " "" "" "" "" "" "" "" "+ Z B.t+ C J.g " "" "" "" ". Z Q.v+ Q W.l " "" "" "[ M C.i- J A.p" "- N V.p- V V.s " "" "- V O.v> M C.w " "" "" "" "" "" "" "" "+ M O.f< I U.j" "] A G.b> Z D.z " "" "" "" "" "+ O J.h+ X K.u " "" "" "" "" "" "" "+ Y I.r. Y E.u " "" "" "" "" "" "" "" "" "- V P.s- R I.g " "" "- Q J.u[ V I.e " "" "" "" "" "- D B.g- C Z.f " "" "" "" "" "" "" "- C E.f- U K.k " "" "" "" "" "" "" "" "" "- Z P.e> D N.y " "" "" "" "" "+ V K.k+ A J.b" "< C E.l] B E.t " "" "" "> D R.p. D L.a " "" "" "" "+ A H.q+ H Y.w " "" "" "" "+ K A.o. M X.k " "" "" "" "- M C.o- B N.c " "" "- F T.w- J F.u " "" "" "" "" "- N Q.i- W K.j " "" "" "- D V.q. E W.g " "" "" "+ C X.p+ R T.y" "+ R P.j+ B S.a " "" "+ D B.i. M G.c" "+ N B.l[ I N.x " "" "" "" "" "" "" "" "" "- Z R.w- P W.n " "" "" "" "" "" "" "" "- C B.h- R P.m " "" "" "" "> S I.t+ H L.n " "" "" "" "" "" "" "" "< G O.e] T Z.w " "" "" "" "" "" "> A Q.k+ N V.q " "" "" "" "" "+ E S.y+ D C.n " "" "" "" ". U E.f- Z A.p" "[ Y C.q- D O.p " "" "" "" "" "" "" "- D R.g- M A.k " "" "" "" "" "> Q D.j+ D E.r " "" "" "" "+ W W.p< E T.y " "" "" "" "" "" "" "" "" "] V P.g> G E.x " "" "" "- L O.p. S P.r " "" "" "" "" "" "" "" "+ B F.q+ G X.x " "" "" "" "" "" "" "" "" "" "+ W X.q+ O E.o" "+ E Z.v. Q G.w " "[ H H.n- C F.x " "" "" "- N L.j- Z N.t " "" "" "" "" "" "" "" "- L G.e- F Y.y " "" "" "" "" "" "" "" "> C L.l+ T R.l " "" "" "" "" "" "" "" "" "" "+ Q F.e< Z D.g " "" "" "" "" "" "" "" "" "" "] W I.i> S T.z " "" "" "" "+ V Z.s+ Y W.r " "" "" "" "" "" "" "" ". R C.e+ O A.d " "" "" "" "" "" "" "" "" "+ J P.b[ H W.i " "" "" "" "" "" "- L F.u- H D.k" "- H Q.w> L Y.c " "" "" "" "" "" "" "" "+ B F.p+ J U.y " "" "" "< X U.c] N E.p " "" "" "" "" "" "" "" "" "> W M.k. J W.n " "" "" "> C K.i- T R.l " "" "" "" "" "" "" "" "" "" "[ S A.c- D W.w " "" "" "" "" "" "" "" "" "" "- R I.g- M F.p " "" "" "" "" "" "" "" "" "> I V.e+ Q U.j " "" "" "< T U.p] I C.j " "" "" "" "" "> W E.t- U O.y " "" "" "" "" "- I S.l. H M.t " "" "" "" "[ A Z.w- F H.x " "" "" "" "" "" "" "" "" "- M A.p- S J.k " "" "" "" "" "" "" "" "" "" "> F X.s+ F A.a" "< P A.c] I G.r " "" "> Y W.m- K F.l " "" "" "" "" "" "" "- V W.e. G Q.u " "" "" "" "" "" "" "" "" "" "+ S C.t+ F W.y " "" "" "" "+ I S.v. N Y.k " "" "" "" "" "" "" "" "" "" ". U Q.f+ V K.f " "" "+ N S.m+ W Y.u " "" "" "+ X X.j+ I I.m " "" "" "" "" "" "+ V I.g+ B Z.f" ". Q Q.q- L A.e " "" "" "" "" "" "[ F O.w- Z K.v " "" "- P I.b- M X.r " "" "" "" "" "" "- H O.n> I R.e " "" "" "+ V S.b< P U.a " "" "" "" "] Y G.g> S C.l " "" "" "" "" "" "" "" "" "+ X I.z+ P I.n""";import ast
print(ast.literal_eval(input())+ast.literal_eval(input()))

What does the program do?

Uhm - there is a possibility that there are more but at least Coconut is backwards compatible w/ Python you might want to add that to your list..

@BMO Wow, TIL Coconut has so many shortening features I didn't even know I wanted in python.

@Quintec: It is an awesome language, the only problem is that the transpiler is horribly slow :(

Okay, it's not brainfuck

@BMO Thanks for the catch, I'll add it as supported if my PC stops screaming because of the size of that line in the code block :P

@FireCubez Are you okay with junk output? I can fix it if not.

@famous1622 I can't allow junk output, how'd I see the rrsult?

@FireCubez Reading the last line, obviously. In all seriousness I'll fix it though :Ehehe:

Python 3 - Hello, World!
3;s="!dlroW ,ollexH";(print(s[-1]+s[-3::-1]),")")#"`[;:].

(Second language technically doesn't print a newline, but the interpreter adds one automatically)
...I just realised that I failed to read the date of the challenge, and the secondary language postdates the challenge. Many apologies.

><>, 39 bytes, safe
vdvII$$$$$$$$$>r+n;O@
>ri68*-i~i68*-^u

Try it online!
Works in ><>, Gol><>, somehow not *><>, and Backhand.
Explanation
vdv                   Push the speed down twice
   II                 Take 2 inputs
     $$$$$$$$$>r      A bunch of stuff that do nothing
                +     Add
                 n;   More nothing
                   O  Output
                    @ End

05AB1E, 7 bytes, safe
”Ÿ™,‚ï!

Try it online!
Also works in

05AB1E (legacy)
2sable

I actually think the only thing it could be is some obscure 05AB1E-based golfing language. What is it?

Hello, World!, cracked
#|
print("Hello, World!")# wh|#(write-line "Hello, World!")

This works in Python, Lisp, and one other language Deadfish~.

Err, any language with # as a comment character and a print function, e.g. Perl

It's not really safe, since I commented a solution half an hour after you posted it. I just assumed you were going to change it, since it works in a large amount of languages, Julia, R etc.

Alright, I'd just crack it despite JoKing's comments. Cracked.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Polycops and Robbers (Robbers' Thread)
This is the robbers' thread, the cops' thread is here

A polyglot is a program, that without modification, can run in multiple languages.

Robbers' Challenge
First, find a vulnerable cop's answer, then try to find languages that the submission works in, if you found any that weren't listed by the cop, then you just cracked their answer. Post an answer linking to the original answer and what languages you found it working on (it must do the same thing on each language). You can then leave a comment on their answer linking back to your answer on this thread.

Winning
Most upvoted answer that actually does crack the cops' code wins

Foo, PotatoLatte's answer
puts "Hello World!"

Try it online!
Ah, the bane of cops and robbers, Foo.

Befunge-93, Shieru Asakotu's answer
'<?php '//'; #@ SPELL,WITH,ME, ,H,E,L,L,O, ,W,O,R,L,D,"'Hello, World!'"
$a = "'Hello, World!'";
if ([])
 console.log($a); //This should be an easy one to solve
else {
 for ($i = 1; $i < strlen($a) - 1; $i++)
  echo($a[$i]);
}
// ?>'

Try it online!
Prints 'Hello, World!', quotes included.

Perl 6, Julia 0.4, R, etc., Cortex's answer
#|
print("Hello, World!")# w|#(write-line "Hello, World!")

Try Perl online!
Try R online!
Try Julia 0.4 online!

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Without using numbers, Calculate Pi
Inspired by Nicola Sap's Challenge
Goal
Your challenge is to simply produce π with 232-1 digits. However today's twist, like the title implies, is to produce it without using any numbers or any π constants in your source-code.
Input/Output
Your program will not be provided usable input. It can output in any reasonable format.
Rules

Standard Loop-Holes forbidden
You cannot use numbers in your source code nor can you use a pi constant if it exists. If your language also has tau defined as 2pi, that's also banned. Numbers are in the range [0-9]
You must output as many digits as you can You must output 2^32-1 digits of pi, including the 3. (This has been changed due to the arbitrary nature of the original task)
Your Program must terminate, or at least theoretically terminate given enough time. Crashing is an acceptable way to terminate.

Scoring
This is code golf so shortest answer wins.
A Million Digits of Pi for your use

Just acknowledging that it's been done to death doesn't mean that you're not killing it more.

How do you define numbers?

@JoKing It might prove to be a fresh enough spin to be interesting. If not, so it goes. Besides, if I didn't say it, someone else would've. Also added

Given that there are algorithms for computing pi to an arbitrary precision I think there need to be some more limits imposed on the problem. Otherwise the winner is just whoever uses the largest target precision. Working around the no-numbers restriction just requires casting char to int

@user202729 Yeah, I overlooked that aspect. I guess to salvage this, the goal shall be changed to generating 2^32-1 digits

It's unfortunate that Shakespeare doesn't have arbitrary precision, or else the Shakespeare Programming Language would be a shoo-in.

@JosiahRyanW I guess implementing arbitrary precision in SPL is not very hard. But how is that related?

@user202729 Shakespeare doesn't have numbers in its source code anyways.

Perl 6, 67 bytes
{$!=.FatRat²/$!+$_+$_-?e}for ²…¹;say substr ⁴/$!,^²³²

Try it online!
Takes a very long time to compute. As an example here's an altered version that only prints the first 1000 digits.

Can you not remove the braces?

Mathematica, 42 39 bytes
N[Log[-(d=I/I)]/I,((c=d+d)^c^c^c)^c-d]&
Output Returns exactly 4294967295 digits as requested.
If more digits were allowed, then by outputting 7.76e17 digits (if even possible lol), 26 bytes would be possible:
N[Log[-E/E]/I,E^(E^E*E)]&
Sorry but Pi = Ln(-1)/i.

The OP has changed the challenge to produce 2^32-1 digits of Pi

@JoKing You mean 2147483647 digits exactly?

4,294,967,295 actually.

@Veskah I though it was 2^(32-1)-1 lol

GolfScript, 70 85 bytes
;''!..):t{](..+.*:a@~@*\a(*@)\@}t.+.+t+:T t..*.*t*?(:b?*@;\{.@[\].~/\~%T*@}b*;;]("."@

+15 bytes because I can't read.
Try it online!
Or, actually, don't. Try this online instead, which calculates 4 digits.


text:
Hyperoperation Golfing
Introduction

In mathematics, the hyperoperation sequence is an infinite sequence of arithmetic operations (called hyperoperations) that starts with the unary operation of successor (n = 0), then continues with the binary operations of addition (n = 1), multiplication (n = 2), and exponentiation (n = 3), after which the sequence proceeds with further binary operations extending beyond exponentiation, using right-associativity.

(Source)

Challenge
Your challenge is code this sequence, given 3 inputs, n, a, and b, code a function such that $${\displaystyle H_{n}(a,b)={\begin{cases}b+1&{\text{if }}n=0\\a&{\text{if }}n=1{\text{ and }}b=0\\0&{\text{if }}n=2{\text{ and }}b=0\\1&{\text{if }}n\geq 3{\text{ and }}b=0\\H_{n-1}(a,H_{n}(a,b-1))&{\text{otherwise}}\end{cases}}}$$
(Also from Wikipedia.)

Input
3 positive decimal integers, n, a, and b, taken from STDIN, function or command line arguments, in any order. Make sure to specify this in your answer

Output
The result of applying \$H_{n}(a,b)\$ with the inputs

Example inputs and outputs
Input: 0, 6, 3
Output: 4

Input: 4 5 2
Output: 3125

Restrictions

Your program/function should take input in base 10
Don't use any built in function that already provides H(n, a, b)
Standard loopholes apply

This is code-golf, so shortest code in bytes wins!

@JoKing Does it? I'll have a read

@Arnauld will do.

(not really. That one "bans builtins" because it's from '13; plus, cumbersome input/output format)

@dzaima fixed it.

JavaScript (ES6),  49  47 bytes
Takes input as (a)(b,n).
a=>g=(b,n)=>n*b?g(g(b-1,n),n-1):-~[b,a-1,-1][n]

Try it online!
Commented
a =>                  // main function taking a
  g = (b, n) =>       // g = recursive function taking b and n
    n * b ?           // if neither n nor b is equal to 0:
      g(              //   go recursive:
        g(b - 1, n),  //     b = g(b - 1, n)
        n - 1         //     decrement n
      )               //   end of recursive call
    :                 // else:
      -~[             //   this is a leaf node:
        b,            //     if n = 0, return b + 1
        a - 1,        //     if n = 1, return (a - 1) + 1 = a
        -1            //     if n = 2, return -1 + 1 = 0
      ][n]            //     if n > 2, return -~undefined = 1

Dyalog APL, 35 bytes
{⍺=0:⍵+1⋄⍵=0:⍺⍺⍵1⊃⍨3⌊⍺⋄(⍺-1)∇⍺∇⍵-1}

Try it online!

you can save a byte by inverting the second guard: {⍺=0:⍵+1⋄×⍵:(⍺-1)∇⍺∇⍵-1⋄⍺⍺⍵1⊃⍨3⌊⍺}

Elixir, 86 bytes
(assumes functions can take a reference to itself as an argument)
fn 0,_,b,_->b+1
1,a,0,_->a
2,_,0,_->0
_,_,0,_->1
n,a,b,f->f.(n-1,a,f.(n,a,b-1,f),f)end

Try it online!


text:
Whose neighbours are hostile?
Introduction
For the purposes of this challenge, we will define the neighbours of an element \$E\$ in a square matrix \$A\$ (such that \$E=A_{i,j}\$) as all the entries of \$A\$  that are immediately adjacent diagonally, horizontally or vertically to \$E\$ (i.e. they "surround" \$E\$, without wrapping around).
For pedants, a formal definition of the neighbours of \$A_{i,\:j}\$ for an \$n\times n\$ matix \$A\$ is (0-indexed):
$$N_{i,\:j}=\{A_{a,\:b}\mid(a,b)\in E_{i,\:j}\:\cap\:([0,\:n)\:\cap\:\Bbb{Z})^2\}$$
where
$$E_{i,\:j}=\{i-1,\:i,\:i+1\}\times \{j-1,\:j,\:j+1\} \text{ \\ } \{i,\:j\}$$
Let's say that the element at index \$i,\:j\$ lives in hostility if it is coprime to all its neighbours (that is, \$\gcd(A_{i,\:j},\:n)=1\:\forall\:n\in N_{i,\:j}\$). Sadly, this poor entry can't borrow even a cup of sugar from its rude nearby residents...
Task
Enough stories: Given a square matrix \$M\$ of positive integers, output one of the following:

A flat list of elements (deduplicated or not) indicating all entries that occupy some indices \$i,j\$ in \$M\$ such that the neighbours \$N_{i,\:j}\$ are hostile.
A boolean matrix with \$1\$s at positions where the neighbours are hostile and \$0\$ otherwise (you can choose any other consistent values in place of \$0\$ and \$1\$).
The list of pairs of indices \$i,\:j\$ that represent hostile neighbourhoods.

Reference Implementation in Physica – supports Python syntax as well for I/O. You can take input and provide output through any standard method and in any reasonable format, while taking note that these loopholes are forbidden by default. This is code-golf, so the shortest code in bytes (in every language) wins!
Moreover, you can take the matrix size as input too and additionally can take the matrix as a flat list since it will always be square.
Example
Consider the following matrix:
$$\left(\begin{matrix}
64 & 10 & 14 \\
27 & 22 & 32 \\
53 & 58 & 36 \\
\end{matrix}\right)$$
The corresponding neighbours of each element are:
i j – E  -> Neighbours                          | All coprime to E?
                                                |
0 0 – 64 -> {10; 27; 22}                        | False
0 1 – 10 -> {64; 14; 27; 22; 32}                | False
0 2 – 14 -> {10; 22; 32}                        | False
1 0 – 27 -> {64; 10; 22; 53; 58}                | True
1 1 – 22 -> {64; 10; 14; 27; 32; 53; 58; 36}    | False
1 2 – 32 -> {10; 14; 22; 58; 36}                | False
2 0 – 53 -> {27; 22; 58}                        | True
2 1 – 58 -> {27; 22; 32; 53; 36}                | False
2 2 – 36 -> {22; 32; 58}                        | False

And thus the output must be one of the following:

{27; 53}
{{0; 0; 0}; {1; 0; 0}; {1; 0; 0}}
{(1; 0); (2; 0)}

Test cases
Input –> Version 1 | Version 2 | Version 3

[[36, 94], [24, 69]] ->
    []
    [[0, 0], [0, 0]]
    []
[[38, 77, 11], [17, 51, 32], [66, 78, 19]] –>
    [38, 19]
    [[1, 0, 0], [0, 0, 0], [0, 0, 1]]
    [(0, 0), (2, 2)]
[[64, 10, 14], [27, 22, 32], [53, 58, 36]] ->
    [27, 53]
    [[0, 0, 0], [1, 0, 0], [1, 0, 0]]
    [(1, 0), (2, 0)]
[[9, 9, 9], [9, 3, 9], [9, 9, 9]] ->
    []
    [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
    []
[[1, 1, 1], [1, 1, 1], [1, 1, 1]] ->
    [1, 1, 1, 1, 1, 1, 1, 1, 1] or [1]
    [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
    [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
[[35, 85, 30, 71], [10, 54, 55, 73], [80, 78, 47, 2], [33, 68, 62, 29]] ->
    [71, 73, 47, 29]
    [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 1, 0], [0, 0, 0, 1]]
    [(0, 3), (1, 3), (2, 2), (3, 3)]

Borrowing stuff from hostile neighbors? For some reason, this reminds me of Jeff Minter's game Hover Bovver...

Can we take the matrix size as input?

@Delfad0r I always forget to mention that. Yes, you may take the matrix size as input.

APL (Dyalog), 17 bytes
1=⊢∨(×/∘,↓)⌺3 3÷⊢

Try it online! (credits to ngn for translating the test cases to APL)
Brief explanation
(×/∘,↓)⌺3 3 gets the product of each element with its neighbours.
Then I divide by the argument ÷⊢, so that each entry in the matrix has been mapped to the product of its neighbors.
Finally I take the gcd of the argument with this matrix ⊢∨, and check for equality with 1, 1=
Note, as with ngn's answer, this fails for some inputs due to a bug in the interpreter.

JavaScript (ES6), 121 bytes
Returns a matrix of Boolean values, where false means hostile.
m=>m.map((r,y)=>r.map((v,x)=>[...'12221000'].some((k,j,a)=>(g=(a,b)=>b?g(b,a%b):a>1)(v,(m[y+~-k]||0)[x+~-a[j+2&7]]||1))))

Try it online!
How?
The method used to isolate the 8 neighbors of each cell is similar to the one I described here.
Commented
m =>                            // m[] = input matrix
  m.map((r, y) =>               // for each row r[] at position y in m[]:
    r.map((v, x) =>             //   for each value v at position x in r[]:
      [...'12221000']           //     we consider all 8 neighbors
      .some((k, j, a) =>        //     for each k at position j in this array a[]:
        ( g = (a, b) =>         //       g is a function which takes 2 integers a and b
            b ?                 //       and recursively determines whether they are
              g(b, a % b)       //       coprime to each other
            :                   //       (returns false if they are, true if they're not)
              a > 1             //
        )(                      //       initial call to g() with:
          v,                    //         the value of the current cell
          (m[y + ~-k] || 0)     //         and the value of the current neighbor
          [x + ~-a[j + 2 & 7]]  //
          || 1                  //         or 1 if this neighbor is undefined
  ))))                          //         (to make sure it's coprime with v)

MATL, 22 bytes
tTT1&Ya3thYC5&Y)Zd1=A)

Input is a matrix. Output is all numbers with hostile neighbours.
Try it online! Or verify all test cases.
Explanation with worked example
Consider input [38, 77, 11; 17, 51, 32; 66, 78, 19] as an example. Stack contents are shown bottom to top.
t         % Implicit input. Duplicate
          % STACK: [38, 77, 11;
                    17, 51, 32;
                    66, 78, 19]
                   [38, 77, 11;
                    17, 51, 32;
                    66, 78, 19]
TT1&Ya    % Pad in the two dimensions with value 1 and width 1
          % STACK: [38, 77, 11;
                    17, 51, 32;
                    66, 78, 19]
                   [1,  1,  1,  1,  1;
                    1,  38, 77, 11, 1;
                    1,  17, 51, 32, 1;
                    1,  66, 78, 19, 1
                    1,  1,  1,  1,  1]
3thYC     % Convert each sliding 3×3 block into a column (in column-major order)
          % STACK: [38, 77, 11;
                    17, 51, 32;
                    66, 78, 19]
                   [ 1,  1,  1,  1, 38, 17,  1, 77, 51;
                     1,  1,  1, 38, 17, 66, 77, 51, 78;
                     1,  1,  1, 17, 66,  1, 51, 78,  1;
                     1, 38, 17,  1, 77, 51,  1, 11, 32;
                    38, 17, 66, 77, 51, 78, 11, 32, 19;
                    17, 66,  1, 51, 78,  1, 32, 19,  1;
                     1, 77, 51,  1, 11, 32,  1,  1,  1;
                    77, 51, 78, 11, 32, 19,  1,  1,  1;
                    51, 78,  1, 32, 19,  1,  1,  1,  1]
5&Y)      % Push 5th row (centers of the 3×3 blocks) and then the rest of the matrix
          % STACK: [38, 77, 11;
                    17, 51, 32;
                    66, 78, 19]
                   [38, 17, 66, 77, 51, 78, 11, 32, 19]
                   [ 1,  1,  1,  1, 38, 17,  1, 77, 51;
                     1,  1,  1, 38, 17, 66, 77, 51, 78;
                     1,  1,  1, 17, 66,  1, 51, 78,  1;
                     1, 38, 17,  1, 77, 51,  1, 11, 32;
                    17, 66,  1, 51, 78,  1, 32, 19,  1;
                     1, 77, 51,  1, 11, 32,  1,  1,  1;
                    77, 51, 78, 11, 32, 19,  1,  1,  1;
                    51, 78,  1, 32, 19,  1,  1,  1,  1]
Zd        % Greatest common divisor, element-wise with broadcast
          % STACK: [38, 77, 11;
                    17, 51, 32;
                    66, 78, 19]
                   [1,  1,  1,  1,  1,  1,  1,  1,  1;
                    1,  1,  1,  1, 17,  6, 11,  1,  1;
                    1,  1,  1,  1,  3,  1,  1,  2,  1;
                    1,  1,  1,  1,  1,  3,  1,  1,  1;
                    1,  1,  1,  1,  3,  1,  1,  1,  1;
                    1,  1,  3,  1,  1,  2,  1,  1,  1;
                    1, 17,  6, 11,  1,  1,  1,  1,  1;
                    1,  1,  1,  1,  1,  1,  1,  1,  1]
1=        % Compare with 1, element-wise. Gives true (1) or false (0)
          % STACK: [38, 77, 11;
                    17, 51, 32;
                    66, 78, 19]
                   [1, 1, 1, 1, 1, 1, 1, 1, 1;
                    1, 1, 1, 1, 0, 0, 0, 1, 1;
                    1, 1, 1, 1, 0, 1, 1, 0, 1;
                    1, 1, 1, 1, 1, 0, 1, 1, 1;
                    1, 1, 1, 1, 0, 1, 1, 1, 1;
                    1, 1, 0, 1, 1, 0, 1, 1, 1;
                    1, 0, 0, 0, 1, 1, 1, 1, 1;
                    1, 1, 1, 1, 1, 1, 1, 1, 1]
A         % All: true (1) for columns that do not contain 0
          % STACK: [38, 77, 11;
                    17, 51, 32;
                    66, 78, 19]
                   [1, 0, 0, 0, 0, 0, 0, 0, 1]
)         % Index (the matrix is read in column-major order). Implicit display
          % [38, 19]

Will this work if the matrix is bigger than 3x3?

@RobertFraser Yes, the procedure does not depend on matrix size. See last test case for example

APL (Dyalog Classic), 23 22 bytes
-1 byte thanks to @H.PWiz
{∧/1=1↓∨∘⊃⍨1⌈4⌽,⍵}⌺3 3

Try it online!
doesn't support matrices smaller than 3x3 due to a bug in the interpreter

@H.PWiz that's very smart, do you wanna post it as your own?

Sure, you can also use (⊃∨⊢) -> ∨∘⊂⍨ I think

Jelly, 24 bytes
Hmm, seems long.
ỊẠ€T
ŒJ_€`Ç€ḟ"J$ịFg"FÇịF

A monadic Link accepting a list of lists of positive integers which returns a list of each of the values which are in hostile neighbourhoods (version 1 with no de-duplication).
Try it online! Or see a test-suite.
How?
ỊẠ€T - Link 1: indices of items which only contain "insignificant" values: list of lists
Ị    - insignificant (vectorises) -- 1 if (-1<=value<=1) else 0
  €  - for €ach:
 Ạ   -   all?
   T - truthy indices

ŒJ_€`Ç€ḟ"J$ịFg"FÇịF - Main Link: list of lists of positive integers, M
ŒJ                  - multi-dimensional indices
    `               - use as right argument as well as left...
   €                -   for €ach:
  _                 -     subtract (vectorises)
      €             - for €ach:
     Ç              -   call last Link (1) as a monad
          $         - last two links as a monad:
         J          -   range of length -> [1,2,3,...,n(elements)]
        "           -   zip with:
       ḟ            -     filter discard (remove the index of the item itself)
            F       - flatten M
           ị        - index into (vectorises) -- getting a list of lists of neighbours
               F    - flatten M
              "     - zip with:
             g      -   greatest common divisor
                Ç   - call last Link (1) as a monad
                  F - flatten M
                 ị  - index into

Python 2, 182 177 166 bytes
lambda a:[[all(gcd(t,a[i+v][j+h])<2for h in[-1,0,1]for v in[-1,0,1]if(h|v)*(i+v>-1<j+h<len(a)>i+v))for j,t in E(s)]for i,s in E(a)]
from fractions import*
E=enumerate

Try it online!
Outputs a list of lists with True/False entries.

Haskell, 95 bytes
m?n|l<-[0..n-1]=[a|i<-l,j<-l,a<-[m!!i!!j],2>sum[1|u<-l,v<-l,(i-u)^2+(j-v)^2<4,gcd(m!!u!!v)a>1]]

Try it online!
The function ? takes the matrix m as a list of lists and the matrix size n; it returns the list of entries in hostility.


text:
The Improved Caesar Pig Latin Cipher
The problem with the Caesar cipher is the resulting words are often unpronounceable.  The problem with Pig Latin is that it is easy to decode.  Why not combine them?
Input
A word consisting of the 26 english letters.
Output
First, change every consonant in the word to the next consonant in the alphabet.  So, b goes to c, d goes to f, and z goes to b.  Then, change every vowel to the next vowel in the alphabet (u goes to a).  Last, only if the first letter of the word is a consonant, move that letter to the end of the word and add "ay" to the end of the word.
Examples:
cat -> evday
dog -> uhfay
eel -> iim

This is code-golf, so the shortest code wins.
Case does not matter.
Vowels that will be used are A, E, I, O, and U

will we have capital letters in the input?

no, but you can if you want

Welcome to PPCG! Very nice challenge, clearly presented.

Suggested test case: z → bay

jot ot e wisz opvisitvoph dupdiqv cav o fu puv vjopl ov jimqt xovj vji ecomovz vu qsupuapdi vji xusftvay

Suggested test case: the → jivay? (That is, if the word starts with multiple consonants, do we only move one of them?)

Stax, 20 bytes
ù≥±╘├*Lâ■8O±âΓ║Θæ%º•

Run and debug it
Explanation
Vc:tVv:tBcVc#{sL"ay"+}ML             #Full program, unpacked, implicit input
Vc:t                                 #Push consonants and ring translate input
    Vv:t                             #Push vowels and ring translate input
        BCvc#                        #Push first letter and tail of word, find number
                                     #of occurrences to consonants
             {sL"ay"+}M              #If truthy (word starts with consonant)
                                     #swap stack, listify, add "ay"
                       L             #Listify stack (combines words that start with vowel)

I went through a few iterations and finally got it down to 20. My original solution was 53 bytes.

Ruby, 96 69 bytes
->s{/^[^aeiou]/=~(r=s.tr'zb-yadehinotu','b-zefijopuva')?$'+$&+'ay':r}

Try it online!
Fun fact of the day: tr() matches strings right-to-left. I always assumed it was left-to-right.

R, 86 85 bytes
Simple way. chartr has the charming and useful property that it can specify letter ranges, which save a few bytes.
-1 bytes by stealing @GB's Ruby solution's translation strings - upvote it!
function(s)sub("^([^aeiou])(.*)","\\2\\1ay",chartr('zb-yadehinotu','b-zefijopuva',s))

Try it online!

Java (JDK), 167 bytes
s->{String r="",a="aeiouabcdfghjklmnpqrstvwxyzb",c=s.split("")[0];s=a.indexOf(c)>5?s.substring(1)+c+"ux":s;for(var d:s.split(""))r+=a.charAt(a.indexOf(d)+1);return r;}

Try it online!
Credits

-7 bytes thanks to Kevin Cruijssen, using better types.
-1 byte thanks to ceilingcat.

168 bytes

05AB1E, 21 bytes
žMDÀ‡žNDÀ‡¬žNsåiÀ…ÿay

Try it online!
Explanation
žMDÀ‡                   # replace each vowel with the next vowel in the alphabet
     žNDÀ‡              # replace each consonant with the next consonant in the alphabet
          ¬žNsåi        # if the first letter is a consonant
                À…ÿay   # rotate the word left and add "ay"

Node.js 10.9.0, 121 116 bytes
Expects the input string in lower case.
s=>(v=n=>2130466>>n&1)((a=Buffer(s).map(n=>(g=i=>v(n=n%61?n+1:97)^i?g(i):n)(v(n))))[0],a+='')?a:a.slice(1)+a[0]+'ay'

Try it online!
Identifying vowels
To identify vowels, the helper function \$v\$ uses the following bitmask:
2130466 = 000001000001000001000100010
               ^     ^     ^   ^   ^
          zyxwvutsrqponmlkjihgfedcba-

And does:
(2130466 >> n) & 1

We don't need to mask out the relevant bits of \$n\$, because it is done implicitly. Below is the relevant quote from the ECMAScript specification:

Let shiftCount be the result of masking out all but the least significant 5 bits of rnum, that is, compute rnum & 0x1F.

Commented
s =>                      // s = input string
  ( v = n =>              // v = helper function taking n = ASCII code in [97..122]
    2130466 >> n & 1      //     and returning 1 if the corresponding character is a vowel
  )                       //     or 0 otherwise (see the previous paragraph)
  (                       // this statement will ultimately invoke v on a[0]
    ( a = Buffer(s)       //   convert s to a Buffer, holding ASCII codes
      .map(n =>           //   for each ASCII code n in there:
        ( g = i =>        //     g = recursive function taking i = vowel flag
          v(              //       update n and invoke v on the new value:
            n = n % 61 ?  //         if n is less than 122 (meaning less than 'z'):
              n + 1       //           increment n
            :             //         else:
              97          //           wrap around by setting n to 97 (meaning 'a')
          ) ^ i ?         //       if v(n) is not equal to i:
            g(i)          //         do recursive calls until it is
          :               //       else:
            n             //         stop recursion and return the new n
        )(v(n))           //     initial call to g with i = v(n)
      )                   //   end of map()
    )[0],                 //   invoke v on a[0]
    a += ''               //   coerce the updated Buffer back to a string
  ) ?                     // if a[0] is a vowel:
    a                     //   return the string as-is
  :                       // else:
    a.slice(1) + a[0]     //   move the leading consonant to the end
    + 'ay'                //   and append the 'ay' suffix

Python 2, 153 121 110 99 91 bytes
lambda s:[s[1:]+s[0]+"ux",s][s[0]in'aeiou'].translate(8*".ecdfighjoklmnpuqrstvawxyzb.....")

Try it online!
8 bytes shaved off due to a suggestion by Matthew Jensen

You can save 8 bytes by using string.translate() function: lambda s:[s[1:]+s[0]+"ux",s][s[0]in'aeiou'].translate(8*".ecdfighjoklmnpuqrstvawxyzb.....")

@MatthewJensen Clever! Usually I avoid translate in Python 2...

Coincidentally, it now also works for upper case as well

T-SQL, 169 bytes
SELECT IIF(CHARINDEX(LEFT(a,1),'aeiou')=0,SUBSTRING(a,2,99)+LEFT(a,1)+'ay',a)FROM
(SELECT TRANSLATE(v,'aeioubcdfghjklmnpqrstvwxyz','eiouacdfghjklmnpqrstvwxyzb')a FROM t)s

Input is via a pre-existing table, per our IO standards.
Performs the characters substitution first, using the (new to SQL 2017) TRANSLATE function, then checks the first character.
Annoying long mostly due to SQL keyword length.

Shell script, 70 bytes
tr a-z b-{|tr eiou{bfjpv fjpvbeioua|sed -E 's/^([^aeiou])(.*)/\2\1ay/'

Try it online!

Haskell, 102 97 bytes
h(c:r)|elem c"aeiou"=c:r|True=r++c:"ay"
f s=h["ecdfighjoklmnpuqrstvawxyzb"!!(fromEnum y-97)|y<-s]

Try it online!

Jelly, 24 bytes
,ṙ¥1y
ØẹçØḄçṙḢe©ØḄƊ®⁾ayx

Try it online!
Saved 1 byte thanks to Jonathan Allan (use the two-char syntax rather than quotes).

Unfortunately far longer sane, non-sneaky version (1-byte shorter sneaky equivalent). I won't be able to update this within the next few hours, but do point out if you find improvements.

Use ⁾ay for a byte. The © could go after the e since that is what you are storing. I have ØẹØḄ,żṙ€¥1ẎyṙḢe©ØḄƊ®⁾ayẋ.

Retina 0.8.2, 50 bytes
T`uo`aei\oub-df-hj-np-tv-zb
^([^aeiou])(.*)
$2$1ay

Try it online! Link includes test cases. Similar approach to the R answer. Explanation:
T`uo`aei\oub-df-hj-np-tv-zb

o refers to the other set, i.e. aei\oub-df-hj-np-tv-zb, which expands to aeioubcdfghjlkmnpqrstvwxyzb, so uo expands to uaeioubcdfghjlkmnpqrstvwxyzb. This results in the following transliteration:
uaeioubcdfghjlkmnpqrstvwxyzb
aeioubcdfghjlkmnpqrstvwxyzb

The second u and b are ignored as they can never be matched, so this provides the desired cipher. (Note that in Retina 1 you can of course use v instead of aei\ou for a 5 byte saving.)
^([^aeiou])(.*)
$2$1ay

If the first letter is not a vowel, rotate it to the end and suffix ay.

><>, 94 92 bytes
i:0(?v"a"%
2%?!v\~r:5g
a2r}<vr+ad*
ol?!;>4g
ecdfighjoklmnpuqrstvawxyzb
1   1   1     1     1

Try it online!
Edit: Saved 2 bytes by taking input mod 97 rather than 32, so the dictionary could start at the beginning of the line. Previous version:
i:0(?v84*%
2%?!v\~r:5g
37r}<vr*46*
ol?!;>4g
 ecdfighjoklmnpuqrstvawxyzb
 1   1   1     1     1

Red, 149 bytes
func[s][c:"aeioua.bcdfghjklmnpqrstvwxyzb"t: copy""foreach p s[append t c/(1
+ index? find c p)]if 7 < index? find c t/1[move t tail t append t"ay"]t]

Try it online!
As (almost) always, the longest entry

Perl 5, 56 bytes
y/a-z/ecdfighjok-npuq-tvaw-zb/;s/^([^aeiou])(.*)/$2$1ay/

Try it online!

Do you need the -s between c and d or g and h?

@Neil no I don't. I wrote a program to compress the ranges... and got the logic wrong :) Thanks.

Normally in such cases you write <s>58</s> 56 bytes in the header and many people add a "Edit: Saved 2 bytes thanks to @Neil." or some such when they are helped in a comment.

F# (Mono), 197 bytes
let f(s:string)=
 let a="aeiouabcdfghjklmnpqrstvwxyzb"
 new string(s|>Seq.map(fun c->a.[a.IndexOf(c)+1])|>Seq.toArray)|>(fun x->if a.IndexOf(x.[0])>5 then x.Substring(1)+(string x.[0])+"ay"else x)

Try it online!

JavaScript (SpiderMonkey), 107 bytes
x=>x.replace(/./g,y=>(z='aeiouabcdfghjklmnpqrstvwxyzb')[z.search(y)+1]).replace(/^([^aeiou])(.+)/,'$2$1ay')

Try it online!
Expects input in lowercase.
Replaces each character of the string with a the one after it in the string 'aeiouabcdfghjklmnpqrstvwxyzb', and then piglatinifies anything with an initial consonant.

PHP, 112 bytes
<?=strtr(($s=strstr(aeiou,($s=$argn)[0])?$s:substr($s,1).$s[0].ux),join(range(a,z)),ecdfighjoklmnpuqrstvawxyzb);

or
<?=strtr(($s=strstr(aeiou,($argn)[0])?$argn:substr($s,1).$s[0].ux),join(range(a,z)),ecdfighjoklmnpuqrstvawxyzb);

assume lower case input. Run as pipe with -nR or try them online.

You could as well use
strtr($s,uzbcadfgehjklminpqrsotvwxy,range(a,z)) instead of
strtr($s,range(a,z),ecdfighjoklmnpuqrstvawxyzb).

Dyalog APL (SBCS), 57 bytes
{a←⎕A{(⍺~⍵)⍵}'AEIOU'⋄('AY',⍨1⌽⊢)⍣(∊/⊃¨⍵a)⊢(⊂⍵⍳⍨∊a)⌷∊1⌽¨a}

Try it online!
Takes input in uppercase only! (Because ⎕A is uppercase alphabet)

⎕A{(⍺~⍵)⍵}'AEIOU': Vector of consonants and vowels
(⊂⍵⍳⍨∊a)⌷∊1⌽¨a: Uses indices of each letter of the word in the normal alphabet (⊂⍵⍳⍨∊a) to index (⌷) into the cipher ∊1⌽¨a.
('AY',⍨1⌽⊢)⍣(∊/⊃¨⍵a): Moves first letter to the end and appends 'AY', if the first letter is a consonant.

Thanks for the cool challenge!

Lexurgy, 202 bytes
class C {b,c,d,f,g,h,j,k,l,m,n,p,q,r,s,t,v,w,x,y,z}
class V {a,e,i,o,u}
c:
{@C,@V}=>{{c,d,f,g,h,j,k,l,m,n,p,q,r,s,t,v,w,x,y,z,b},{e,i,o,u,a}}
p:
([]+)$1 *=>$1/$ @V _
(@C+)$1 ([]*)$2=>$2 $1 ay/$ _


text:
Longest Repeating Subsequence of a Single Digit
Challenge:
Given a positive integer, output the longest single-digit subsequence that occurs at least twice, AND has boundaries of another digit (or the start/end of the integer).
An example:
Input: 7888885466662716666
The longest subsequence of a single digit would be 88888 (7[88888]5466662716666) with a length of 5. However, this subsequence only occurs once in the integer.
Instead, the result for input 7888885466662716666 should be 6666 (78888854[6666]271[6666]), since it occurs (at least) twice.
Challenge rules:

Length of the subsequences takes priority over the amount of times it occurs. (I.e. with input 8888858888866656665666, we output 88888 ([88888]5[88888]66656665666; length 5, occurs twice), and not 666 (88888588888[666]5[666]5[666]; length 3, occurs thrice).
If the length of multiple subsequences are equal, we output the one with the largest occurrence-count. I.e. with input 3331113331119111, we output 111 (333[111]333[111]9[111]; length 3, occurs thrice), and not 333 ([333]111[333]1119111; length 3 as well, but occurs twice)
If the occurrence-count and length of multiple subsequences are equal, you can output either of them, or all (in any order). I.e. with input 777333777333, the possible outputs are: 777; 333; [777, 333]; or [333, 777].
The subsequence must have boundaries of other digits (or the start/end of the integer). I.e. with input 122222233433 the result is 33 (1222222[33]4[33]; length 2, occurs twice) and not 222 (1[222][222]33433, length 3, occurs twice with both invalid).

This applies to all numbers that are counted towards the occurrence-counter. I.e. with input 811774177781382 the result is 8 ([8]117741777[8]13[8]2; length 1, occurs thrice) and not 77 (811[77]41[77]781382 / 811[77]417[77]81382; length 2, occurs twice with one invalid) nor 1 (8[1][1]774[1]7778[1]382; length 1, occurs four times with two invalid).

You can assume the input won't contain any digits 0 (it will match [1-9]+). (This is to avoid having to deal with test cases like 10002000 that should output 000, where most languages would output 0 by default.)
You can assume the input will always contain at least one valid output.
I/O are both flexible. Can be a list/array/stream of digits/bytes/characters or as string instead of a single integer.

General rules:

This is code-golf, so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
Standard rules apply for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
Default Loopholes are forbidden.
If possible, please add a link with a test for your code.
Also, adding an explanation for your answer is highly recommended.

Test cases:
Input:  7888885466662716666 / [7,8,8,8,8,8,5,4,6,6,6,6,2,7,1,6,6,6,6]
Output: 6666                / [6,6,6,6]

Input:  3331113331119111 / [3,3,3,1,1,1,3,3,3,1,1,1,9,1,1,1]
Output: 111              / [1,1,1]

Input:            777333777333                   / [7,7,7,3,3,3,7,7,7,3,3,3]
Possible outputs: 777; 333; [777,333]; [333;777] / [7,7,7]; [3,3,3]; [[7,7,7],[3,3,3]]; [[3,3,3],[7,7,7]]

Input:  122222233433 / [1,2,2,2,2,2,2,3,3,4,3,3]
Output: 33           / [3,3]

Input:  811774177781382 / [8,1,1,7,7,4,1,7,7,7,8,1,3,8,2]
Output: 8               / [8]

Input:  555153333551 / [5,5,5,1,5,3,3,3,3,5,5,1]
Output: 1            / [1]

Input:            12321              / [1,2,3,2,1]
Possible outputs: 1; 2; [1,2]; [2,1] / [1]; [2]; [[1],[2]]; [[2],[1]]

Input:  944949949494999494 / [9,4,4,9,4,9,9,4,9,4,9,4,9,9,9,4,9,4]
Output: 4                  / [4]

Input:  8888858888866656665666 / [8,8,8,8,8,5,8,8,8,8,8,6,6,6,5,6,6,6,5,6,6,6]
Output: 88888                  / [8,8,8,8,8]

Input:  1112221112221111               / [1,1,1,2,2,2,1,1,1,2,2,2,1,1,1,1]
Output: 111; 222; [111,222]; [222,111] / [1,1,1]; [2,2,2]; [[1,1,1],[2,2,2]]; [[2,2,2],[1,1,1]]

Input:  911133111339339339339339 / [9,1,1,1,3,3,1,1,1,3,3,9,3,3,9,3,3,9,3,3,9,3,3,9]
Output: 111                      / [1,1,1]

Suggested test case: 8888858888866656665666. If I interpreted the challenge correctly, both the Brachylog and 05AB1E solutions fail.

@Mr.Xcoder Added, thanks.

@Arnauld Hmm, it would be one of the winners anyway in my opinion because it occurs as many times as 222 when bounded by other integers. I guess we just shouldn't count the occurrence that is a substring of 1111. Better wait for the OP though, indeed.

@Arnauld For 1112221112221111 these are the subsequences and their counts: 1111 (1), 111 (2), 222 (2). Since we only outputs sequences occurring at least twice, the output can be one of: 111, 222, [111,222], [222,111]. (See the fourth rule for some more information.) Basically 1111 will only ever count as 1111, and not as 1 and 111 or 11 and 11. I'll add your test case, but the output is either or both of 111 and 222.

Vyxal o, 68 bitsv2, 8.5 bytes
Ġ:UÞ⊍⁽LO∆M

Try it Online!
groups by identical adjacent digits, finds the duplicated elements, then takes the most common of the longest runs.

05AB1E, 14 bytes
γÐ¢1›ÏD€gZQÏ.M

Try it online!
Explanation
γ                # group consecutive equal elements
 Ð¢              # count the occurrence of each group among the list of groups
   1›Ï           # keep only groups with a count greater than 1
      D€gZQÏ     # keep only those with a length equal to the greatest length
            .M   # get the most common item

@Riley: Unfortunately that would get the first element which is not necessarily the most common one.

Oops.. I missed that bullet.

Jelly, 12 bytes
Œgœ-Q$LÐṀÆṃ'

Try it online!
Previous version – 14 bytes
ŒgŒQ¬TịƲLÐṀÆṃ'

Try it online!
How it works?
Œgœ-Q$LÐṀÆṃ' – Full program. Receives a list of digits as input.
Œg           – Group equal adjacent values.
  œ-Q$       – Multiset difference with itself deduplicate.
      LÐṀ    – Keep those that are maximal by length.
         Æṃ' – Mode. Returns the most common element(s).
-------------------------------------------------------------------------
ŒgŒQ¬TịƲLÐṀÆṃ' – Full program. Receives a list of digits as input.
Œg             – Group equal adjacent values.
  ŒQ           – Distinct sieve. Replace the first occurrences of each value by 1.
                 and the rest by 0. [1,2,3,2,3,2,5]ŒQ -> [1,1,1,0,0,0,1]
    ¬T         – Negate and find the truthy indices.
      ịƲ       – Then index in the initial list of groups.
               – This discards the groups that only occur once.
        LÐṀ    – Find all those which are maximal by length.
           Æṃ' – And take the mode.

JavaScript (ES6), 79 73 68 bytes
Takes input as a string. Returns an integer.
s=>[...s,r=q=0].map(o=d=>q=s^d?o[!o[q]|r[q.length]?q:r=q]=s=d:q+d)|r

Try it online!
Commented
s =>                      // s = input string, also used as the current digit
  [ ...s,                 // split s into a list of digit characters
    r =                   // r is the final result
    q =                   // q is the current digit sequence
    0                     // append a final dummy entry to force the processing of the last
  ]                       // sequence
  .map(o =                // o is an object used to keep track of encountered sequences
       d =>               // for each digit d in the array defined above:
    q =                   //   update q:
      s ^ d ?             //     if d is not equal to the current digit:
        o[                //       this statement will ultimately update o[q]
          !o[q] |         //         if q has not been previously seen
          r[q.length] ?   //         or the best result is longer than q:
            q             //           leave r unchanged
          :               //         else:
            r = q         //           set r to q
        ] = s = d         //       reset q to d, set the current digit to d
                          //       and mark q as encountered by setting o[q]
      :                   //     else:
        q + d             //       append d to q
  ) | r                   // end of map(); return r, coerced to an integer

Maybe I'm saying something incorrect here, but since ...s converts the input to a list of digit characters, isn't it shorter to just take the input as a list of digit characters to begin with, instead of a string? I've allowed flexible I/O. (But I'm assuming it interferes with another part of your code?)

@KevinCruijssen The problem is that I need an extra iteration to process the last sequence. So I'd need to do [...s,0] even if s already is a list.

Retina, 56 bytes
L`(.)\1*
O`
L$m`^(.+)(¶\1)+$
$#2;$1
N`
.+;

N$`
$.&
-1G`

Try it online! Link includes test cases. Explanation:
L`(.)\1*

List all the maximally repeated digit subsequences.
O`

Sort the list into order.
L$m`^(.+)(¶\1)+$
$#2;$1

List all the multiple subsequences with their "count".
N`

Sort in ascending order of count.
.+;

Delete the counts.
N$`
$.&

Sort in ascending order of length. (Where lengths are equal, the previous order due to count is preserved.)
-1G`

Keep the last i.e. longest value.

Perl 6, 58 56 bytes
*.comb(/(.)$0*/).Bag.max({.value>1,+.key.comb,.{*}}).key

Try it online!

R, 102 bytes
function(i)rep(names(sort(-(x=(x=table(rle(i)))[rowSums(x>1)>0,,drop=F])[m<-max(rownames(x)),])[1]),m)

Try it online!
Since there wasn't an R answer yet, I decided to give it a try, and well... it wasn't easy. I don't really know whether it is a good approach, but here it goes.
Inputs and outputs vectors of characters.

Close to 100 bytes is pretty good for R with this challenge.

Python 2, 123 120 bytes
import re
def f(s):r=re.findall(r'(\d)(\1*)',s);c=r.count;print max((len(a+b)*(c((a,b))>1),c((a,b)),a+b)for a,b in r)[2]

Try it online!

Powershell, 101 byte
($args|sls '(.)\1*'-a|%{$_.Matches}|group|?{$_.Count-1}|sort @{e={$_.Name.Length,$_.Count}})[-1].Name

Explanied test script:
$f = {

(
    $args|          # for each argument (stings)
    sls '(.)\1*'-a| # searches all
    %{$_.Matches}|  # regex matches
    group|          # group it (Note: Count of each group > 0 by design)
    ?{$_.Count-1}|  # passthru groups with Count not equal 1
    sort @{         # sort all groups by 2 values
        e={$_.Name.Length,$_.Count}
    }
)[-1].Name          # returns name of last group (group with max values)

}

@(
    ,('7888885466662716666', '6666')
    ,('3331113331119111', '111')
    ,('777333777333', '777','333')
    ,('122222233433', '33')
    ,('811774177781382', '8')
    ,('555153333551','1')
    ,('12321', '1','2')
    ,('944949949494999494','4')
    ,('8888858888866656665666','88888')
    ,('1112221112221111','111','222')
) | % {
    $s,$e = $_
    $r = &$f $s
    "$($r-in$e): $r"
}

Output:
True: 6666
True: 111
True: 777
True: 33
True: 8
True: 1
True: 1
True: 4
True: 88888
True: 111

Python 2, 114 113 bytes
-1 byte thanks to TFeld.
p='';r=[];C=r.count
for c in input():r+=['']*(c!=p);r[-1]+=c;p=c
print max((len(w),C(w),w)for w in r if~-C(w))[2]

Try it online!

Haskell, 72 bytes
import Data.Lists
g!x|y<-countElem x g=(y>1,1<$x,y)
(argmax=<<(!)).group

How it works
(argmax=<<(!)).group       -- expands to: f i = argmax (group i !) (group i)
    group                  -- split the input list into subsequences of equal digits
                           -- e.g. "1112211" -> ["111","22","11"]

                           -- find the element of this list where the function !
                           -- returns the maximum value. First parameter to !
                           -- is the grouped input list, second parameter the
                           -- the element to look at

g!x|
    y<-countElem x g       -- let y be the number of occurrences of x in g
  = (  ,   ,  )            -- return a triple of
     y>1                   -- a boolean y>1  (remember: True > False)
        1<$x               -- length of x (to be exact: all elements in x
                           -- replaced by 1. This sorts the same way as the
                           -- length of x)
             y             -- y
                           -- a triples sorts lexicographical

Do you not need to use Haskell + lists as language because Data.Lists is not part of base?

@BWO: don't know. I've always used a plain "Haskell", even when I imported an exotic library (e.g. Gloss for graphical output or Matrix). I use "Haskell + something" if I don't want to include the byte count for the imports. I think we had this topic on meta, but I cannot find it anymore. If I remember correctly, we had no general definition of "standard library".  What should be the reference for Haskell? The Haskell Report, GHC's base, Haskell Plattform, something else?

IMO it should be as with C/JavaScript/.. that (if it matters) we need to use Haskell (GHC) or Haskell (Hugs) etc. because the implementation specifies a language on PPCG. So for a GHC answer that would include base and for all the other ones I wouldn't know :D

Do you perhaps have a TIO link so it can be tested? Or is the Data.Lists library not available on TIO or another online Haskell compiler?

@KevinCruijssen: yes Data.Lists is missing on TIO. You can test it with this version.

R, 85 bytes
function(x,R=rle(x),a=ave(R$v,R,FUN=length))rep(R$v[o<-order(a<2,-R$l,-a)[1]],R$l[o])

Try it online!

Input : a vector of separated integer digits e.g. c(1,8,8...)
Output : a vector of separated integer digits

Unrolled code with explanation :
function(x){                # x is a vector of digits : e.g. c(1,1,8,8,1,1)

R = rle(x)                  # Get the sequences of consecutive repeating digits
                            # doing run length encoding on x, i.e. : R is a list
                            # with the digits (R$values) and the number of their
                            # consecutive occurrencies (R$lengths)
                            # N.B. you can use R$v for R$values and R$l for R$lenghts

a=ave(R$v,R,FUN=length)     # Group R$v by R$l AND R$v, count the occurrencies
                            # for each group and "unroll" the value of each
                            # group to the original R$v length.
                            # Here basically we count the occurrencies of the same
                            # sequence.

o<-order(a<2,-R$l,-a)[1]    # Get the indexes used to order by a < 2 then by -R$l and
                            # finally by -a; store the first index in "o".
                            # Here basically we use order to select the first sequence
                            # repeated at least twice, in case of ties the sequence
                            # with the greatest length and in case of ties the most
                            # repeated sequence.

rep(R$v[o],R$v[o])          # Using the index "o", we reconstruct the sequence repeating
                            # R$l[o] times R$v[o]
}

Alternative version accepting vector of integer or character digits :
R, 88 bytes
function(x,R=rle(x),a=ave(R$v,R,FUN=length))rep(R$v[o<-tail(order(a>1,R$l,a),1)],R$l[o])

Try it online!

Input : a vector of separated characters or digits e.g. c("1","8","8"...) or c(1,8,8...)
Output : a vector of separated characters if the input was a vector of characters, a vector of digits if the input was a vector of digits

Can you add an explanation? I don't understand how it's working.

@JayCe: done! (I've added details that you well know, just for non-R users ;) )

ty! It makes sense now.

Wolfram Language (Mathematica), 67 bytes
#&@@@MaximalBy[Select[Tally@Split@#,Last@#>1&],{Length@#,#2}&@@#&]&

Pure function. Takes a list of digits as input and returns a list of subsequences (in no particular order) as output. Not sure if the "must appear at least twice" clause can be handled more cleanly.
Try it online!

Could you perhaps add a TIO link for it?

If you really insist...

Ruby, 68 67 bytes
->a{(b=a.chunk &:+@).max_by{|x|[(c=b.count x)<2?0:x[1].size,c]}[1]}

Try it online!
Inputs and outputs arrays of chars.
The approach is pretty straightforward: we identify the runs of consecutive digits (chunk using unary + as identity function) and take the maximum - first by the size of the run (reset to zero if its occurrence count is < 2), then by the count itself.

Red, 256 250 bytes
func[s][p: func[b][sort parse b[collect[any keep[copy a skip thru any a]]]]first
last sort/compare collect[foreach d p p s[if 1 < k: length? to-block d[keep/only
reduce[form unique d k]]]]func[x y][(reduce[length? x/1 x/2])< reduce[length? y/1 y/2]]]

Try it online!
Really, realy long solution this time... (sigh)
Takes the input as a string.
Explanation:
f: func [ s ] [
    p: func [ b ] [                        ; groups and sorts the adjacent repeating items
        sort parse b [
            collect [
                any keep[
                    copy a skip thru any a ; gather any item, optionally followed by itself
                ]
            ]
        ]
    ]
    t: copy []
    foreach d p p s [                     ; p p s transforms the input string into a block of sorted blocks of repeating digits
        if 1 < k: length? to-block d [    ; filters only the blocks that occur more than once
            insert/only t reduce [ form unique d k ] ; stores the digits and the number of occurences
                                          ; "8888858888866656665666" -> [["5" 3] ["666" 3] ["88888" 2]]
        ]
    ]
    first last sort/compare t func [ x y ] ; takes the first element (the digits) of the last block of the sorted block of items
        [ (reduce [ length? x/1 x/2 ]) < reduce [ length? y/1 y/2 ] ] ; direct comparison of the blocks
]

Java (JDK 10), 213 bytes
s->{int l=99,X[][]=new int[10][l],d,D=0,m=0,M=0;for(var x:s.split("(?<=(.))(?!\\1)"))X[x.charAt(0)-48][x.length()]++;for(;M<1&&l-->1;)for(d=0;d++<9;)if((m=X[d][l])>1&m>M){M=m;D=d;}for(;l-->0;)System.out.print(D);}

Try it online!
Explanation (outdated)
s->{                                    // Lambda for Consumer<String>
 int l=99,                              //  Length of token, max is 99.
     X[][]=new int[10][l],              //  Array containing the occurrences per token
     d,                                 //  digit value
     D=0,                               //  digit holder for best sequence candidate
     m=0,                               //  holder of the current candidate
     M=0;                               //  best candidate for the current length of token.
 for(var x:s.split("(?<=(.))(?!\\1)"))  //  Tokenize the string into digit-repeating sequences
  X[x.charAt(0)-48][x.length()]++;      //   Add one occurrence for the token
 for(;M<1&&l-->1;)                      //  While no value has been found and for each length, descending. Do not decrease length if a value has been found.
  for(d=0;d++<9;)                       //   for each digit
   if((m=X[d][l])>1&m>M){               //    if the current occurrence count is at least 2 and that count is the current greatest for the length
    M=m;D=d;                            //     mark it as the current best
   }                                    //
 for(;l-->0;)System.out.print(D);       //  Output the best-fitting subsequence.
}                                       //

Credits

-9 bytes and bug spotting thanks to Kevin Cruijssen

I'm afraid there is a small flaw in your j*o>M check. If I understand correctly it takes the max length * occurrence-count. But for a test case like 1113311133933933933933 for example, the 111 would be (3 * 2 = 6), and the 33 would be (2 * 6 = 12). So it outputs 33 having the highest occurrence, instead of 111 being the longest occurring at least twice. Also, var r="";for(;O-->0;)r+=D;return r; can be golfed to for(;O-->0;)System.out.print(D); in Java 10, or even shorter in Java 11: return(D+"").repeat(O);.

@KevinCruijssen I think I fixed it.

That indeed looks better, and nice way of golfing bytes at the same time. You just forgot to update your explanation. And you can golf 1 more byte changing int X[][]=new int[10][99],d,l=99, to int l=99,X[][]=new int[10][l],d,.

@KevinCruijssen Thanks! I also golfed one more byte by writing d++<9 instead of ++d<10. Sorry for the rest: I'm rather tired today =_=

PCRE, 152 bytes
(\d)(?<!(?=\1)..)(?=(\1*)(?!\1).*(?!\1).\1\2(?!\1))(?!(?:(?=\2((\3?+)(\d)(\5*)))){1,592}?(?=\2\3.*(?!\5).\5\6(?!\5))(?:\1(?=\1*\4\5(\7?+\5)))*+(?!\1))\2

See it in action on: https://regex101.com/r/0U0dEp/1 (just look at the first match in each test case)
This is just for fun, since regex isn't a real programming language in and of itself, and the solution is limited :P
Because a zero-width group such as (?:)+ only matches once and doesn't repeat indefinitely, and because PCRE internally makes copies of groups quantified with limits, I've had to use a magic number in there ("{1,592}"), which means we can only look up to 592 contiguous sets of digits ahead to find a competing set that could be longer than the one currently under inspection. More info on this concept here.

Perl 5, 88 bytes
my($m,%s);++$i%2*$s{$_}++&&($n=$s{$_}/9+length)>$m&&($a=$_,$m=$n)for pop=~/((.)\2*)/g;$a

Try it online!
Slightly ungolfed, with tests:
sub f {
  my($m,%s);
  my($i,$n,$a);           #not needed in golfed version
  ++$i % 2  *  $s{$_}++
  && ($n=$s{$_}/9+length) > $m
  && ($a=$_, $m=$n)
    for pop=~/((.)\2*)/g; #i.e. 7888885466662716666 => 7 88888 5 4 6666 2 7 1 6666
  $a
}
for(map[/\d+/g],split/\n/,join"",<DATA>){ #tests
  my($i,@e)=@$_;
  printf "%-6s   input %-24s   expected %-10s   got %s\n",
    (grep f($i) eq $_, @e) ? "Ok" : "Not ok", $i, join('|',@e), f($i);
}
__DATA__
Input:  7888885466662716666     Output: 6666
Input:  3331113331119111        Output: 111
Input:  777333777333            Output: 777|333
Input:  122222233433            Output: 33
Input:  811774177781382         Output: 8
Input:  555153333551            Output: 1
Input:  12321                   Output: 1|2
Input:  944949949494999494      Output: 4
Input:  8888858888866656665666  Output: 88888
Input:  1112221112221111        Output: 111|222

Japt -h, 12 bytes
Input & output are strings.
ò¦ ñÊf@ÓZè¶X

Try it