text:
lc's dvntrs n Wndrlnd
The task
Today's special offer: consonants and punctuation for FREE!
Your program or function will be given as input the first 6 paragraphs of Lewis Carroll's famous novel Alice's Adventures in Wonderland, with all vowels [aeiouAEIOU] removed and all other characters left intact.
It must output the original text, byte-for-byte identical.
The shortest answer in bytes wins.
You may store your data in one or several files, as long as this is done under the rules for scoring multiple files. Please consider providing a way to access these files in your answer if you do so.
As a reminder, fetching data from any other external source is forbidden (this is a default loophole). If you do that, you'll be trapped in the Rabbit hole for 6 months.
Input
Your program or function will be given this exact ASCII string, where 703 vowels are missing:
lc ws bgnnng t gt vry trd f sttng by hr sstr n th bnk, nd f hvng nthng t d: nc r twc sh hd ppd nt th bk hr sstr ws rdng, bt t hd n pctrs r cnvrstns n t, "nd wht s th s f  bk," thght lc "wtht pctrs r cnvrstns?"
S sh ws cnsdrng n hr wn mnd (s wll s sh cld, fr th ht dy md hr fl vry slpy nd stpd), whthr th plsr f mkng  dsy- chn wld b wrth th trbl f gttng p nd pckng th dss, whn sddnly  Wht Rbbt wth pnk ys rn cls by hr.
Thr ws nthng s _vry_ rmrkbl n tht; nr dd lc thnk t s _vry_ mch t f th wy t hr th Rbbt sy t tslf, "h dr! h dr!  shll b lt!" (whn sh thght t vr ftrwrds, t ccrrd t hr tht sh ght t hv wndrd t ths, bt t th tm t ll smd qt ntrl); bt whn th Rbbt ctlly _tk  wtch t f ts wstct-pckt_, nd lkd t t, nd thn hrrd n, lc strtd t hr ft, fr t flshd crss hr mnd tht sh hd nvr bfr sn  rbbt wth thr  wstct- pckt, r  wtch t tk t f t, nd brnng wth crsty, sh rn crss th fld ftr t, nd frtntly ws jst n tm t s t pp dwn  lrg rbbt-hl ndr th hdg.
n nthr mmnt dwn wnt lc ftr t, nvr nc cnsdrng hw n th wrld sh ws t gt t gn.
Th rbbt-hl wnt strght n lk  tnnl fr sm wy, nd thn dppd sddnly dwn, s sddnly tht lc hd nt  mmnt t thnk bt stppng hrslf bfr sh fnd hrslf fllng dwn  vry dp wll.
thr th wll ws vry dp, r sh fll vry slwly, fr sh hd plnty f tm s sh wnt dwn t lk bt hr nd t wndr wht ws gng t hppn nxt. Frst, sh trd t lk dwn nd mk t wht sh ws cmng t, bt t ws t drk t s nythng; thn sh lkd t th sds f th wll, nd ntcd tht thy wr flld wth cpbrds nd bk-shlvs; hr nd thr sh sw mps nd pctrs hng pn pgs. Sh tk dwn  jr frm n f th shlvs s sh pssd; t ws lblld "RNG MRMLD", bt t hr grt dsppntmnt t ws mpty: sh dd nt lk t drp th jr fr fr f kllng smbdy ndrnth, s mngd t pt t nt n f th cpbrds s sh fll pst t.

Size: 1677 bytes
Paragraph separator: LF
SHA-256: df40659e07f6185ea348028dd22f137902fa50b9abcb790ff39353e189656c6f

Output
Your code must print or return this exact string.
Alice was beginning to get very tired of sitting by her sister on the bank, and of having nothing to do: once or twice she had peeped into the book her sister was reading, but it had no pictures or conversations in it, "and what is the use of a book," thought Alice "without pictures or conversations?"
So she was considering in her own mind (as well as she could, for the hot day made her feel very sleepy and stupid), whether the pleasure of making a daisy- chain would be worth the trouble of getting up and picking the daisies, when suddenly a White Rabbit with pink eyes ran close by her.
There was nothing so _very_ remarkable in that; nor did Alice think it so _very_ much out of the way to hear the Rabbit say to itself, "Oh dear! Oh dear! I shall be late!" (when she thought it over afterwards, it occurred to her that she ought to have wondered at this, but at the time it all seemed quite natural); but when the Rabbit actually _took a watch out of its waistcoat-pocket_, and looked at it, and then hurried on, Alice started to her feet, for it flashed across her mind that she had never before seen a rabbit with either a waistcoat- pocket, or a watch to take out of it, and burning with curiosity, she ran across the field after it, and fortunately was just in time to see it pop down a large rabbit-hole under the hedge.
In another moment down went Alice after it, never once considering how in the world she was to get out again.
The rabbit-hole went straight on like a tunnel for some way, and then dipped suddenly down, so suddenly that Alice had not a moment to think about stopping herself before she found herself falling down a very deep well.
Either the well was very deep, or she fell very slowly, for she had plenty of time as she went down to look about her and to wonder what was going to happen next. First, she tried to look down and make out what she was coming to, but it was too dark to see anything; then she looked at the sides of the well, and noticed that they were filled with cupboards and book-shelves; here and there she saw maps and pictures hung upon pegs. She took down a jar from one of the shelves as she passed; it was labelled "ORANGE MARMALADE", but to her great disappointment it was empty: she did not like to drop the jar for fear of killing somebody underneath, so managed to put it into one of the cupboards as she fell past it.

Size: 2380 bytes
Paragraph separator: LF
SHA-256: 86abbfeb5dfa10bd9b266ea91723b9f79ab49306e2e8266174a0aa4c49ba7d57

You can use this script to test your output.

What if I fetch data from external resources and only return it after 6 months?

@RGS I'm afraid you can't fool the White Rabbit that easily... :-/

Mathematica has an useful built-in: ExampleData[{"Text", "AliceInWonderland"}]. Is it allowed? :)

@mypronounismonicareinstate I should have seen it coming! But please ... no. :-)

Something something Wheel of Fortune something something I'd like to buy a vowel...  There's a joke in there somewhere, fill in the details yourself.

Is the Mathematica text really identical?

One thing I really like about this challenge is the scores aren't simply dominated by the choice of language: golfing languages first, regular languages next, weird esoteric languages like brainfuck last. Data encoding is the biggest factor here, so more of a level playing field.

@SteveBennett The first 25 characters are the name of the chapter, it seems to have no newlines, and it is much longer (probably the entire novel, but I haven't checked), but it's otherwise the same.

Python 2, 121 + 557 + 1 = 679 bytes
i=0
for c in open('a').read():i=i<<8|ord(c)
s=input();k=0
while i:s=s[:k]+'aeiouAEIO'[i/9%9]+s[k:];k+=i%9+1;i/=81
print s

Try it online!
This needs the following data saved in a file named a:
00000000: 7761 d548 fdb9 2ae6 f85b b98c e171 79b6  wa.H..*..[...qy.
00000010: ff19 d1aa 487f 2d27 03f5 030f 1fa1 df57  ....H.-'.......W
00000020: 0552 e6c3 df80 aeeb 75df 89a8 bd59 55ea  .R......u....YU.
00000030: 2244 fcfa b086 e85c 2835 be0a 230e 67a1  "D.....\(5..#.g.
00000040: adde 0f6d 2e92 b038 905b 5e7a cc04 c536  ...m...8.[^z...6
00000050: dd7a b912 9897 92c0 fe1a 64ff 04c1 7387  .z........d...s.
00000060: a782 f2c0 0510 1400 9724 876f de25 31af  .........$.o.%1.
00000070: f0c5 849d cd9b cca6 a32d 4808 e9b6 221c  .........-H...".
00000080: 3b1f ff7f 38e9 1e69 a42f b038 4b65 e694  ;...8..i./.8Ke..
00000090: 1d94 6743 e616 5b3b c510 d7c5 7b3e 4f31  ..gC..[;....{>O1
000000a0: df7d 2fe9 62df 55c1 3c45 2ea9 5777 2af1  .}/.b.U.<E..Ww*.
000000b0: 3d9c d752 3963 ffd8 7f7b a052 423d f38b  =..R9c...{.RB=..
000000c0: 181e 7562 2653 0a41 3fb4 9d57 9a3c d665  ..ub&S.A?..W.<.e
000000d0: 3bbd 5f5a 731e 4b93 3328 801d e1b0 04af  ;._Zs.K.3(......
000000e0: ab51 9126 0412 9eae 7b88 8dcc c99a 7624  .Q.&....{.....v$
000000f0: 0610 09d5 a8f1 e940 bf5e d281 2497 f372  .......@.^..$..r
00000100: 7d0d a1e6 8dea a6e6 381a a134 8981 998c  }.......8..4....
00000110: 6684 936b 637c 3d94 b287 8aa5 9186 3129  f..kc|=.......1)
00000120: c629 d9bd ac7a a10d 3178 2519 9a7e c45f  .)...z..1x%..~._
00000130: bdd1 e128 526c 8e53 cef1 cee8 5cb4 adb9  ...(Rl.S....\...
00000140: 4ad2 7f4f 3799 73f8 5629 215b 645d 8971  J..O7.s.V)![d].q
00000150: 0ef7 7286 04c2 f596 d27e cfa7 fb46 0ef7  ..r......~...F..
00000160: aeaa d39f f163 d729 d094 887e e7a5 6169  .....c.)...~..ai
00000170: ef50 94b9 85a0 848f 4d66 4314 c3a5 bf56  .P......MfC....V
00000180: 5d3d d6d9 a4bc 88c3 8da5 3393 06bc 6e60  ]=........3...n`
00000190: 9448 47f3 a01b 36e0 fe3a dc6e a7d7 aa6d  .HG...6..:.n...m
000001a0: b8e6 8354 aa38 039b 5788 6330 43d0 0b77  ...T.8..W.c0C..w
000001b0: 32a8 d419 b4b9 d1e1 ffe5 81bf e6a3 a54b  2..............K
000001c0: 725e 0850 3973 c4b2 31fb 5a5c c4cd c142  r^.P9s..1.Z\...B
000001d0: c851 0f57 acf9 12c6 de59 af38 83ee 5c50  .Q.W.....Y.8..\P
000001e0: eae2 0e1d f579 efe0 b871 3a29 6ec9 7167  .....y...q:)n.qg
000001f0: 4ca3 6379 b1b6 6b83 1f84 7e29 d4bc f36f  L.cy..k...~)...o
00000200: 1d61 d26d 519b 05c7 b8f7 2bb9 fa44 95ae  .a.mQ.....+..D..
00000210: 883f 9539 a924 bf6f 1297 dc83 74d5 9571  .?.9.$.o....t..q
00000220: 1345 b844 55b4 b423 3591 dd87 4b         .E.DU..#5...K

Python 3.8, 848 800 789 780 776 bytes
Function that prints the result.
def f(s,k=0):[print(end='AEIOaeiou'[c//9%9]+s[k:(k:=k+c%9)])for c in b"R7/'.8:A017/B8=08/C/('B%:A:AAA.C70/'-./8B/?B080'-%;J9'A8I/BA/%6B8:)&:.I.A&?E?LR708?K8I/BA/%6EB/'A7.99/C:'0(/?MC/B'%/0-02-0)I</10-%I.B%9&$<$9?L/E0?J.B/9J(8;/$7620J1'7/&9:9.0(@22./'A:B2.&&.:(B8R7099B2K?JC/'A-(/&9'@82o-'o-'f(/%310?L8@/&/)8AJ0A1(.?MA%/A./(:J(/7.8(-.0H7/%I)L1/&8&H*?A&(?JA:$9?'A1(?@/&9)0J6/BR70&0A0-1A:&/&C0;(/'.0.@/-/&&99-8/&$9?(A0A&)A%.?JA9(J::I6@</&&D/60&/9(AI%1'K97/A-.9BB&&/&9@.J1///e%A0@1C0R7.&/:./A/A7.:A:/E/'A/?J%$;/&9@/3$:B7.&J0B@/')080J2DAJ3&R7/'A&@1B9%?LA:/1.@0/?L/1&:B&1-01Z81/1'1-0C/12EC/(1B7.(/1CA?A%?K/(AA1''?:A&02=060A?BB(%.?L(/'@:BJ9'?A(A-.(<1/?@/(/7/C/1(@71(0./80:J?((?C/1..).0/''(8I0KIB3/?BB&(A@.C0//(/&09'%/0mS\SRR^KA1-'7&?909&5/9B7/BC/'B-&B8:@.BJ/-)A%%0AJ88@@.C/J?((/1'8"]

Try it online!
Observations: U does not occur in the original text, so there are only 9 distinct vowels. There are at most 8 characters between two vowels.
This means that the value and position of each vowel can be encoded in a single base-81 digit.

wait, is reading from a file allowed?

@ASCII-only The post explicitly mentions this: You may store your data in one or several files, as long as this is done under the rules for scoring multiple files. Please consider providing a way to access these files in your answer if you do so.

Charcoal, 496 bytes
ＵＴ≔⮌⪪⪫Ｅ⁶Ｓ⸿¹θＦ”}➙¬⬤"K9dSmＤ⸿¤{qW26↶s›P?⌕»´[↧!²⊖~ks×◨﹪§^“σ@{″¦ＹＯ↓⊞⊗←,÷@vⅈ8⎇▷➙↖✳Ｈ Σ⧴Z↘?γ↙＆HQ⪫‖³↗↧¦rⅉ⭆&(\²≡›¹,↗&~H*oηoＩs·D +Ｎ⍘q↑Tθ7ＦI#*Ｎr↔№↘№⊟º⁼¶⊞↶⌊ζR‴Ｃ﹪-➙∕⌕∕Π℅ΠJ→6◨∧%9¤ÀＡσＲＨ✂,＆πＣ∨<Ｉ=À=≧d⊗↓‹ＹＡ‖Y%℅_⦃⁺»⌊ζ⟦Ｊ≦χ:Ｋ3» ,M±g±Φ→*›t»Ｓυ_¶pA‹↷e¿ ⁸2+∨Ｘ⁵SmWAL]ＦＫ÷)›¤1⭆ξp₂T>Ｖ§?″(↧⁴↙b⁸1E↘Vⅈ⊗Ｙb⮌¶¿%℅Π;⁴Hz⊙0.×℅ＢＳUa⁻～e⁶⸿⍘ΦδＤÀ»m±Ｄ±≕Ｓs⌈βＡ｜QA⌕↥D¬μB→↔⌕◧Ｅ℅⊖HιVU⌈τ↶ZＦ1Sn⌕\¤�|üA§Qt⌈⮌ρ»≕↶⁵Ｋs3ψ→χ}⌈093⦄LgW‴ιO².huρ▷⊙�K[№ê←⁷Ｄ{π▶BêＴBＡvlＩθn⧴Ｐ;⎇ÀＰξ→↘υＵ>|⌕⁺;⪫ω∨⁵◨‽Z⧴﹪↓ΦLτ,‖&!,⊗αＪ-κ·Z∧⁼1⁴8№✂τＥΦχl}§ＳＶ'‽5⊗⸿β=¤|KＣTG⦃”«§AEIOaeiou÷℅ι⁹Ｆ﹪℅ι⁹⊟θ

Try it online! Link is to verbose version of code. Based on @ovs's approach. Explanation:
ＵＴ

Turn off automatic padding.
≔⮌⪪⪫Ｅ⁶Ｓ⸿¹θ

Read in six lines of text, join them together (I could have used \n but \r made the code easier to write), split into characters, and reverse, thus resulting in a list that I can pop as I go.
Ｆ...«

Loop over a compressed data string.
§AEIOaeiou÷℅ι⁹

Take the ordinal of the character, divide it by 9, and cyclically index into the list of vowels. I used the character codes 36-111 for readability, making the uppercase vowels use codes 81-111, with the cyclic indexing mapping them to start of the list.
Ｆ﹪℅ι⁹

The remainder gives the number of non-vowels to print. Loop that many times.
⊟θ

Remove and print each character as needed from the list generated from the input.

According to the prefix of the compressed string (}) and Charcoal's source code, it seems that the underlying compression algorithm is LZMA. Pretty efficient!

If there is a prefix in the compressed string, wouldn't that mean it's inefficient?

@mypronounismonicareinstate The 1-byte prefix tells how the string is encoded: RAW, DICTIONARY, CHARSET, RLE, BROTLI or LZMA. (Charcoal tries all methods and keeps the one that leads to the shortest result.)

Perl 5, 862 bytes
$g=join'',<>;@v=('aeiouAEIOU'=~/./g,'');for('%21@Q2BcAQb1CRBZaRACa@`SP2cBcCCA3b1Q@Q!1BCQC#QRAPQ 2ZDBPSBD1CSA@2#RB`Z@Ba413@C#ZS$e21RC$RD1CSA@2#ZSQ@SB12RQCb`QPaC$ZCaCPP1AQ!QZA!PZD2ZQAaQ 413P2P@"ZP"S$aCZQS$A3QBT@bBZA@"2!ZATA`R1@BRbQ1Pc1ZAZA1@SBcQZA0@A2`cRE21RRSQZDS$Ca@SA a@BPS2AZHQ XQ WPa@1ZQaS$bC1@A@ZBCDASA`a3$ZC@1CA1@bd@aB12@a!1T"1@40ZDaa@B@D ZS#@@c$CB`"S SA`c#1@BPZATB!CU21PASAQ!cB`A@CaRZ@a@Q1Q31A!@@BRQ"A@@"S cAS@@ZC@13$CBPdBbd2#2ZQ@@CZAB!PABPcD01`TRR1CA!2SSP@A@BS14AaAAG@3AS1caU210ABa1CACB12cBaCZQ@SAC$@0"ZA@BS1AZP"cR10DASS1@PZARATAZCZCDAZPE21@S@C1cRP3$cBaAa31QC$aA`BcPAa!Qf"AaA`Qa!SaAaZCZSa@acR10aAccC#@3$Q@cCA`PS"c@AQZBZaR!SC#SP`13$`a@S2cTBPS#@cA!0bZQaC#1@aB1CaA`c21`aQ1BARdC `c#aAa10ZA1Q@PPbD1TT3QZQC#SP@cC13aQA@a@ARPP1AX5FEE56dSAa R0C"QRPAZqBSR1CSa@SQ CRBc13TAA ZC@01SDBBC313aDC `aA`R'=~/./g){$c=-32+ord;substr($g,$p+=int$c/16,0)=$v[$c%16]and$p++}print$g

Try it online!

You can save a few bytes using -p and moving some of the args around a bit, but keeping the same approach: Try it online! (I had to strip the long string to fit the URL here!)

Thx @DomHastings Maybe I'll update later. I also think I can shave a bit off by doing some huffmanish stuff on the long data string unless it's eaten up by much longer unpacking code.

C (gcc), 817 816 804 bytes
i;a;f(char*t){for(a=0;i="[A80:ABM9:D8KCB>C9K;02L1AMBMKK9JD8:0:78BK:KI:C91:.AWB1LBT8KL90AICB23B;S8J0KIOR_A8CKRCT8KL90AIO:0LB8AC:KD2:1;KRN;K1189:7:<71WA=9;:.S8J1A10@4@LR;K=LR9J:BU0DB<0@A7<U92C80BCD:81M8<<80LBM:</09A2MC]A8CCL:WLRK;0L9.;0B1LA9{:.y:.p1;08=;LRDK8090EKT9L92;JRN08K980DV0;B8A0;78U@80S/W;;0B0T.OI00MRKB2@L.L92MI80B1<UB7K^A819L9:7MB290K;C3;0:8:J89700BC:@900@L.M9L00N08JRKB1VBDVAIA=00K<B719B1MT/82UCC8K97ALL1090BL8S9;99o0J9L8M;^A8/9B;8K9KB8AMB;K=0L9KR0/@<0BL894@MC8/T9LL801<C9U9NNT94]A80L0K8MC1JRMB;9;J8:KR;92BM19;7:h@9;92:;7L;9;NO;0;MC8/;9MMKI0JR:0MK921L@M09:E>C7LKIL128JR2;0LAMUB1LI0M97/D=;KI80;B8K;92MA82;:8B9CVK.2MI;9;8/<8:011DT8UUJ:=KIL10MK8J;:90;09C1189y\\f]]\\eVL9;.C/K@:C19?BLC8KL;0L:.KCBM8JU99.N0/8LTBBKJ8J;TK.2;92C"[a++];t+=i%9)i-=46,printf("%.*s%s",i%9,t,L"aeiouAEIO"+i/9);printf("t.");}

Try it online!
12 bytes off thanks to ceilingcat.
The function f accepts the given text (without vowels) as an argument and it prints the desired text on stdout.

@ceilingcat Remember that function submissions must be reusable.

@ceilingcat Thanks -- I needed to add an initialization for a so that the function would be reusable, but it's still shorter that way than turning from a function into a full program.

@S.S.Anne  I initialized a in ceilingcat's function before posting it, so that the function would be reusable.

@ceilingcat I like the wide char trick, by the way.

Stax, 568 bytes
ï¥æ£░iï╘◙±Γn♪º↔gïÇ┌#w¡▒ åñGD/U▄$╝·ñ}$◙d░╒≡%►Σ┘ô♦╙xWv‼╖♣╛Yn≤┼7F╛«hw¡9ⁿ─┤ê\Ω╜jo(⌠Å▌╩ó░W╙â≤↨7sp↨♪÷○|╫g₧ñ»Q█░╧║Ωτα¼óΘ(ZN⌐╥Uδ~♠*>¥1,╝ⁿf↓╓2à↑☼│Qp≡°▼σ§xó),┴₧ZÉvj┘ç_e└▬`;úpπ↔E¬ƒ▀╘W○ß╫ ì▬W○♪¡÷╥K@≤ZφÄó☼P+<☺øt│¥↨╪ ê▄kI[☺╟▀↨┐>t╦¢F-x╣F|h√ZiE3èâ¼⌠Hû);&Σî╩☺d4☺σi♂∞îóF:;▬╚↓┼F→C◄╓Ω!ß═xªÄ→δ½Gôº{E▲◄╩╫┘╘£o¡╟Ü¥_^+èê╬*φG╬æCH┬mfΣ±┬dï⌂¥àΩ¶ô}∞T▓$xÄú╤∙╪ué≥↕Γ"¢sÉ╬É↨v+gΔä╖§|9¥¶·¶üφ║⌂aΦx⌡-+Æ&bò╪A;Ä╙6╪âqë0Çv↔‼☺§msⁿùVz↨v☺ô╟òö┬♠╪X╢╗Δ√G2ñùP╛2ΩΓ∟↓¥}¿Γ¼t╒╩OS≥UD'_ç╩9b♂╚jy§─╒│42╨Éε░►ëφCº╬‼_ö█V/╖}Z↑2Δ^♪└∞ò1¿ö╨╗⌐╛┌I`π▓◙≈┌]▌#⌐◘Σ;Ç◙°╛vJΔÑ←│6éÆ*Ñ┬╒≥ε┼l&'W♠f┴]┴↓_┬╩ä╗▼╥r%ªè♣▓↔Φa»¬┌-↨d┤╛εE,↨²└╠YâVΦL⌂♣"╬b)╠é

Run and debug it

ES2015 800 799 characters/bytes
(i,p=0)=>[..."2h`X_ikrabh`sinai`t`YXsVkrkrrr_tha`X^_`is`psaiaX^Vl{jXriz`sr`VgsikZWk_z_rWpvp}2haip|iz`sr`Vgvs`Xrh_jj`tkXaY`p~t`sXV`a^ac^aZzm`ba^Vz_sVjWUmUjp}`vap{_s`j{Yil`Uhgca{bXh`Wjkj_aYqcc_`Xrksc_WW_kYsi2hajjsc|p{t`Xr^Y`WjXqicO^XO^XFY`Vdbap}iq`W`Zir{arbY_p~rV`r_`Yk{Y`h_iY^_ayh`VzZ}b`WiWy[prWYp{rkUjpXrbYpq`WjZa{g`s2haWara^brkW`WtalY`X_a_q`^`WWjj^i`WUjpYrarWZrV_p{rjY{kkzgqm`WWu`gaW`jYrzVbX|jh`r^_jssWW`Wjq_{b```EVraqbta2h_W`k_`r`rh_krk`v`Xr`p{VUl`Wjq`dUksh_W{asq`XZaia{cur{dW2h`XrWqbsjVp}rk`b_qa`p}`bWksWb^ab:ib`bXb^at`bcvt`Ybsh_Y`btrprVp|`YrrbXXpkrWacnagarpssYV_p}Y`Xqks{jXprYr^_Ymb`pq`Y`h`t`bYqhbYa_`iak{pYYpt`b__Z_a`XXYiza|zsd`pssWYrq_ta``Y`WajXV`aM3<322>|rb^XhWpjajWf`jsh`st`Xs^Wsikq_s{`^ZrVVar{iiqq_t`{pYY`bXi"].map(r=>
(l=(v=r.charCodeAt()-49)%9,'AEIOaeiou'[(v-l)/9]+i.slice(p,p+=l))).join``

const f=

(i,p=0)=>[..."2h`X_ikrabh`sinai`t`YXsVkrkrrr_tha`X^_`is`psaiaX^Vl{jXriz`sr`VgsikZWk_z_rWpvp}2haip|iz`sr`Vgvs`Xrh_jj`tkXaY`p~t`sXV`a^ac^aZzm`ba^Vz_sVjWUmUjp}`vap{_s`j{Yil`Uhgca{bXh`Wjkj_aYqcc_`Xrksc_WW_kYsi2hajjsc|p{t`Xr^Y`WjXqicO^XO^XFY`Vdbap}iq`W`Zir{arbY_p~rV`r_`Yk{Y`h_iY^_ayh`VzZ}b`WiWy[prWYp{rkUjpXrbYpq`WjZa{g`s2haWara^brkW`WtalY`X_a_q`^`WWjj^i`WUjpYrarWZrV_p{rjY{kkzgqm`WWu`gaW`jYrzVbX|jh`r^_jssWW`Wjq_{b```EVraqbta2h_W`k_`r`rh_krk`v`Xr`p{VUl`Wjq`dUksh_W{asq`XZaia{cur{dW2h`XrWqbsjVp}rk`b_qa`p}`bWksWb^ab:ib`bXb^at`bcvt`Ybsh_Y`btrprVp|`YrrbXXpkrWacnagarpssYV_p}Y`Xqks{jXprYr^_Ymb`pq`Y`h`t`bYqhbYa_`iak{pYYpt`b__Z_a`XXYiza|zsd`pssWYrq_ta``Y`WajXV`aM3<322>|rb^XhWpjajWf`jsh`st`Xs^Wsikq_s{`^ZrVVar{iiqq_t`{pYY`bXi"].map(r=>
(l=(v=r.charCodeAt()-49)%9,'AEIOaeiou'[(v-l)/9]+i.slice(p,p+=l))).join``

console.log(f(`lc ws bgnnng t gt vry trd f sttng by hr sstr n th bnk, nd f hvng nthng t d: nc r twc sh hd ppd nt th bk hr sstr ws rdng, bt t hd n pctrs r cnvrstns n t, "nd wht s th s f  bk," thght lc "wtht pctrs r cnvrstns?"
S sh ws cnsdrng n hr wn mnd (s wll s sh cld, fr th ht dy md hr fl vry slpy nd stpd), whthr th plsr f mkng  dsy- chn wld b wrth th trbl f gttng p nd pckng th dss, whn sddnly  Wht Rbbt wth pnk ys rn cls by hr.
Thr ws nthng s _vry_ rmrkbl n tht; nr dd lc thnk t s _vry_ mch t f th wy t hr th Rbbt sy t tslf, "h dr! h dr!  shll b lt!" (whn sh thght t vr ftrwrds, t ccrrd t hr tht sh ght t hv wndrd t ths, bt t th tm t ll smd qt ntrl); bt whn th Rbbt ctlly _tk  wtch t f ts wstct-pckt_, nd lkd t t, nd thn hrrd n, lc strtd t hr ft, fr t flshd crss hr mnd tht sh hd nvr bfr sn  rbbt wth thr  wstct- pckt, r  wtch t tk t f t, nd brnng wth crsty, sh rn crss th fld ftr t, nd frtntly ws jst n tm t s t pp dwn  lrg rbbt-hl ndr th hdg.
n nthr mmnt dwn wnt lc ftr t, nvr nc cnsdrng hw n th wrld sh ws t gt t gn.
Th rbbt-hl wnt strght n lk  tnnl fr sm wy, nd thn dppd sddnly dwn, s sddnly tht lc hd nt  mmnt t thnk bt stppng hrslf bfr sh fnd hrslf fllng dwn  vry dp wll.
thr th wll ws vry dp, r sh fll vry slwly, fr sh hd plnty f tm s sh wnt dwn t lk bt hr nd t wndr wht ws gng t hppn nxt. Frst, sh trd t lk dwn nd mk t wht sh ws cmng t, bt t ws t drk t s nythng; thn sh lkd t th sds f th wll, nd ntcd tht thy wr flld wth cpbrds nd bk-shlvs; hr nd thr sh sw mps nd pctrs hng pn pgs. Sh tk dwn  jr frm n f th shlvs s sh pssd; t ws lblld "RNG MRMLD", bt t hr grt dsppntmnt t ws mpty: sh dd nt lk t drp th jr fr fr f kllng smbdy ndrnth, s mngd t pt t nt n f th cpbrds s sh fll pst t.`));

JavaScript (Node/Browser ES2015) 806 characters
(i,p=0)=>[...'3ypgoz|qrypzqzpphge||oyqpgnopzpqzqgne}{gzppexz|if|oof3yqzzppexpgyo{{p|gqhppgepqnqsnqi~prqneoe{fd~d{pqop{hz}pdyxsqrgypf{|{oqhssopg|soffo|hz3yq{{spgnhpf{gzsSngSngIhpetrqzpfpizqrhoepoph|hpyozhnoqypeirpfzfjfh|d{grhpf{iqxp3yqfqqnr|fpfq}hpgoqopnpff{{nzpfd{hqfieo{h||x~pffpxqfp{herg{ypno{ffpf{orpppHeqrq3yofp|oppyo||ppgped}pf{ptd|yofqpgiqzqstf3ypgfr{e|proqpprf|frnqr<zrprgrnqprsphryohprephrgg|fqsqxqheohpg|{ghnoh~rpphpypprhyrhqopzq|hhprooioqpgghzqtpfhoqpphpfq{gepqQ4>433@rngyf{q{fvp{yppgnfz|opnieeqzzophhprgz'].map(r=>
(l=(v=r.charCodeAt(0)-50)%10,'AEIOUaeiou'[(v-l)/10]+i.slice(p,p+=l))).join('')

In each character I pack both the vowel (including case) and number of source characters to copy. 10 vowels plus length of 0-8 makes 80 possible values to pack into a byte, which is ok.
JavaScript 1273 characters
i=>{n='A2i2ea4e2ii5oe4e5i2eo4ii8e4ieo5ea5a4o4a2i5oi5oooe2o5i2e4ea4e1e2eio4eo1o4e4ie4a4e1a2i6ui4a4oiu2eo4oea2i1o4ii5a6ai5e2u2e2oao1o7o1u5A2i2e4io1u4iu2eo4oea2i1o7o4ea4oi2e2i4i4eo5i5a4e4a5eo1u6o5eo4a4a2ee4e1e4e6e1e4a6u2i7ee5e4e1a2u2e2o4a2i4aa1i7a1i4o1u5eo7e4o1ue2o4ei4ua5ii6ea1i2i1e6e4ue5a4i2eai4i5i4e2e4a5o2e6e6e2ea4oi5o4e6e2aae2i5a5o4iA2i2e4i4i4o4e6u4o1uo5ea4oe1a5eai4a4o2ie6O4e1a4O4e1a4I4a5ea2e7e5e4o1u5io2eaea6ioue4oe5a5e2o1u6oa2eoe2ea5i5ua5ei2e2ia5e1e2e4u1i2ea2u2a6u5e5eaiau1a7o1oaa5o1uoi5a1i4o1a4oe5a5o1o2eai4a6e4ui1eo4A2i2e4ae4oe4e1e5oi5aeao5e4i6a5ea4e2e4e2o2ee1eaai4i4e1ieaa1i4o1a5oe4oaa6oa2e2o1uoi4a5ui5i5u2i1o2i7eaao6ei1e4aei4a5ou2a2e5a4u4i4i2eoe1e2i4o4o4aaeai4o2e2ue5eeeIa2oe4o2e5o5e4A2i2e2aei5e2eoeoi2e2i5oi5eo7ea4oeo1ua2a1i6eai4o2ee7a1i5o4i2e2aue4o4o2ea4a6e4ie4ue6o6oue7aA2i2ea4oao2e5o4i4a2o1u5oi5ee5e2o2e4eo1u5ee5ai5o4ae5e1e4e5E1ie5ee5a4e5e1e4o5ee5e6o7o5ea5e5o4i2e2a5ee5o5oo1oa2o1u4ea5ooe5a4a4o1i5oae4e6i8e4i1e4oo1o4o4a5a2e2o1u5a5ea4o2i5o4ui4a4o1oa5oe1e2a5i7e5eo1o2ea5ei2eo5ee5a5o2i2e5a5e4e2eie4i5uo1a5a5o1o5ee5e2e2a6e2e4ea4a4a5iu2e4u4u2o4e7eo1o4o4aa5oo2e2o5e4eea5eae4i4a4a2ee4O2AEAA2A2E5u4oe5e1a4i2ao1i4e4i4ae9ei4o4i2eo4o5ea4o4e1ao4ii5o2e2o4uee1a6oa2a2e4ouiio2o2e2o5euo1a5a5ee5a4i'
j=p=0
z=''
while (n[j])z += n[j++]+i.slice(p,p+=((+n[j++])||(j--,3))-1)
return z}

Great challenge! Not very impressive submission.

Yeah, maybe the site strips characters out? I'm not sure what the issue is - I can save and run it locally, and I can paste it in the snippet thing here and run it. But saving it mangles it.

Ah, the problem was that some of the characters were backslashes, which broke things. Chose a different offset and now it works.

Nice, glad it worked out. In the future you can try TIO which shouldn't have trouble with backslashes. Of course if you want a snippet, you'd need to do something else. You could probably double each backslash though I'm not sure that would work.

Actually the backslashes were just a problem for me in any case, because they needed to be escaped. Blah, blah, blah. Boring story. Fixed. :)

Retina 0.8.2, 1364 bytes
^
A1i1e2a3e1i2i4o2e3e4i1e2o3i2i7e3i2e2o4e2a4a3o3a1i4o2i4o2o2o2e1o4i1e3e2a3ee1e2i2o3e2oo3e3i2e3a3ea1i5u2i3a3o2i2u1e2o3o2e2a1io3i2i4a5a2i4e1u1e1o2a2oo6ou4A1i1e3i2ou3i2u1e2o3o2e2a1io6o3e2a3o2i1e1i3i3e2o4i4a3e3a4e2ou5o4e2o3a3a1e2e3ee3e5ee3a5u1i6e2e4e3ea1u1e1o3a1i3a2ai6ai3ou4e2o6e3ou2e1o3e2i3u2a4i2i5e2ai1ie5e3u2e4a3i1e2a2i3i4i3e1e3a4o1e5e5e1e2a3o2i4o3e5e1a2a2e1i4a4o3i2A1i1e3i3i3o3e5u3ou2o4e2a3o2ea4e2a2i3a3o1i2e5O3ea3O3ea3I3a4e2a1e6e4e3ou4i2o1e2a2e2a5i2o2u2e3o2e4a4e1ou5o2a1e2o2e1e2a4i4u2a4e2i1e1i2a4ee1e3ui1e2a1u1a5u4e4e2a2i2a2ua6oo2a2a4ou2o2i4ai3oa3o2e4a4oo1e2a2i3a5e3u2ie2o3A1i1e3a2e3o2e3ee4o2i4a2e2a2o4e3i5a4e2a3e1e3e1o1e2ee2a2a2i3i3ei2e2a2ai3oa4o2e3o2a2a5o2a1e1ou2o2i3a4u2i4i4u1io1i6e2a2a2o5e2ie3a2e2i3a4o2u1a1e4a3u3i3i1e2o2ee1i3o3o3a2a2e2a2i3o1e1u2e4e2e2e2I2a1o2e3o1e4o4e3A1i1e1a2e2i4e1e2o2e2o2i1e1i4o2i4e2o6e2a3o2e2ou2a1ai5e2a2i3o1e2e6ai4o3i1e1a2u2e3o3o1e2a3a5e3i2e3u2e5o5o2u2e6a2A1i1e2a3o2a2o1e4o3i3a1ou4o2i4e2e4e1o1e3e2ou4e2e4a2i4o3a2e4ee3e4Ei2e4e2e4a3e4ee3o4e2e4e5o6o4e2a4e4o3i1e1a4e2e4o4o2oo2a1ou3e2a4o2o2e4a3a3oi4o2a2e3e5i7e3ie3o2oo3o3a4a1e1ou4a4e2a3o1i4o3u2i3a3oo2a4o2ee1a4i6e4e2oo1e2a4e2i1e2o4e2e4a4o1i1e4a4e3e1e2i2e3i4u2oa4a4oo4e2e4e1e1a5e1e3e2a3a3a4i2u1e3u3u1o3e6e2oo3o3a2a4o2o1e1o4e3e2e2a4e2a2e3i3a3a1e2e3O1A2E2A2A1A1E4u3o2e4ea3i1a2oi3e3i3a2e8e2i3o3i1e2o3o4e2a3o3ea2o3i2i4o1e1o3u2e2ea5o2a1a1e3o2u2i2i2o1o1e1o4e2u2oa4a4e2e4a3i
\d
$*
+s`1(.*i)(.)
$2$1

Try it online! Simply encodes the vowels and distances between the vowels, which are used to slowly shuffle the consonants into place.

Bash, 10 bytes + 1151 bytes + 1-char file name = 1162 bytes
bzip2 -d a

Output in a.out
File a is the output of bzip2 alice.txt; mv alice.txt.bz2 a where alice.txt is the required output.

I get 1115 bytes for a zopfli-compressed file. Then this is also a Bubblegum answer as well!

@mypronounismonicareinstate I get 1095 bytes with zopfli.

@ovs I feel like I'm not using zopfli correctly. How many iterations did you use?

@mypronounismonicareinstate I used 10,000 iterations, also tried with 100,000, but there was no improvement (I get 1105 bytes for a single iteration). My call looks like zopfli --deflate -c --i10000 original.txt | xxd, this directly outputs the hexdump for TIO.

Keg, 1391 bytes
`?A2Ȋ1Ɛ2Ȧ3Ɛ1Ȋ2Ȋ4Ǫ2Ɛ3Ɛ4Ȋ1Ɛ2Ǫ3Ȋ2Ȋ7Ɛ3Ȋ2Ɛ2Ǫ4Ɛ2Ȧ4Ȧ3Ǫ3Ȧ1Ȋ4Ǫ2Ȋ4Ǫ2Ǫ2Ǫ2Ɛ1Ǫ4Ȋ1Ɛ3Ɛ2Ȧ3ƐƐ1Ɛ2Ȋ2Ǫ3Ɛ2ǪǪ3Ɛ3Ȋ2Ɛ3Ȧ3ƐȦ1Ȋ5Ȕ2Ȋ3Ȧ3Ǫ2Ȋ2Ȕ1Ɛ2Ǫ3Ǫ2Ɛ2Ȧ1ȊǪ3Ȋ2Ȋ4Ȧ5Ȧ2Ȋ4Ɛ1Ȕ1Ɛ1Ǫ2Ȧ2ǪǪ6ǪȔ4A2Ȋ1Ɛ3Ȋ2ǪȔ3Ȋ2Ȕ1Ɛ2Ǫ3Ǫ2Ɛ2Ȧ1ȊǪ49⑨,?1Ǫ3Ɛ2Ȧ3Ǫ2Ȋ1Ɛ1Ȋ3Ȋ3Ɛ2Ǫ4Ȋ4Ȧ3Ɛ3Ȧ4Ɛ2ǪȔ5Ǫ4Ɛ2Ǫ3Ȧ3Ȧ1Ɛ2Ɛ3ƐƐ3Ɛ5ƐƐ3Ȧ5Ȕ1Ȋ6Ɛ2Ɛ4Ɛ3ƐȦ1Ȕ1Ɛ1Ǫ3Ȧ1Ȋ3Ȧ2ȦȊ6ȦȊ3ǪȔ4Ɛ2Ǫ6Ɛ3ǪȔ2Ɛ1Ǫ3Ɛ2Ȋ3Ȕ2Ȧ4Ȋ2Ȋ5Ɛ2ȦȊ1ȊƐ5Ɛ3Ȕ2Ɛ4Ȧ3Ȋ1Ɛ2Ȧ2Ȋ3Ȋ4Ȋ3Ɛ1Ɛ3Ȧ4Ǫ1Ɛ5Ɛ29⑨,?2Ɛ1Ɛ2Ȧ3Ǫ2Ȋ4Ǫ3Ɛ5Ɛ1Ȧ2Ȧ2Ɛ1Ȋ4Ȧ4Ǫ3Ȋ2A2Ȋ1Ɛ3Ȋ3Ȋ3Ǫ3Ɛ5Ȕ3ǪȔ2Ǫ4Ɛ2Ȧ3Ǫ2ƐȦ4Ɛ2Ȧ2Ȋ3Ȧ3Ǫ1Ȋ2Ɛ5O4ƐȦ3O4ƐȦ3I4Ȧ4Ɛ2Ȧ1Ɛ6Ɛ4Ɛ3ǪȔ4Ȋ2Ǫ1Ɛ2Ȧ2Ɛ2Ȧ5Ȋ2Ǫ2Ȕ2Ɛ3Ǫ2Ɛ4Ȧ4Ɛ1ǪȔ5Ǫ2Ȧ1Ɛ2Ǫ2Ɛ1Ɛ2Ȧ4Ȋ4Ȕ2Ȧ4Ɛ2Ȋ1Ɛ1Ȋ2Ȧ4ƐƐ1Ɛ3ȔȊ1Ɛ2Ȧ1Ȕ1Ȧ5Ȕ4Ɛ4Ɛ2Ȧ2Ȋ2Ȧ2ȔȦ6ǪǪ2Ȧ2Ȧ4ǪȔ2Ǫ2Ȋ4ȦȊ3ǪȦ3Ǫ2Ɛ4Ȧ4ǪǪ1Ɛ2Ȧ2Ȋ3Ȧ5Ɛ3Ȕ2ȊƐ2Ǫ3A2Ȋ1Ɛ3Ȧ2Ɛ3Ǫ2Ɛ3ƐƐ4Ǫ2Ȋ4Ȧ2Ɛ2Ȧ2Ǫ4Ɛ3Ȋ5Ȧ4Ɛ2Ȧ3Ɛ1Ɛ3Ɛ1Ǫ1Ɛ2ƐƐ2Ȧ2Ȧ2Ȋ3Ȋ3ƐȊ2Ɛ2Ȧ2ȦȊ3ǪȦ4Ǫ2Ɛ3Ǫ2Ȧ2Ȧ5Ǫ2Ȧ1Ɛ1ǪȔ2Ǫ2Ȋ3Ȧ4Ȕ2Ȋ4Ȋ4Ȕ1ȊǪ1Ȋ6Ɛ2Ȧ2Ȧ2Ǫ5Ɛ2ȊƐ3Ȧ2Ɛ2Ȋ3Ȧ4Ǫ2Ȕ1Ȧ1Ɛ4Ȧ3Ȕ3Ȋ3Ȋ1Ɛ2Ǫ2ƐƐ1Ȋ3Ǫ3Ǫ3Ȧ2Ȧ2Ɛ2Ȧ2Ȋ3Ǫ1Ɛ1Ȕ2Ɛ4Ɛ2Ɛ2Ɛ19⑨,?I3Ȧ1Ǫ2Ɛ3Ǫ1Ɛ4Ǫ4Ɛ3A2Ȋ1Ɛ1Ȧ2Ɛ2Ȋ4Ɛ1Ɛ2Ǫ2Ɛ2Ǫ2Ȋ1Ɛ1Ȋ4Ǫ2Ȋ4Ɛ2Ǫ6Ɛ2Ȧ3Ǫ2Ɛ2ǪȔ2Ȧ1ȦȊ29⑨,?2Ɛ2Ȧ2Ȋ3Ǫ1Ɛ2Ɛ6ȦȊ4Ǫ3Ȋ1Ɛ1Ȧ2Ȕ2Ɛ3Ǫ3Ǫ1Ɛ2Ȧ3Ȧ5Ɛ3Ȋ2Ɛ3Ȕ2Ɛ5Ǫ5Ǫ2Ȕ2Ɛ6Ȧ2A2Ȋ1Ɛ2Ȧ3Ǫ2Ȧ2Ǫ1Ɛ4Ǫ3Ȋ3Ȧ1ǪȔ4Ǫ2Ȋ4Ɛ2Ɛ4Ɛ1Ǫ1Ɛ3Ɛ2ǪȔ4Ɛ2Ɛ4Ȧ2Ȋ4Ǫ3Ȧ2Ɛ4ƐƐ3Ɛ39⑨,?E1Ȋ2Ɛ4Ɛ2Ɛ4Ȧ3Ɛ4ƐƐ3Ǫ4Ɛ2Ɛ4Ɛ5Ǫ6Ǫ4Ɛ2Ȧ4Ɛ4Ǫ3Ȋ1Ɛ1Ȧ4Ɛ2Ɛ4Ǫ4Ǫ2ǪǪ2Ȧ1ǪȔ3Ɛ2Ȧ4Ǫ2Ǫ2Ɛ4Ȧ3Ȧ3ǪȊ4Ǫ2Ȧ2Ɛ3Ɛ5Ȋ7Ɛ3ȊƐ3Ǫ2ǪǪ3Ǫ3Ȧ4Ȧ1Ɛ1ǪȔ4Ȧ4Ɛ2Ȧ3Ǫ1Ȋ4Ǫ3Ȕ2Ȋ3Ȧ3ǪǪ2Ȧ4Ǫ2ƐƐ1Ȧ4Ȋ6Ɛ4Ɛ2ǪǪ1Ɛ2Ȧ4Ɛ2Ȋ1Ɛ2Ǫ4Ɛ2Ɛ4Ȧ4Ǫ1Ȋ1Ɛ4Ȧ4Ɛ3Ɛ1Ɛ2Ȋ2Ɛ3Ȋ4Ȕ2ǪȦ4Ȧ4ǪǪ4Ɛ2Ɛ4Ɛ1Ɛ1Ȧ5Ɛ1Ɛ3Ɛ2Ȧ3Ȧ3Ȧ4Ȋ2Ȕ1Ɛ3Ȕ3Ȕ1Ǫ3Ɛ6Ɛ2ǪǪ3Ǫ3Ȧ2Ȧ4Ǫ2Ǫ1Ɛ1Ǫ4Ɛ3Ɛ2Ɛ2Ȧ4Ɛ2Ȧ2Ɛ3Ȋ3Ȧ3Ȧ1Ɛ2Ɛ3O2A3E3A3A2A2E5Ȕ3Ǫ2Ɛ4ƐȦ3Ȋ1Ȧ2ǪȊ3Ɛ3Ȋ3Ȧ2Ɛ8Ɛ2Ȋ3Ǫ3Ȋ1Ɛ2Ǫ3Ǫ4Ɛ2Ȧ3Ǫ3ƐȦ2Ǫ3Ȋ2Ȋ4Ǫ1Ɛ1Ǫ3Ȕ2Ɛ2ƐȦ5Ǫ2Ȧ1Ȧ1Ɛ3Ǫ2Ȕ2Ȋ2Ȋ2Ǫ1Ǫ1Ɛ1Ǫ4Ɛ2Ȕ2ǪȦ4Ȧ4Ɛ2Ɛ4Ȧ3Ȋ2`÷⑷:`12345678`-[|ℤ`,`*]⑸⅀ß

Try it online!
Explanation
`...` # The huge to-be evaluated string
      # that says what the program should do in the encoding
÷     # Split the string into individual characters
 ⑷   # Map over the string
:`12345678`-[|ℤ`,`*]⑸
      # If the string is in 1-8, multiply the comma by that integer.

⅀     # Join the whole stack
ß     # Evaluate the generated code

PHP, 2224 1592 bytes
for(;$a=$argv[1][$i];$i++){foreach(["A"=>"UHULUNUO","E"=>"LSUJUP","I"=>"=IG<","O"=>"===CUG","e"=>"1822313:3K4Z7B8?8V99:::H:I:Q;1;2;E;J=P=S?:?>?Z@4AAC@D9DHF1FQG8G:GEGMH1I?IRIYJ>K;MEN4NCOEOHP=QTRDRGRHRLS7S9S=S>SDSET7TNTVTXUBUDV<VDWHWNX<XO","a"=>"2:2D4R7>7A8G:L;F;H<L=2=L=R>C?A?K?U@6@8@K@WALB;BOBSD@DGE>E@EZFOG>HYJ1KEL=O7NOOCPBQ3Q:QMSJSMTGU6UAV7W6WWWXXS","i"=>"191H1N1Z2Z3<3I4T6J7X9H:9:E;V?EE5E6J<LSQSR;RJV6VNWAX8","o"=>"1?242O2Q3>45626F7;:P;=<9<O=5><>J>Q?7?<A?B3B@D7DEE5EWFAFGHSIIIXJMK?KFKJMNNKNPNYO1O=OAOZPPQ7T4UWVWTKTMVZWGWIWUX2X:X;","u"=>"4Y7W8>9B<A>L@7AYDTE4EYF8FZIPRSSZT3WLX4XC","ea"=>"3Q8=<Q=@=FV3W<WP","ou"=>"5;5F6Z8R97<D>6?2A1DIHWL3P>","ai"=>"8I8O9QA9CZHZIE","ie"=>"9RB1EIOW","ui"=>"@3","oi"=>"V9","ua"=>"@M","ei"=>"CT","oa"=>"A<D3RUXE","oo"=>"@SAINMP2Q1QJT?","ee"=>"397G7O?YBECHFCLLM<Q9"]as$c=>$b)for($j=-1;$d=$b[++$j];)if($i==(ord($d)-49)*42+ord($b[++$j])-49)$r.=$c;$r.=$a;}echo preg_replace(["/(\\s)(t|s)h(n)?(?= )/i","/(h(?=r)|g|d)(rs|r\\W|t)/","/wh(?!a)/","/ (w|h|s)(s |d |v)/","/(\\W)nd/","/(th|w(?=t)|m|F)(n|th|r)/","/b(o)?t/","/ (a)?nt/","/([^namlie])d(\\W)/","/(?<= )(t|n)(\\W|s)/","/(d(?!r|n)|c(?!r)|cr|m|h|w(?!n))(w|n|ss|m|r)/","/(\\W)s /","/ (n)?r /","/([^iu])ng/"],["$1$2he$3","$1e$2","whe"," $1a$2","$1and","$1i$2","b$1ut"," $1not","$1ed$2","i$1$2","$1o$2","$1as "," $1or ","$1ing"],str_replace(["lc","bb","dd"," f ","bfr","fr ","vr","nc","bk","ctr","stn","nsd","wll","mk","  ","tht","lf","ftr"," tm","hl","lk"],["Alice","abbi","udde"," of ","before","for ","ver","once","book","icture","sation","nside","well","mak"," a ","that","elf","after"," time","hole","like"],$r));

Try it online!
Haha this is such a longest mess :D well this takes a double approach by replacing some english generic syntaxes, then adding the missing vowels. Actually doing it the other way round so that some generic replacements are avoided because proper vowels were inserted first. Still optimizations to do I guess..
EDIT: saved 632 bytes by encoding the positions with the following:

each position is converted to base 42 (the answer! 41 would have been enough, doesn't change the count anyway)
gives 2 digits. Each digit is represented by the char code of the value + 49 (so it starts with "1" to prevent a falsey value)

You can save a bunch of bytes on this removing all the quoted strings and replacing them with ~barestring (or just removing the quotes for alphanum strings) and you get a 1417 byte count here's a program to build it and a TIO link to confirm it works in the comments.

@DomHastings Thanks! it works in the keys too! I have a lot of other optimizations to do, now that positions are compressed many replace are longer than adding vowels positions. I will integrate your modification with it. More PHP notices!!!

So many notices... it actually slowed the processing down on my machine whilst it was spewing them out! Good luck!

@DomHastings actually bare strings only work with alphanumeric strings, chars such as = breaks it.. If I understand well, your use of ~ is to get UTF-8 chars such as ÎÇÍ and use ~ on it to get original chars? The problem with this method is that those chars take 2 bytes each, so that doesn't really lower the byte count :/ I haven't worked on the improvement yet, maybe today

Ah, they shouldn't be UTF-8 byte strings, just high byte chars (so copy/pasting into TIO won't work - I think anyway). My understanding of ~ is that 01100001 (93 / a) becomes 10011110 (158 / ž in 1252 latin-1) which PHP treats as an undefined constant using the content. So removing the quotes and replacing with ~. It's ugly, but it works :)

05AB1E, 575 574 568 563 bytes
•zʒβßαØä₁«&ƒa*O¶¾8ΓÍ₃Ê1eéÿ¡¸;‹nθ¯õ!šìLx‘Â0·äLègα&íΘ∞ÜΣ<Ã5U≠₄ˆδø¿»·V.A×Ø€ćê”€Qý!¦:üÜ©zт8λóÞš÷—2Ô(9È∍,\&Ćø
æ—₃Ƶ“°R₁ƶмŠ₆wÎl£ΩfεjÍŒÒwœ'².yÅµÓ:jÐδ-‰øεžƒt£„cçQ¨RXJα≠’§krèýF∊¥ï·ǝ('₄“©wGßÙKMв\Ƶ¢j«ŽÞí‹ÂâäÝ–Σ-…ëĀº< \¼·²QS²„;É2тT6%> Po,¶úÒ‰ðC”‡ÖζpH¬tŸÞbΩ`™¦š˜°ƶÔ¾ÉëÑηhÁbg>1©
zµÏ|-Bó
?₂Äo›]Iþd]dlÈ₄Ćθ)MιζŠ3_)U¾ǝ£ÜŽ8”ÏвƵ^Î₆»Θª∊eÞJ8JèO¶₁û∊Kƒ–q×L÷=£AγõиisoÃeþ¶åβв"\¨"ι>т&«ǝôŠe°Í.%+cÿ“ZS÷&(ι+›1ßΘF>é4”×§oìÂ₄jœ´â¿¦Ÿ~ë^†¡ÎVÎÝα7eæ‚°?ôΛ¼èp
dŒΛ¡ˆĀ∞€—À¢<·»+¹ʒ”qmý∞âMZîPéƵáÃ¸Ô”₄ðwÆ¼axæ₄UU≠³ý¡ÅΩ66yΘE±ðcƶceåι.üWv₁¤Ãi«Š41×β4ëαÐWΔaŠRùmàÝå=åÔ≠%Úм“Z½ŽæYÏα´ŒiÝ²Ú∞Iª\ã¡.&тèã×ùÜ•74вvy9‰`žÀè?Fć?

-6 bytes thanks to @Neil.
Try it online.
Explanation:
•zʒβ...×ùÜ•       # Compressed integer 224641896896148016938368561552335098644440638806788380400165012285773501511250520005365941174208862664146279830408159028683082511746603646891689033010607628801437815480712915937924652809275189770660278010281318902097091708373828682312372672780477399419735631443886176059155071050262476552107016396780364226771683546971818103868361088000198778349003798076521493395410165779115606867484976791281038122102473781863665290228860335504663518108519671908117249856499506351874454875954494300437192218659256356139029651017435075963148812076901839173173452741192124604287091826161488097642846505252520037487674529824294243076129434563729383043104197923479360824310056655097918512677989534664676292688146822517512437302732254580913876380548881065041539680195011501730965834481558588377458598325965058885027168108789089635332449928831687357681298337708316403895593386671522073867265788780974012285668758807646711339460091042314668721692971679186845632617647310449657373332887652449016140311441573605606672295627533091777550161610779991335347646888360976210146797195084763186022703803722123461953373745423277449265741179310520405868463753966730206640071346865760122413333839703653337550179608290258257704143816340134609444894565369164030543611560755320287705090985654855136258294063356183305469030387994762970933038946455313934
 74в              # Converted to base-74 as list: [14,11,19,27,10,20,38,21,28,37,11,19,30,20,65,28,20,19,39,19,36,27,30,9,38,21,38,21,21,21,10,39,11,28,19,27,1,10,19,20,30,19,3,30,28,20,28,27,1,9,47,22,29,27,21,20,13,19,30,21,19,9,2,30,20,38,45,18,38,10,13,10,21,18,3,57,3,40,14,11,28,20,3,31,20,13,19,30,21,19,9,2,57,30,19,27,21,11,10,29,29,19,39,38,27,28,36,19,3,49,39,19,30,27,9,19,28,1,28,46,1,28,45,13,56,19,37,28,1,9,13,10,30,9,29,18,0,56,0,29,3,40,19,57,28,3,22,10,30,19,29,22,36,20,47,19,0,11,2,46,28,22,37,27,11,19,18,29,38,29,10,28,36,12,46,46,10,19,27,21,38,30,46,10,18,18,10,38,36,30,20,14,11,28,29,29,30,46,31,3,22,39,19,27,21,1,36,19,18,29,27,12,20,46,35,1,27,35,1,27,34,36,19,9,55,37,28,3,40,20,12,19,18,19,45,20,21,22,28,21,37,36,10,3,49,21,9,19,21,10,19,36,38,22,36,19,11,10,20,36,1,10,28,4,11,19,9,13,45,40,37,19,18,20,18,4,54,3,21,18,36,3,22,21,38,0,29,3,27,21,37,36,3,12,19,18,29,45,28,22,2,19,30,14,11,28,18,28,21,28,1,37,21,38,18,19,18,39,28,47,36,19,27,10,28,10,12,19,1,19,18,18,29,29,1,20,19,18,0,29,3,36,21,28,21,18,45,21,9,10,3,22,21,29,36,22,38,38,13,2,12,56,19,18,18,48,19,2,28,18,19,29,36,21,13,9,37,27,31,29,11,19,21,1,10,29,30,30,18,18,19,18,29,12,10,22,37,19,19,19,25,9,21,28,12,37,39,28,14,11,10,18,19,38,10,19,21,19,21,11,10,38,21,38,19,57,19,27,21,19,3,22,9,0,47,19,18,29,12,19,55,0,38,30,11,10,18,22,28,30,12,19,27,45,28,20,28,22,46,48,21,22,55,18,14,11,19,27,21,18,12,37,30,29,9,3,40,21,38,19,37,10,12,28,19,3,40,19,37,18,38,30,18,37,1,28,37,6,20,37,19,37,27,37,1,28,39,19,37,46,57,39,19,36,37,30,11,10,36,19,37,39,21,3,21,9,3,31,19,36,21,21,37,27,27,3,38,21,18,28,46,65,28,2,28,21,3,30,30,36,9,10,3,40,36,19,27,12,38,30,22,29,27,3,21,36,21,1,10,36,56,37,19,3,12,19,36,19,11,19,39,19,37,36,12,11,37,36,28,10,19,20,28,38,22,3,36,36,3,39,19,37,10,10,45,10,28,19,27,27,36,20,13,28,31,13,30,55,19,3,30,30,18,36,21,12,10,39,28,19,19,36,19,18,28,29,27,9,19,28,17,23,24,23,14,14,42,31,21,37,1,27,11,18,3,29,28,29,18,73,19,29,30,11,19,30,39,19,27,30,1,18,30,20,38,12,10,30,22,19,1,45,21,9,9,28,21,22,20,20,12,12,10,39,19,22,3,36,36,19,37,27,20]
    v             # Loop over each integer `y` in this list:
     y9‰          #  Take the divmod-9 of the current integer
        `         #  Pop and push both y//9 and y%9 separated to the stack
         žÀ       #  Push builtin string "aeiouAEIOU"
           è      #  And (0-based) index y%9 into this string
            ?     #  Pop and print this character (without trailing newline)
             F    #  Then loop y//9 amount of times:
              ć?  #   And extract, pop, and print the first character of the string
                  #   (which will use the implicit input-string in the very first iteration)

See this 05AB1E tip of mine (sections How to compress large integers? and How to compress integer lists?) to understand why •zʒβ...×ùÜ• is 224...934 and •zʒβ...×ùÜ•74в is [14,11,19,...,37,27,20].

On the other hand, divmod-10 would allow you to use vyDžÀè?T÷Fć? as your loop. Oh well. Why do you manually add 5 to y//9 instead of adjusting the list values by 45 (mod 81)? That would at least allow you to use vy9‰`sžÀè?Fć? as your loop...

@Neil The +5 was initially 5._ to change the string "aeiouAEIO" to "AEIOaeiou". As for your first suggestion with divmod-10 and vžÀyè?yT÷Fć?, it ends up at 576 bytes. As for the (...+45)%81 with vy9‰`sžÀè?Fć?, that indeed saves 6 bytes, so thanks. :)

I'm glad one of my suggestions was helpful at least :-)

Ooh, you swapped the higher and lower base 9 digits anyway, a bit like my suggestion for divmod-10 did!

@Neil Yeah, I noticed the swap in your suggestion with divmod-9, and tried it without that swap to see if the compressed list would be shorter, which was indeed the case. :)

Deadfish~, 18625 bytes
{{i}dddd}iiiiic{{i}dddddd}iiicdddcddddddciic{{d}iii}ic{{i}d}dddc{d}{d}ddc{i}{i}ddc{{d}ii}dddc{{i}dddd}iiiiiiciiiciiciiciiiiiccdddddciiiiic{d}iiic{{d}iii}dc{{i}dd}iiiicdddddc{{d}ii}ic{{i}ddd}icddc{i}iiiiic{{d}ii}ddddc{{i}dd}iiiiiic{d}{d}iiic{i}iiic{i}dddc{{d}i}ic{{i}dd}iiiic{d}dc{i}dc{d}dddcdc{{d}iii}iic{{i}dd}dc{d}ic{{d}iii}c{{i}dd}iiic{d}c{i}icc{d}dciiiiic{d}iiic{{d}iii}dc{{i}dddd}iiiiiic{i}{i}iiic{{d}i}ic{{i}ddd}iicdddc{i}iiic{{d}ii}ddc{{i}dd}iiic{d}c{i}cic{d}dddddc{i}iiic{{d}ii}ddc{{i}dd}dcdc{{d}ii}iic{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}dddd}iiiiiicdc{i}iiicdddc{{d}iiii}dddc{d}ddc{{i}dddd}iiiiic{i}iiic{d}c{{d}iii}iic{{i}dd}dc{d}ic{{d}iii}c{{i}ddd}iic{d}iiic{i}{i}ic{d}dddciiiiic{d}iiic{{d}iii}dc{{i}dd}ddciciiiiic{d}ddciciiiiic{d}iiic{{d}iii}dc{{i}dd}iiiicdddddc{{d}ii}ic{{i}ddd}ddc{i}ic{{d}iiiii}dddc{d}{d}ddddddc{{i}dd}dcdc{d}dciic{{d}iii}ic{{i}dd}dciiic{{d}ii}ddc{{i}dd}iiiiciiic{d}ddddcddddddciic{{d}iii}ic{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}ddd}iic{d}iiiciiic{{d}iii}iic{{i}dd}c{d}dcc{i}ic{d}dcdc{{d}iii}iic{{i}ddd}iiiciiiiiciiiiiicdddddc{{d}ii}ic{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}dddd}iiiiiic{i}iiiccddddc{{d}iii}dddddc{{i}ddd}iicdddc{i}iiic{{d}ii}ddc{{i}dd}iiic{d}c{i}cic{d}dddddc{i}iiic{{d}ii}ddc{{i}d}dddc{d}{d}ddc{i}{i}ddc{{d}ii}dddc{{i}dd}iic{d}dddcddddciiiciiiiiciiiiic{d}iiic{{d}iiii}ic{d}ddc{{i}dddd}iiiiiic{i}{i}dcdc{{d}ii}ddddc{{i}ddd}iiic{i}ic{{d}ii}ddddc{{i}ddd}iic{d}iiiciiic{{d}iii}iic{{i}dd}ddcic{{d}ii}ic{{i}dd}c{d}iiicddddddc{i}{i}dddcicdddc{d}dddc{i}iiiic{{d}ii}dddc{{i}dd}dciiic{{d}ii}ddc{{i}ddd}dddc{i}iicdc{i}ddc{d}{d}iiic{i}iiicic{d}{d}iic{i}{i}dc{d}dciiiiiicdciiiiic{{d}ii}dddc{{i}ddd}iiiciiiiic{{d}ii}iic{{i}ddd}iiic{i}ic{{d}iii}ddc{d}ddciic{{i}dddd}iiic{i}iiic{d}c{{d}iii}iic{{i}d}dddc{d}dddddc{d}iiic{i}{i}dc{{d}ii}ddddc{{i}ddd}iiic{i}c{{d}ii}dddc{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}dd}iiiiicddc{d}ddddc{{d}iii}ic{{i}dd}dc{d}ic{{d}iii}c{{i}dddd}iiiiic{{d}iiii}dddddc{{i}dddd}iiiiiic{i}iiiccddddc{{d}iiii}dddc{d}cddc{{i}dd}iiiic{d}ddc{i}dddciiiiiic{d}ddddcic{i}iic{{d}ii}ddddc{i}{i}{i}iiic{{i}dddddd}iiicdddcddddddciic{{d}iii}iciic{{i}dd}iiiiic{d}ddddc{i}ic{d}ddc{i}dddciiiiiicdc{{d}ii}ddddc{{i}dd}c{d}iiicddddddc{i}{i}dddcicdddc{d}dddc{i}iiiic{{d}ii}dddc{{i}dd}dciiic{{d}ii}ddc{{i}ddd}dddc{i}iicdc{i}ddc{d}{d}iiic{i}iiicic{d}{d}iic{i}{i}dc{d}dciiiiiicdciiiiic{{d}iiiii}ddc{d}{d}{d}ic{d}{d}ddddc{{i}ddd}iiic{i}{i}{i}ddc{{d}ii}ic{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}d}dddc{d}{d}ddc{i}{i}ddc{{d}ii}dddc{{i}ddd}dddc{i}iicdciiiiic{d}cdddddcic{i}iiic{d}iciiiiic{d}iiic{{d}iii}dc{{i}ddd}iiiciiiiic{{d}ii}iic{{i}ddd}iicdddc{i}iiic{{d}ii}ddc{{i}dd}dc{i}ddc{d}ic{{d}ii}iic{{i}dd}dddcddddciiiiic{d}c{{d}iii}iic{i}ddc{{i}dddd}dddc{i}{i}ddc{{d}ii}dddc{{i}d}dddc{d}{d}iic{i}dddcc{{d}iii}ddddddc{{i}dddd}iiiiic{i}{i}ddc{{d}ii}dddc{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}ddd}dddc{i}iiciiiiiic{d}ic{d}iic{{d}iiiii}ddddddc{d}ddc{{i}ddd}c{i}dciiic{{d}ii}ddc{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}ddd}iic{i}dddciiiiic{{d}ii}ddddc{{i}ddd}ddcdddc{i}{i}iiiic{{d}i}ic{{i}dd}dddc{d}ddciiicic{{d}iii}ic{{i}ddd}iicdddc{i}iiic{{d}ii}ddc{{i}ddd}cdcc{i}dddc{{d}iii}ddddddc{{i}dd}iiiiiic{d}{d}iiic{i}iiic{i}dddc{{d}i}ic{{i}dd}iiic{d}iiic{d}iiicc{i}ic{i}dc{{d}i}ic{{i}dddd}iiiiic{i}iiic{d}c{{d}iii}iic{{i}dd}iiicicicdddddc{d}iiicdddddc{{d}iiii}iciiic{d}ddc{{i}d}dddc{d}dddddcdddc{i}iiiiic{d}ddcdddc{i}iiic{{d}ii}ddc{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}dd}cddddc{d}iiicddddc{i}{i}ddciicdddc{d}dddc{{d}iii}ic{{i}dd}dc{d}ic{{d}iii}c{{i}dd}dddc{d}ddc{i}cddciiiiic{d}iiic{{d}iii}dc{{i}dddd}iiiiic{{d}iiii}dddddc{{i}ddd}ddcdddc{i}ddc{i}ciiiiiic{{d}iii}ddddddc{d}dddc{{i}ddd}dddciiiiic{d}iiic{i}ddciiiiic{{d}ii}iic{{i}d}dddc{d}iiciiiiiic{d}ic{d}iic{{d}iii}iic{{i}dddd}iiiiiiciiic{{d}iii}ic{{i}d}dddc{d}iiciiiciic{d}ddc{{d}iii}ddc{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}dd}iiiicddcdddciiiiiic{d}{d}ic{i}c{d}iiic{{d}iii}ic{{i}dd}dc{d}ic{{d}iii}c{{i}ddd}icddc{i}iiiiicc{d}dciiiiic{d}iiic{{d}iii}dc{{i}dd}iiiiicdddddc{{d}ii}c{{i}dddd}iiiiic{i}iiic{d}c{{d}iii}iic{{i}dd}c{d}iiicddddddc{i}ddcddciiiiic{d}iiic{{d}iii}dc{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}ddd}ddcdddc{i}ddc{i}c{d}cddddc{i}iiiic{{d}iii}dc{d}ddc{{i}d}dddc{d}dddddcdddc{i}dc{{d}ii}iic{{i}dd}iiiciic{d}{d}iiiccic{i}dcddc{i}iiic{{d}i}ic{{i}dddd}iiiiic{{d}iiii}dddddc{{i}ddddd}iiiiic{i}{i}dddcic{i}ic{d}dddddc{{d}iii}ic{{i}ddddd}c{i}iiiiicicc{i}dddc{i}ic{{d}ii}ddddc{{i}d}dddc{d}ddddc{i}ic{d}ddc{{d}iii}ddc{{i}dd}c{d}iiiciiiiicdddc{{d}iii}dddddc{{i}ddd}dc{i}{i}c{d}{d}c{i}iiiic{{d}ii}dddc{{i}dd}iic{d}{d}iiic{i}iiic{{d}ii}iic{{i}ddd}dddc{i}dciiiciiiic{d}ddddc{{d}iii}ic{{i}dddd}iiiiiic{i}{i}iiic{{d}i}ic{{i}ddd}iicdddc{i}iiic{{d}iii}iic{d}{d}{d}ddddddc{{i}ddd}iiiic{i}{i}cdddc{i}iiic{d}dddc{{d}iii}ic{{i}d}dddc{d}{d}ddc{i}{i}ddc{{d}ii}dddc{{i}dd}ddciciiiiic{d}ddciciiiiic{d}iiic{{d}iii}dc{{i}dd}iiicddddc{{d}ii}ic{{i}dddd}iiic{i}{i}iiic{d}{d}iiic{i}iiic{i}dddc{d}{d}ddddddc{{d}iiii}dddc{{i}dd}iic{d}dddc{i}ddc{d}ddc{i}{i}dddc{d}iiic{d}cic{i}c{d}iiic{{d}iii}ic{{i}ddd}iiiciiiiic{{d}ii}iic{{i}dd}iiiic{d}ddc{d}iiic{i}{i}dc{{d}iiii}iiic{d}{d}{d}iiic{{i}dd}ddciciiic{{d}ii}ddc{{i}ddd}ddciiiiicdddddc{{d}iii}iic{i}{i}{i}iiic{{i}dddddd}iiicdddcddddddciic{{d}iii}ic{{i}dd}iiiic{d}ddciciiiiicdddc{{d}iii}dddddc{{i}ddd}iiic{i}ic{{d}ii}ddddc{{i}dd}iiicddddc{{d}ii}ic{{i}dddd}iiic{i}{i}iiic{d}{d}iiic{i}iiic{i}dddc{d}{d}ddddddc{{d}iiii}dddc{{i}dd}dddc{i}ddc{d}{d}iiciiiiic{{d}iii}ddc{{i}dd}dciiiiiicdc{{d}ii}ddddc{{i}dd}dc{d}ic{{d}iii}c{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}d}dddc{d}{d}ddc{i}{i}iiiic{{d}i}ic{{i}dd}iiiicdddddc{{d}ii}ic{{i}ddd}iicdddcddddc{i}{i}dddc{{d}ii}ddc{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}ddddd}c{i}iiiiicicc{i}dddc{i}ic{{d}ii}ddddc{{i}dd}iiic{d}{d}iic{i}{i}iiiic{{d}i}ic{{i}dd}iiiicdddddc{{d}ii}ic{{i}ddd}iiic{i}icdc{d}ddddc{i}dddcddddddc{{d}iiii}iic{d}ddciic{{i}dddddd}iiiiic{i}{i}iiiiic{{d}iii}ddc{{i}ddd}ddcicddddc{i}{i}dddc{{d}ii}dcdc{{i}ddddd}dddc{i}{i}iiiiic{{d}iii}ddc{{i}ddd}ddcicddddc{i}{i}dddc{{d}ii}dcdc{{i}dddddd}ic{{d}iiiiii}dc{{i}dd}iiic{d}dc{d}iiic{i}icc{{d}iii}ddddddc{{i}dddd}iiiiiiciiic{{d}iii}ic{{i}ddd}iiiiiic{d}dc{i}{i}dc{d}dddddc{{d}iii}iicicddc{i}ddc{{i}dd}dc{d}dddddcdddc{i}dc{{d}ii}iic{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}dd}iiiic{d}ddc{i}dddciiiiiic{d}ddddcic{i}iic{{d}ii}ddddc{{i}ddd}iiic{i}ic{{d}ii}ddddc{{i}dd}dc{i}dddc{d}{d}iiic{i}iiic{{d}ii}ddc{{i}dddd}iiiiiciiiiic{i}iiiic{d}dddddc{i}iiiciiiiic{d}{d}ddc{i}{i}dddc{d}ddddc{i}iiiiic{{d}iii}dc{d}ddc{{i}ddd}iiic{i}ic{{d}ii}ddddc{{i}dd}dc{d}ddcc{i}{i}ddcdddcc{d}dddcdc{{d}iii}iic{{i}dd}iiiicdddddc{{d}ii}ic{{i}ddd}iicdddc{i}iiic{{d}ii}ddc{{i}dd}iiiic{d}ddc{d}iiic{i}{i}dc{{d}ii}ddddc{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}dd}dciiiiiic{d}ddddcic{i}iic{{d}ii}ddddc{{i}dd}iiiicdddddc{{d}ii}ic{{i}ddd}iic{d}iiic{i}{i}ic{d}{d}iiic{{d}iii}ic{{i}d}dddc{d}iicdc{d}cic{i}iiic{d}dddcdc{{d}iii}iic{{i}dddd}iiiiic{i}{i}dc{{d}ii}ddddc{{i}dd}iiiic{d}ddcic{i}c{{d}iii}dc{d}ddc{{i}dddd}iiiiiic{i}{i}dcdc{{d}ii}ddddc{{i}dddd}iiiiic{i}{i}dc{{d}ii}ddddc{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}dd}iiiic{d}dciiiic{d}iic{{d}iii}ic{{i}ddd}iiic{i}ic{{d}ii}ddddc{{i}dddd}iiiiic{i}icc{{d}iii}ddddddc{{i}dd}iiic{d}ddddcc{i}ddc{d}iicdc{{d}iii}iic{{i}dd}iciiiic{d}ddc{i}ic{d}dddddc{{d}iii}ic{{i}dd}ddc{d}dddc{i}{i}dcicdddc{d}{d}iiic{i}ic{{d}iii}iiic{i}{i}ddc{d}{d}{d}iiic{{i}dddd}iiiiiic{i}{i}dcdc{{d}ii}ddddc{{i}d}dddc{d}dddddcdddc{i}dc{{d}ii}iic{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}ddddd}c{i}iiiiicicc{i}dddc{i}ic{{d}ii}ddddc{{i}dddd}iiiiiciic{i}{i}dddcic{d}{d}c{i}icc{i}iiic{{d}i}ic{{i}dddd}iiic{i}{i}icdddddccddddc{{d}iii}dddddc{{i}dddd}iiiiic{{d}iiii}dddddc{{i}d}dddc{d}{d}ddc{i}{i}dc{d}{d}iiiciiiiic{{d}iii}ddc{{i}dd}dciiiiiicdc{{d}ii}ddddc{{i}dd}dc{d}ic{{d}iii}c{{i}ddd}iiic{i}icdc{{d}ii}dddc{{i}d}dddc{d}{d}ddc{i}ddc{i}cic{d}{d}iiic{i}iic{d}ddddc{i}{i}dc{{d}iii}dc{{i}ddd}dddcdc{d}ddc{i}ddcddddddc{i}iiiiic{d}{d}dc{{d}iiiii}dc{d}ddc{{i}dddd}iiiiic{i}iiic{d}c{{d}iii}iic{{i}ddd}iiiiiiciiiccddddcddddddcdc{{d}iii}iic{{i}dddd}iiiiic{i}{i}dc{{d}ii}ddddc{{i}ddd}iiic{i}ic{{d}iii}ddc{d}ddc{{i}dddd}iiiiic{i}iiic{d}c{{d}iii}iic{{i}dd}iiiic{d}ddcdddc{i}dc{{d}ii}iic{{i}ddd}iic{i}iiicdddcc{d}icddddcdc{{d}iii}iic{{i}dd}dcdc{{d}iiii}ddddddc{d}ddc{i}{i}{i}iiic{{i}dddddd}iiicdddcddddddciic{{d}iii}ic{{i}dd}iiicic{d}{d}ic{i}{i}dddciic{d}dddddcdc{{d}iii}iic{{i}dd}iiiicdddddc{{d}ii}ic{{i}ddd}iicdddc{i}iiic{{d}ii}ddc{{i}ddd}cdcc{i}iiiiic{{d}iii}ddc{d}ddc{{i}ddd}c{i}dciiic{{d}ii}ddc{{i}ddd}iiic{i}ic{{d}ii}ddddc{{i}ddd}ciiiiiic{d}dc{i}{i}ddc{d}dcdddcdc{{d}iii}iic{{i}dddd}iiiiiciic{i}iiiiicdddciiiicc{{d}ii}dddc{{i}ddd}iicdddc{i}iiic{{d}ii}ddc{{i}dd}dddcddddciiiiic{d}c{{d}iii}iic{{i}dd}iiiic{d}ddc{d}iiic{i}{i}dc{{d}ii}ddddc{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}ddd}iic{d}iiiciiic{{d}iii}iic{{i}dd}ddc{d}ic{i}{i}dddc{d}{d}iiic{i}iiic{{d}ii}ddc{{i}dddd}iiiiiiciiicic{i}dciiic{d}dddc{{d}iii}ic{{i}dd}iiic{d}ddddcc{i}dc{{d}ii}iic{{i}dddd}iiiiic{{d}iiii}dddddc{{i}dd}iic{d}{d}iiicicc{i}dddc{i}ic{{d}ii}ddddc{{i}d}dddc{d}ddddc{i}ic{d}ddc{{d}iii}ddc{{i}ddd}dciiiic{i}ic{d}ddcdddc{i}iiic{{d}ii}ddc{{i}dddd}iiiiic{{d}iiii}dddddc{{i}d}dddc{d}{d}ddc{i}ddc{i}cic{d}{d}iiic{i}iic{d}ddddc{i}{i}dc{{d}iii}dc{d}dddc{{i}dd}cdc{d}ddc{i}ddcddddddc{i}iiiiic{{d}iii}ddc{d}ddc{{i}dd}dciiic{{d}ii}ddc{{i}dddd}iiiiic{{d}iiii}dddddc{{i}d}dddc{d}{d}ddc{i}{i}dc{d}{d}iiiciiiiic{{d}iii}ddc{{i}dd}iiiicdddddc{{d}ii}ic{{i}dd}iiiic{d}{d}ic{i}cddddddc{{d}iii}ic{{i}dd}dciiiiiicdc{{d}ii}ddddc{{i}dd}dc{d}ic{{d}iii}c{{i}ddd}iiic{i}ic{{d}iii}ddc{d}ddc{{i}dddd}iiiiic{i}iiic{d}c{{d}iii}iic{{i}dddd}iiiiiic{i}{i}dcdddcddddcdddddciiiiic{d}iiic{{d}iii}dc{{i}d}dddc{d}ddddc{i}ic{d}ddc{{d}iii}ddc{{i}ddd}dddc{i}{i}ddcdddc{d}iciiiiiiciiiic{d}c{i}iciiiiic{{d}ii}iiic{d}ddc{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}dd}iic{d}{d}iiic{i}iiic{{d}ii}iic{{i}dddd}iiiiiciic{i}iiiiicdddciiiicc{{d}ii}dddc{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}ddd}ciiicddddc{i}dddc{d}iic{{d}iii}iic{{i}dddd}iiiiiciiiiic{i}iiiic{d}dddddc{i}iiic{{d}ii}ddc{{i}ddd}iiic{i}ic{{d}iii}ddc{d}ddc{{i}dddd}iiiiic{i}iiic{d}c{{d}iii}iic{{i}ddd}c{i}dciiiciicic{d}iiic{d}dddc{i}{i}dc{d}dddddc{i}dddc{i}iiic{{d}i}ic{{i}d}dddc{d}{d}ddc{i}{i}ddc{{d}ii}dddc{{i}ddd}iiiic{i}icddcic{{d}ii}ddddc{{i}ddd}iiiciiiiic{{d}ii}iic{{i}dd}iiiic{d}dciiiic{d}iic{{d}iii}ic{{i}dd}iiiicdddddc{{d}ii}ic{{i}dd}iiic{d}ddddcc{{d}iii}ic{{i}ddd}iiic{i}ic{{d}ii}ddddc{{i}dd}cdcic{{d}ii}c{{i}ddd}ddc{i}ic{i}ddc{d}ic{{d}ii}iic{{i}dddd}iiiiic{{d}iiii}dddddc{{i}ddd}iiiiiic{d}dc{i}{i}dddc{d}dcddc{{d}iii}ic{{i}dd}iic{d}{d}iiicicc{i}dddc{i}ic{{d}iii}dc{{i}dddd}dc{i}dddcdddc{d}iiic{{d}iii}ic{{i}dd}iiiiic{d}iiic{d}cic{i}iiic{{d}ii}ddc{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}ddd}iicdddcdciiicddc{{d}iiiii}dddddc{d}{d}{d}ddddddc{{i}dddd}iiic{{i}dddddd}dddc{{d}ii}iic{{i}dddd}iiiiic{i}iiiciciiiiic{d}ddcdddc{i}iiic{{d}ii}ddc{{i}dd}dddciicddc{d}iic{i}dciiiiiic{{d}ii}ddddc{{i}ddd}ddc{i}ic{i}ddc{d}ic{{d}ii}iic{{i}d}dddc{d}{d}iic{i}dciiiiiic{{d}ii}ddddc{i}{i}{i}iiic{{i}dddddd}iiicdddcddddddciic{{d}iii}ic{{i}dddd}iiiiiciiiiic{i}iiiic{d}dddddc{i}iiic{{d}ii}ddc{{i}ddd}iiic{i}ic{{d}iii}ddc{d}ddc{{i}dd}ddc{d}ic{i}{i}dddc{d}{d}iiic{i}iiic{{d}ii}ddc{{i}dd}dcdc{d}dciic{{d}iii}ic{{i}ddd}dddc{i}iicdciiiiic{d}cdddddcic{i}iiic{d}iciiiiic{d}iiic{{d}iii}dc{{i}ddd}iic{i}dddc{i}ddc{{d}i}iiic{{i}ddd}iiiciiiiic{{d}ii}iic{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}d}dddc{d}iiciiicddddddc{d}iic{{d}iii}iic{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}d}dddc{d}{d}ddc{i}{i}ddc{{d}ii}dddc{{i}dd}iiiicdddddc{{d}ii}ic{{i}ddd}icddc{i}iiiiic{{d}ii}ddddc{{i}dd}dciiiiiicdc{{d}ii}ddddc{{i}dddd}iiiiiciiiiiicddddddc{i}ddciiiiic{{d}iiii}ddddc{d}{d}{d}ddddddc{{i}ddd}iiiic{i}{i}cdddc{{d}iii}ic{{i}dd}iic{d}{d}iiicicc{i}dddc{i}ic{{d}iii}dc{{i}dddd}dc{i}dddcdddc{d}iiic{{d}iii}ic{{i}d}dddc{d}{d}iic{i}dciiiiiic{{d}ii}ddddc{{i}dd}iiicicddc{d}{d}iiic{i}ddcddcic{i}iic{{d}ii}ddddc{{i}dd}dcdc{{d}ii}iic{{i}ddd}iiiiiicdddciicddddddc{{d}iii}ic{{i}dddd}iiiiic{{d}iiii}dddddc{{i}dd}iiiicic{d}iiicc{d}ic{i}dddc{{d}iii}ddddddc{{i}ddd}c{i}dciiic{{d}ii}ddc{{i}dd}iiicddddcddc{d}iic{{d}iii}ic{{i}d}dddc{d}{d}ddc{i}{i}iiiic{{d}ii}iiic{d}ddc{{i}dddd}iiiiic{i}iiic{d}c{{d}iii}iic{{i}dd}iiiic{d}ddcdddc{i}dc{{d}ii}iic{{i}ddd}ddciiiiic{i}dddcc{d}dcdc{{d}iii}iic{{i}dd}iiiciic{d}{d}iiiccic{i}dcddc{i}iiic{{d}i}ic{{i}ddd}ddc{i}ic{i}ddc{d}ic{{d}iiii}ddddddc{d}ddc{{i}dd}iiicddddc{{d}ii}ic{{i}dd}iiiciic{d}{d}iiiccic{i}dcddc{i}iiic{{d}i}ic{{i}dd}iiiic{d}ddc{d}iiic{i}{i}dc{{d}ii}ddddc{i}{i}{i}iiic{{i}dddddd}iiicdddcddddddciic{{d}iii}ic{{i}ddd}iic{d}iiiciiic{{d}iii}iic{{i}dd}ddciciiiiic{{d}ii}ddddc{{i}dddd}iiiiic{{d}iiii}dddddc{{i}dd}dddciicddc{d}iic{i}dciiiiiic{{d}ii}ddddc{{i}dd}iiiicdddddc{{d}ii}ic{{i}dd}iiiic{d}ddciciiiiicdddc{{d}iii}dddddc{{i}dddd}iiiiicic{i}iiiciiiiiicdc{{d}ii}ddddc{{i}dd}iiicicdddddcicc{d}iiiciiiiic{d}iiic{{d}iii}dc{{i}ddd}iicdddc{i}iiicic{d}ddddc{i}dddcddddddc{{d}iii}c{{i}dddd}iiiiiiciiicic{i}dciiic{d}dddc{{d}iii}ic{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}ddd}c{i}dciiiiiic{d}iiic{d}c{{d}iii}iic{{i}ddd}iicdddc{i}iiicic{d}ddddc{i}dddcddddddc{{d}iii}c{{i}ddd}cdddddc{i}iccdddciiiiic{d}iiic{{d}iii}dc{{i}ddd}ddc{i}ic{i}ddc{d}ic{{d}ii}iic{{i}dddd}iiiiic{{d}iiii}dddddc{{i}dd}iiiiiic{d}{d}iiic{i}iiic{i}dddc{{d}i}ic{{i}ddd}ddcicc{i}ic{{d}ii}c{{i}d}dddc{d}{d}iic{i}dddcc{{d}iiii}ddc{d}{d}{d}ddddddc{{i}dddd}dc{i}{i}{i}iiiiiic{i}ic{d}ddcdddc{i}iiic{{d}ii}ddc{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}d}dddc{d}{d}iic{i}dddcc{{d}iii}ddddddc{{i}d}dddc{d}{d}ddc{i}{i}ddc{{d}ii}dddc{{i}dd}iiiiiic{d}{d}iiic{i}iiic{i}dddc{{d}i}ic{{i}ddd}ddcicc{i}ic{{d}iii}iic{d}ddc{{i}dd}dciiic{{d}ii}ddc{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}ddd}cdc{i}dddcc{{d}iii}ddddddc{{i}dd}iiiiiic{d}{d}iiic{i}iiic{i}dddc{{d}i}ic{{i}dd}iiic{d}iiiciiic{i}ddc{d}dc{i}iiic{{d}ii}iiic{d}ddc{{i}ddd}c{i}dciiic{{d}ii}ddc{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}ddd}iic{d}iiiciiic{{d}iii}iic{{i}dd}cddddc{d}iiic{i}dciiiiiiciiiiic{{d}i}ic{{i}dd}dc{d}ic{{d}iii}c{{i}dd}iiiic{d}dciiiic{d}iic{{d}iii}ic{{i}dddd}iiiiic{i}{i}ddc{{d}ii}dddc{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}d}dddc{d}{d}iic{i}dciiiiiic{{d}ii}ddddc{{i}ddd}ddc{i}ic{i}ddc{d}ic{{d}ii}iic{{i}dd}iiiicdddddc{{d}ii}ic{{i}ddd}iiiiiiciiiccddddc{{d}iii}dddddc{{i}dddd}iiiiicic{i}iiiciiiiiicdc{{d}ii}ddddc{{i}ddd}iicdddc{i}iiic{{d}ii}ddc{{i}dddd}iiiiic{i}iiic{d}c{{d}iii}iic{{i}dd}iiiicdddddc{{d}ii}ic{{i}d}dddc{d}iicdc{d}cic{i}iiic{{d}ii}ddc{{i}d}dddc{d}dddddc{d}iiic{i}{i}dc{{d}ii}ddddc{{i}d}dddc{d}{d}ddc{i}{i}ddc{{d}ii}dddc{{i}ddd}ic{i}ddcddddddciiiiic{d}iiic{{d}iii}dc{{i}dd}iiiicdddddc{{d}ii}ic{{i}ddd}iic{d}iiic{i}iiiiicc{d}dc{i}dc{{d}ii}iic{{i}dd}ddc{d}ic{i}{i}dcddddc{{d}iii}c{d}ddddc{{i}dddddd}ddc{i}{i}{i}iiiiic{i}dcicic{{d}iii}ddc{d}ddc{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}dd}iiiicddc{d}icddddcdc{{d}iii}iic{{i}dd}iiiicdddddc{{d}ii}ic{{i}ddd}iiiiiiciiiccddddc{{d}iii}dddddc{{i}ddd}ddc{i}ic{i}ddc{d}ic{{d}ii}iic{{i}dddd}iiiiic{i}iiic{d}c{{d}iii}iic{{i}dd}dddc{d}ddc{i}cddddddc{{d}iii}ic{{i}dd}dciiiiiicdc{{d}ii}ddddc{{i}d}dddc{d}dddddc{d}iiic{i}{i}dc{{d}ii}ddddc{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}d}dddc{d}{d}ddc{i}{i}ddc{{d}ii}dddc{{i}ddd}dddc{i}iicddcddddciiiiic{d}iiic{{d}iii}dc{{i}dd}iiiicdddddc{{d}iii}iiic{d}ddc{{i}dddd}iiiiiic{i}{i}dcdc{{d}ii}ddddc{{i}ddd}iiic{i}ic{{d}ii}ddddc{{i}d}dddc{d}{d}ddc{i}{i}ddc{{d}ii}dddc{{i}dd}iiiicdddddcc{{d}ii}ic{{i}ddd}ddcdddc{i}{i}dddc{d}iiic{{d}iii}dddddc{{i}dd}iiiicdddddc{{d}ii}ic{{i}dd}iiic{d}ddddcc{{d}iii}ic{{i}dddd}iiiiic{i}iiic{i}icdddddc{d}ddciciiiiic{d}iiic{{d}iiiiii}ddddc{d}{d}{d}iiic{{i}dd}iiiic{d}ddcdddc{i}dc{{d}ii}iic{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}ddd}iiiiiiciiiccddddcddddddcdc{{d}iii}iic{{i}dddd}iiiiic{i}{i}dc{{d}ii}ddddc{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}dd}iiic{d}cdddddcic{i}iiiic{{d}ii}dddc{{i}dd}dc{d}ic{{d}iii}c{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}d}dddc{d}{d}iic{i}dddcc{{d}iiii}ddddc{d}ddc{{i}dddd}iiiiic{i}iiic{d}c{{d}iii}iic{{i}dd}ddciciiiiic{d}dcddddddciicdc{{d}iii}iic{{i}dd}iiiic{d}ddc{d}iiic{i}{i}dc{{d}ii}ddddc{{i}dd}iiiic{d}ddcdddc{i}{i}c{{d}i}ic{{i}d}dddc{d}{d}iic{i}iiic{d}dddc{{d}iii}ic{{i}ddd}ciiiciiicc{d}iiicdc{{d}iii}iic{{i}d}dddc{d}ddddc{i}ic{d}ddc{{d}iii}ddc{{i}ddd}dddc{i}{i}ddcdddddc{d}ddddc{i}iiic{d}ddddc{i}{i}dddc{d}ddddc{i}iiiiic{{d}ii}dddc{{i}dddd}iiiiic{i}iiic{d}c{{d}iii}iic{{i}dddd}iiiiiic{i}iiiccddddc{{d}iiii}ddc{{i}ddd}c{d}dcdddc{i}dddc{i}c{d}{d}iiic{i}iiiic{{d}iiiii}ddddddc{d}{d}{d}iiic{{i}ddd}iicdddc{i}iiic{d}dddc{{d}iii}ic{{i}dddd}iiiiic{i}iiic{d}c{{d}iii}iic{{i}dd}iiiic{d}ddcdddc{i}iiic{d}dddc{{d}iii}ic{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}dd}iiic{d}{d}iic{i}{i}iic{{d}i}iiic{{i}dd}dddc{d}ddc{i}iiiiiciiic{{d}ii}dddc{{i}dddd}iiiiic{i}iiic{d}c{{d}iii}iic{{i}dd}c{d}iiicddddddc{i}{i}dddcicdddc{d}dddc{i}iiiic{{d}ii}dddc{{i}ddd}iic{i}iiic{d}iiic{d}iiic{{d}iii}dc{{i}dd}iiiiicdddddcdcdc{{d}ii}iic{{i}dd}c{d}dciic{i}iic{{d}iii}ic{d}ddddc{{i}ddddd}ic{i}{i}icdddc{{d}iii}ic{{i}dd}iiiicdddddccddddc{{d}iii}dddddc{{i}ddd}ddc{i}ic{i}ddc{d}ic{{d}ii}iic{{i}dddd}iiiiic{{d}iiii}dddddc{{i}ddd}iiiic{d}ic{i}{i}dddc{{d}ii}ddc{{i}ddd}c{i}iicdddcddc{{d}ii}iiic{{i}dd}dcdc{d}ic{{d}iii}ic{{i}dd}dc{d}ic{{d}iii}c{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}dd}iiic{d}dcdddc{i}dddc{i}c{d}{d}iiic{i}iiiic{{d}ii}dddc{{i}dddd}iiiiic{i}{i}ddc{{d}ii}dddc{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}dd}c{d}dddddc{i}{i}ddcc{d}ddddcdc{{d}iiiiii}dc{d}{d}{d}iiic{{i}ddd}iiic{i}ic{{d}ii}ddddc{{i}d}dddc{d}{d}ddc{i}{i}ddc{{d}ii}dddc{{i}ddd}iiiiiic{d}dciciiic{i}dddcc{d}iiicdc{{d}iii}iiciic{{i}dddddd}iiiiiciiic{d}{d}iiic{i}iiic{d}iiicddc{{d}iiiiii}iiic{{i}dddddd}iiiiic{d}ddc{i}{i}dddcdddddc{d}ddc{i}ic{d}dciiicic{d}{d}{d}dddddc{i}c{d}ddc{{i}dddd}iiiiiic{i}{i}dcdc{{d}ii}ddddc{{i}dd}iiiicdddddc{{d}ii}ic{{i}ddd}iicdddc{i}iiic{{d}ii}ddc{{i}ddd}ic{i}ic{d}dddcddddc{i}{i}dc{{d}ii}ddddc{{i}ddd}ddciiiiic{i}c{d}{d}iic{i}iiiiiccdcddddddciiiiiciiiiiic{d}iiic{d}iic{i}dciiiiiic{{d}ii}ddddc{{i}ddd}iiic{i}ic{{d}ii}ddddc{{i}d}dddc{d}{d}ddc{i}{i}ddc{{d}ii}dddc{{i}ddd}dc{i}ddciiiciiiiciiiiic{{d}iiii}dddc{d}{d}ddddddc{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}ddd}ddciiiiicdddddc{{d}iii}iic{{i}dd}ddciciiiiic{{d}ii}ddddc{{i}ddd}iiiiiicdddciicddddddc{{d}iii}ic{{i}dd}iiiicdddddc{{d}ii}ic{{i}ddd}ddc{i}iiiicdddcic{{d}ii}c{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}ddd}iiiic{d}ic{i}{i}dddc{{d}ii}ddc{{i}ddd}c{i}dciiic{{d}ii}ddc{{i}ddd}cdcddddc{i}{i}dddc{{d}ii}ddc{{i}dd}dc{d}ic{{d}iii}c{{i}ddd}iiiiicddciiiccdddciiiiic{d}iiic{{d}iii}dc{{i}dd}iiicddddcddc{d}iicdddc{i}iiic{d}dc{i}{i}ic{{d}i}ic{{i}dd}iiiiic{d}iiic{d}cic{i}iiicddddc{d}icddddc{i}{i}dc{d}ddc{{d}iiii}c{d}ddc{{i}dd}iiicddddc{{d}ii}ic{{i}dd}dddc{d}ddc{i}iiic{d}dddciiiiiicddcdc{{d}iii}iic{{i}dd}iiiicdddddc{{d}ii}ic{{i}dd}ciiiiicdc{{d}ii}ddddc{{i}ddd}iiic{i}ic{{d}ii}ddddc{{i}ddd}iiiciiiiiciiiiiicdddddc{{d}ii}ic{{i}dd}dcdc{d}ic{{d}iii}ic{{i}dd}dc{d}ic{{d}iii}c{{i}dd}iiiic{d}ddcdddc{{d}iii}ic{{i}ddd}dddc{i}{i}ddcdddddc{d}ddddc{i}iiic{d}ddddc{i}{i}dddc{d}ddddc{i}iiiiic{{d}ii}dddc{{i}dddd}iiiiic{i}{i}ddc{{d}ii}dddc{{i}dd}iiic{d}dcdddc{{d}iii}ic{{i}ddd}cdc{i}dddcc{{d}iii}ddddddc{{i}dd}c{d}dddddc{i}{i}ddcic{{d}ii}ddddc{{i}ddd}iiic{i}ic{{d}iii}c

No input, so I'm just making it up.


text:
Break The Chain
You are given an \$ 25 \times 25 \$ square lattice graph. You are to remove certain nodes from the graph as to minimize your score, based on the following scoring system:
Your score will be the \$ \text{number of nodes removed} \$ \$ + \$ the \$ \text{size of the largest connected component} \$. In the smaller \$ 4 \times 4 \$ example below, exactly \$ 5 \$ nodes have been crossed out (removed), and the size of the largest connected component is \$ 4 \$ (top and left components). Therefore the total score is \$ 9 \$.

Notes

You should give your score alongside a list of crossed out nodes
If a program was written to solve this problem, please include it in your answer if possible
Here is a program to check your score

This is code-challenge, so the minimum score wins!

Out of curiosity, as someone not well versed in graph theory, is this equivalent to saying "Divide a 25x25 grid by placing obstacles in cells. Your score is the size of the largest contiguous area free of obstacles, plus the number of obstacles you placed"?

@SteveBennett Yes, that is certainly another way to put it :)

I sense an OEIS entry in this - Calculate the minimum scores for any NxN grid size.  Proving optimality would be pretty challenging at higher N's though.

92+41=133
.......X.........X.......
........X.......X........
.......X.........X.......
......X.X.......X.X......
.....X...X.....X...X.....
....X.....X...X.....X....
...X.......X.X.......X...
X.X.........X.........X.X
.X.X.......X.X.......X.X.
....X.....X...X.....X....
.....X...X.....X...X.....
......X.X.......X.X......
.......X.........X.......
......X.X.......X.X......
.....X...X.....X...X.....
....X.....X...X.....X....
.X.X.......X.X.......X.X.
X.X.........X.........X.X
...X.......X.X.......X...
....X.....X...X.....X....
.....X...X.....X...X.....
......X.X.......X.X......
.......X.........X.......
........X.......X........
.......X.........X.......

Now with 13 regions, all of 41.
Previous version 93+46=139
X...........X...........X
.X..........X..........X.
..X.........X.........X..
...X.......X.X.......X...
....X.....X...X.....X....
.....X...X.....X...X.....
......X.X.......X.X......
.......X.........X.......
......X.X.......X.X......
.....X...X.....X...X.....
....X.....X...X.....X....
...X.......X.X.......X...
XXX.........X.........XXX
...X.......X.X.......X...
....X.....X...X.....X....
.....X...X.....X...X.....
......X.X.......X.X......
.......X.........X.......
......X.X.......X.X......
.....X...X.....X...X.....
....X.....X...X.....X....
...X.......X.X.......X...
..X.........X.........X..
.X..........X..........X.
X...........X...........X

8 regions of 46, 4 regions of 41.

This looks like a spider web. I guess a spider is actually minimizing the size of the holes while using as little silk as possible.

Why do I get 185 on this?

@mypronounismonicareinstate I don't know. I count 46 for the largest region (there are 8 of them) and 93 X's, total 139.

After a long examination, I found the problem: there's a cleverly hidden lowercase X.

@mypronounismonicareinstate Edited. Thanks

I bit the bullet and calculated the optimal size for a diamond pattern. It turns out to be 41. It looks like we have a winner!

Lower bound: 114
Notation: Add 25 points to each side of the grid to produce a 27-by-27 grid with corners missing. Call these additional 100 points \$\mathcal{E}\$. Let \$\mathcal{X}\$ denote the set of deleted points. Say the \$i\$th component has \$c_i\$ points and is bounded by \$x_i\$ members of \$\mathcal{X}\$ and by \$e_i\$ members of \$\mathcal{E}\$.
Constraints: First, components that border \$\mathcal{E}\$ border disjoint subsets of \$\mathcal{E}\$, and so
$$\sum_i e_i \leq 100.$$
Next, consider the simple polygon with vertices/perimeter at the members of \$\mathcal{X}\$ and \$\mathcal{E}\$ that border the \$i\$th component. By Pick's theorem, the area of this polygon is
$$A_i=c_i + \frac{x_i + e_i}{2} - 1.$$
Meanwhile, the octagon with \$\mathcal{E}\$ as vertices/perimeter has area 674. As such,
$$\sum_i c_i + \sum_i\Big( \frac{ x_i + e_i }{2} - 1 \Big)
= \sum_i A_i
\leq 674.$$
Furthermore, it is conjectured (!) that
$$\frac{ x_i + e_i }{2} - 1
\geq \frac{1}{2}\Big\lceil \sqrt{8c_i-4}\Big\rceil.$$
Optimization: In our notation, we seek to minimize \$|\mathcal{X}|+\max_i c_i\$. It is convenient to write
$$|\mathcal{X}|
= 625 - \sum_i c_i.$$
We may relax our optimization to only consider the above constraints:
$$\text{minimize} \quad 625 - \sum_i c_i + \max_i c_i$$
$$\text{subject to} \quad \sum_i e_i \leq 100, \quad
\sum_i c_i + \sum_i\Big( \frac{ x_i + e_i }{2} - 1 \Big) \leq 674, $$
$$\frac{ x_i + e_i }{2} - 1
\geq \frac{1}{2}\Big\lceil \sqrt{8c_i-4}\Big\rceil, \quad x,c,e \geq 0.$$
The square root makes this optimization a pain, so we further relax to a sequence of linear programs. To accomplish this, we take
$$X_k := \sum_{i:c_i=k} x_i,
\quad
E_k := \sum_{i:c_i=k} e_i,
\quad
z_k := |\{i:c_i = k\}|,
\quad
C := \max_i c_i.$$
Then for each \$C\in\{1,\ldots,133\}\$, we solve the linear program
$$\text{minimize} \quad 625 - \sum_k kz_k + C$$
$$\text{subject to} \quad \sum_k E_k \leq 100, \quad
\sum_k kz_k + \sum_k\Big( \frac{ X_k + E_k }{2} - z_k \Big) \leq 674, $$
$$\frac{ X_k + E_k }{2} - z_k
\geq \frac{1}{2}\Big\lceil \sqrt{8k-4}\Big\rceil\cdot z_k, \quad X,E,z \geq 0.$$
Indeed, we only need to consider \$C\leq 133\$ thanks to the best known solution. Here's an implementation in MATLAB using CVX:
vals=[];
for C=1:133;
    [C min(vals)]
    w = ceil(sqrt(8*(1:C)-4))/2;
    cvx_begin quiet
        variable X(C)
        variable E(C)
        variable z(C)
        minimize( 625 - (1:C)*z + C )
        subject to
            sum(E) <= 100
            (1:C)*z + sum( (X+E)/2-z ) <= 674
            for ii=1:C
                (X(ii)+E(ii))/2-z(ii) >= w(ii)*z(ii)
            end
            X >= 0
            E >= 0
            z >= 0
        cvx_end
    vals(end+1)=cvx_optval;
end

The minimum value of 113.32 occurs when \$C=41\$. (Curiously, this is the size of the components in the best known solution.) Here's a plot of how the minimum varies with \$C\$:

Score 80 + 61 = 141
........X...........X....
.......X.............X...
........X...........X....
.X.......X.........X.....
X.X.......X.......X......
...X.......X.....X.......
....X.......X...X........
.....X.....X.X.X.......X.
......X...X...X.......X.X
.......X.X.....X.....X...
........X.......X...X....
.......X.........X.X.....
......X...........X......
.....X.X.........X.......
....X...X.......X........
...X.....X.....X.X.......
X.X.......X...X...X......
.X.......X.X.X.....X.....
........X...X.......X....
.......X.....X.......X...
......X.......X.......X.X
.....X.........X.......X.
....X...........X........
...X.............X.......
....X...........X........

Found with the help of this program which tells you the number of Xs and the size of each area of .s.
Previous score 89 + 54 = 143
....X...............X....
.....X.............X.....
......X...........X......
.......X.........X.......
........X...X...X........
.........XXX.XXX.........
........X.......X........
.......X.........X.......
XXXXXXX...........XXXXXXX
.......X.........X.......
.......X.........X.......
........X.......X........
.........XXXXXXX.........
........X.......X........
.......X.........X.......
.......X.........X.......
XXXXXXX...........XXXXXXX
.......X.........X.......
........X.......X........
.........XXX.XXX.........
........X...X...X........
.......X.........X.......
......X...........X......
.....X.............X.....
....X...............X....

It's pretty. :)

C++, score 147
Adding simulated annealing has changed the results very significantly. They are now extremely worrying.
The code:
//#define _GLIBCXX_DEBUG
#include <x86intrin.h>
#include <iostream>
#include <streambuf>
#include <bitset>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
#include <climits>
#include <random>
#include <set>
#include <list>
#include <map>
#include <unordered_map>
#include <deque>
#include <stack>
#include <queue>
#include <string>
#include <iomanip>
#include <unordered_set>
#include <thread>

std::mt19937_64 mt;
int N = 25;
std::vector<char> cuts(N*N);
std::vector<char> marks;
int dfs(int at)
{
    char x = at % N, y = at / N;
    marks[at] = true;
    int sz = 1;
    static const char ddx[4] {1, -1, 0, 0};
    static const char ddy[4] {0, 0, 1, -1};
    for(int d = 0; d < 4; d++)
    {
        int dx = ddx[d], dy = ddy[d];
        int nx = x + dx, ny = y + dy;
        if(nx < 0 || ny < 0 || ny >= N || nx >= N) continue;
        if(marks[ny * N + nx]) continue;
        sz += dfs(ny * N + nx);
    }
    return sz;
}
bool connected(int at)
{
    char x = at % N, y = at / N;
    static const char ddx[4] {1, -1, 0, 0};
    static const char ddy[4] {0, 0, 1, -1};
    for(int d = 0; d < 4; d++)
    {
        int dx = ddx[d], dy = ddy[d];
        int nx = x + dx, ny = y + dy;
        if(nx < 0 || ny < 0 || ny >= N || nx >= N) continue;
        if(cuts[ny * N + nx]) return true;
    }
    return false;
}
int score()
{
    marks = cuts; //true -> pretend it's already cut
    int ans1 = 0, ans2 = 0;
    for(char el : cuts) ans2 += el == true;
    for(int i = 0; i < N*N; i++)
    {
        if(marks[i]) continue;
        ans1 = std::max(ans1, dfs(i));
    }
    return ans1 + ans2;
}
int main()//int64_t argc, char*argv[])
{
    int gs = 8;
    for(int y = 0; y < N; y++)
    for(int x = 0; x < N; x += gs)
        cuts[y*N+x] ^= true;
    for(int y = 0; y < N; y += gs)
    for(int x = 0; x < N; x++)
        cuts[y*N+x] ^= true;
    for(int x = 0; x < N; x++)
        cuts[x] ^= true,
        cuts[N*x] ^= true,
        cuts[N*(N-1)+x] ^= true,
        cuts[N*x+N-1] ^= true;
    //do random changes, minimizing score
    printf("%d\n", score());
    int its = 1e6;
    float temp = 1;
    for(int y = 0; y < N; y++)
    {
        for(int x = 0; x < N; x++) printf("%c", cuts[y*N+x] ? '#' : '.');
        printf("\n");
    }
    while(its --> 0)
    {
        if(its % 1000 == 0) printf("i: %d\n", its);
        temp -= 2e-6;
        int i = 0;
        do { i = mt() % (N*N); }
        while(!cuts[i] && !connected(i));
        //fun fact: do..while loops don't actually need braces
        int sb = score();
        cuts[i] ^= 1;
        int sa = score();
        int delta = sb - sa; //positive -> good
        //printf("%d\n", delta);
        if(delta <= 0 && (temp <= 0 || ldexpf(std::exp(delta / temp), 60) < mt()))
            cuts[i] ^= 1;
        else printf("%d\n", sa);
    }
    for(int y = 0; y < N; y++)
    {
        for(int x = 0; x < N; x++) printf("%c", cuts[y*N+x] ? '#' : '.');
        printf("\n");
    }
}

The output, with the starting condition being a 3x3 grid:
........#........#.......
.........#......#........
........#.......#........
.......#.......#.........
........#.......#........
........#........#.......
.......#........#........
.#....#.#......#.#...#.##
#.#.##...#...##...#.#.#..
...#......#.#....#.#.....
...........#.....#.......
..........#......#.......
.........#.......#.......
#......##........#.......
.#....#.......###........
..##.#.......#..#........
....#......##....#....#.#
.....#....#......#...#.#.
......#.##........###....
.......#.........#.......
.......#........#........
........#......#.........
.......#......#..........
.......#......#..........
.......#.....#...........
```

Score: 158 145 141
-4 thanks to @LevelRiverSt !
.....X.............X.....
.....X.............X.....
......X...........X......
.......X.........X.......
........X.......X........
XX.......X.....X.......XX
..X.......X.X.X.......X..
...X.......X.X.......X...
....X.....X...X.....X....
.....X...X.....X...X.....
......X.X.......X.X......
.......X.........X.......
......X...........X......
.......X.........X.......
......X.X.......X.X......
.....X...X.....X...X.....
....X.....X...X.....X....
...X.......X.X.......X...
..X.......X.X.X.......X..
XX.......X.....X.......XX
........X.......X........
.......X.........X.......
......X...........X......
.....X.............X.....
.....X.............X.....

Try it online!
Number of X: 80
Largest component: 61
Divide the grid into 9 rougly equal areas of size ~60.

There is a way to get 80+61 by revising the spokes (more or less a rotation by 1/16 turn.) Do 2 rows of .....X.............X..... at the top then go diagonally in toward the central diamond.

@LevelRiverSt thanks!

92 + 45 = 137
......X.........X........
.......X........X........
........X........X.......
.......X.X.......X.......
......X..X......X.X......
.....X....X....X...X.....
....X......X..X.....X...X
X..X.......X.X.......X.X.
.XX.........X.........X..
...X.......X.X.......X...
....X.....X...X.....X....
.....X...X.....X...X.....
......X.X.....X.X.X......
.......X.....X...X.......
......X.....X.....X......
.....X......X......X.....
....X......X........X....
....X.....X.X........XXX.
XXXX.X...X...X......X...X
......X.X.....X....X.....
.......X.......X..X......
.......X........XX.......
........X.......X........
........X.......X........
........X.......X........

Try it online!
I started with a program, then I took the best output and hand-modified it to get this. Next I'm going to try restricting the program to only place Xs on one color of squares - that seems like it might work better. The program is written in rust. The key idea was to seed the map with a Vornoi diagram before running a simplified simulating annealing:
use rand::prelude::*;

use std::collections::{HashMap, HashSet};

fn make_neighbors(point: (usize, usize), size: usize) -> Vec<(usize, usize)> {
    let (r, c) = point;
    let mut neighbors = vec![];
    if r > 0 {
        neighbors.push((r - 1, c));
    }
    if c > 0 {
        neighbors.push((r, c - 1));
    }
    if r < size - 1 {
        neighbors.push((r + 1, c));
    }
    if c < size - 1 {
        neighbors.push((r, c + 1));
    }
    neighbors
}

fn value_board(board: &Vec<Vec<bool>>) -> usize {
    let size = board.len();
    let mut color_counts = vec![];
    let mut removed_count = 0;
    let mut seen = HashSet::new();
    for r in 0..size {
        for c in 0..size {
            if board[r][c] {
                removed_count += 1;
            } else {
                let mut color_count = 0;
                let mut flood_stack = vec![(r, c)];
                while !flood_stack.is_empty() {
                    let point = flood_stack.pop().unwrap();
                    if !board[point.0][point.1] &&!seen.contains(&point) {
                        seen.insert(point);
                        color_count += 1;
                        let neighbors = make_neighbors(point, size);
                        flood_stack.extend(neighbors);
                    }
                }
                color_counts.push(color_count);
            }
        }
    }
    let max_color_count = color_counts.into_iter().max().unwrap_or(0);
    removed_count + max_color_count
}

// TODO: make removed, neighbor_removed into VecSets.
fn simulated_annealing(input_board: &Vec<Vec<bool>>, max_steps: usize) -> Vec<Vec<bool>> {
    let size = input_board.len();
    let mut coloring: HashMap<(usize, usize), usize> = HashMap::new();
    let mut max_color = 0;
    let mut color_counts = vec![];
    let mut removed: Vec<(usize, usize)> = vec![];
    let mut neighbor_removed: Vec<(usize, usize)> = vec![];
    let mut board = input_board.clone();
    for r in 0..size {
        for c in 0..size {
            if board[r][c] {
                removed.push((r, c));
                let neighbors = make_neighbors((r, c), size);
                for point in neighbors {
                    if !board[point.0][point.1] && !neighbor_removed.contains(&point) {
                        neighbor_removed.push(point);
                    }
                }
            } else {
                if !coloring.contains_key(&(r, c)) {
                    let color = max_color;
                    max_color += 1;
                    color_counts.push(0);
                    let mut flood_stack = vec![(r, c)];
                    while !flood_stack.is_empty() {
                        let point = flood_stack.pop().unwrap();
                        if !board[point.0][point.1] && !coloring.contains_key(&point) {
                            coloring.insert(point, color);
                            color_counts[color] += 1;
                            let neighbors = make_neighbors(point, size);
                            flood_stack.extend(neighbors);
                        }
                    }
                }
            }
        }
    }
    let mut rng = thread_rng();
    for step in 0..max_steps {
        //dbg!(&removed, &neighbor_removed, &coloring, &board);
        assert_eq!(removed.len() + coloring.len(), size.pow(2));
        if rng.gen::<f64>() < 0.5  && !removed.is_empty() {
            let index = rng.gen_range(0, removed.len());
            let &(r, c) = &removed[index];
            assert!(removed.contains(&(r, c)));
            assert!(!neighbor_removed.contains(&(r, c)));
            assert!(!coloring.contains_key(&(r, c)));
            assert!(board[r][c]);
            let neighbors = make_neighbors((r, c), size);
            let neighbor_colors: HashSet<usize> = neighbors
                .iter()
                .filter_map(|n| coloring.get(n))
                .cloned()
                .collect();
            // Remove if only 1 color.
            // This will always be a neutral or improving step
            // Never remove otherwise
            if neighbor_colors.len() <= 1 {
                board[r][c] = false;
                removed.swap_remove(index);
                let neighbors = make_neighbors((r, c), size);
                for neighbor in neighbors {
                    if board[neighbor.0][neighbor.1] {
                        neighbor_removed.push((r, c));
                        break;
                    }
                }
                let new_color = if neighbor_colors.len() == 1 {
                    neighbor_colors.into_iter().next().unwrap()
                } else {
                    let new_color = max_color;
                    max_color += 1;
                    color_counts.push(0);
                    new_color
                };
                coloring.insert((r, c), new_color);
                color_counts[new_color] += 1;
            }
        } else if !neighbor_removed.is_empty() {
            let index = rng.gen_range(0, neighbor_removed.len());
            let (r, c) = neighbor_removed[index];
            let my_color = *coloring.get(&(r, c)).unwrap();
            let is_max_color = color_counts.iter().enumerate().all(|(i, &color_count)| {
                i == my_color || color_count < color_counts[my_color]
            });
            // Flip if either is a max color, in which case it's free,
            // or temp is high enough and get lucky.
            let take_action = is_max_color || {
                step < max_steps / 2 && rng.gen::<f64>() < 0.1
            };
            if take_action {
                board[r][c] = true;
                neighbor_removed.swap_remove(index);
                removed.push((r, c));
                coloring.remove(&(r, c));
                color_counts[my_color] -= 1;
                let neighbors = make_neighbors((r, c), size);
                for neighbor in neighbors {
                    if !board[neighbor.0][neighbor.1] && !neighbor_removed.contains(&neighbor) {
                        neighbor_removed.push(neighbor)
                    }
                }
            }
        }
    }
    board
}
// Given starting points and a board size, make a vornoi diagram
fn vornoi(points: &Vec<(usize, usize)>, size: usize) -> Vec<Vec<bool>> {
    let mut time_board: Vec<Vec<Option<usize>>> = vec![vec![None; size]; size];
    let mut board = vec![vec![false; size]; size];
    for (i, point) in points.iter().enumerate() {
        time_board[point.0][point.1] = Some(i);
    }
    for _ in 0..size {
        let mut new_board = time_board.clone();
        for r in 0..size {
            for c in 0..size {
                if let Some(i) = time_board[r][c] {
                    let neighbors = make_neighbors((r, c), size);
                    for (nr, nc) in neighbors {
                        if let Some(j) = new_board[nr][nc] {
                            if i != j {
                                board[r][c] = true;
                            }
                        } else {
                            new_board[nr][nc] = Some(i);
                        }
                    }
                }
            }
        }
        time_board = new_board
    }
    board
}

fn random_vornoi(num_points: usize, size: usize) -> Vec<Vec<bool>> {
    let mut points = vec![];
    let mut rng = thread_rng();
    while points.len() < num_points {
        let r = rng.gen_range(0, size);
        let c = rng.gen_range(0, size);
        if !points.contains(&(r, c)) {
            points.push((r, c))
        }
    }
    vornoi(&points, size)
}
fn print_board(board: &Vec<Vec<bool>>) {
    let string_board = board
        .iter()
        .map(|row| {
            row.iter()
                .map(|&c| if c { 'X' } else { '.' })
                .collect::<String>()
        })
        .collect::<Vec<String>>()
        .join("\n");
    println!("{}", string_board);
}
fn main() {
    let size: usize = 25;
    let reps = 100;
    let steps = 30000000;
    let mut best_points = 0;
    let mut best_board = None;
    let mut best_value = size.pow(2);
    for num_points in 8..17 {
        let mut best_board_points = None;
        let mut best_value_points = size.pow(2);
        for _ in 0..reps {
            let board = random_vornoi(num_points, size);
            let better_board = simulated_annealing(&board, steps);
            let value = value_board(&better_board);
            if value < best_value {
                best_board = Some(better_board.clone());
                best_value = value;
                best_points = num_points;
            }
            if value < best_value_points {
                best_board_points = Some(better_board);
                best_value_points = value;
            }
        }
        println!("{} {}", num_points, best_value_points);
        print_board(&best_board_points.unwrap());
        println!();
    }
    println!("{} {}", best_points, best_value);
    print_board(&best_board.unwrap());
    println!();
}

To run the program, put the above file in src/main.rs and put rand = "*" in your Cargo.toml.

Score: 314 313
-1 thanks to @Level River St
.X.X.X.X.X.X.X.X.X.X.X.X.
X.X.X.X.X.X.X.X.X.X.X.X.X
.X.X.X.X.X.X.X.X.X.X.X.X.
X.X.X.X.X.X.X.X.X.X.X.X.X
.X.X.X.X.X.X.X.X.X.X.X.X.
X.X.X.X.X.X.X.X.X.X.X.X.X
.X.X.X.X.X.X.X.X.X.X.X.X.
X.X.X.X.X.X.X.X.X.X.X.X.X
.X.X.X.X.X.X.X.X.X.X.X.X.
X.X.X.X.X.X.X.X.X.X.X.X.X
.X.X.X.X.X.X.X.X.X.X.X.X.
X.X.X.X.X.X.X.X.X.X.X.X.X
.X.X.X.X.X.X.X.X.X.X.X.X.
X.X.X.X.X.X.X.X.X.X.X.X.X
.X.X.X.X.X.X.X.X.X.X.X.X.
X.X.X.X.X.X.X.X.X.X.X.X.X
.X.X.X.X.X.X.X.X.X.X.X.X.
X.X.X.X.X.X.X.X.X.X.X.X.X
.X.X.X.X.X.X.X.X.X.X.X.X.
X.X.X.X.X.X.X.X.X.X.X.X.X
.X.X.X.X.X.X.X.X.X.X.X.X.
X.X.X.X.X.X.X.X.X.X.X.X.X
.X.X.X.X.X.X.X.X.X.X.X.X.
X.X.X.X.X.X.X.X.X.X.X.X.X
.X.X.X.X.X.X.X.X.X.X.X.X.

The largest connected component is of size 1.
Verify the score here: Try it online!

I make your score 313. 625/2 rounded up. Or alternatively add each pair of rows and you get 12*25 with an additional 13 for the odd row at the bottom.

source: Stack Exchange

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

sort: votes


text:
Holey Knight's Tour
Given a rectangular board of cells with some number of holes in it, determine whether it is possible to complete a "holey knight's tour" (That is, a path that visits every non-hole cell exactly once using only chess knight moves, not returning to the starting cell) that starts on the top-left cell.
For the sake of completeness of the challenge definition, knights move by teleporting directly to a cell that is two cells away along one axis and one cell along the other axis.
Examples
Using . for open spaces and X for holes
1
. . .
. X .
. . .

YES
2
. . . X
. X . .
. . X .
X . . .

NO
3
. . . . .
X . . . .
. . X . .
. X . . .
. . . . .

YES
4
. . X . .
X . . . X
. . . . .
. X . . .
X . . X X

YES
5
. . . . . .
. . X . . .
. X . . . .
. . . . . .
. . . . . .

NO
Rules and Assumptions

You must theoretically be able to support boards up to 1000x1000
Boards do not necessarily have to be square
As this problem could potentially have exponential time complexity in the worst case, and in an effort to not make testing solutions take forever, board sizes up to 6x6 must return an answer within one minute on modern hardware.
A board with a hole in the top-left corner (where the knight starts) is always unsolvable

Shortest code wins

@Arnauld thanks. Fixed

Can we take input as a list of holes or as a list of non-holes?

Thank you for fixing the test cases. Unfortunately, the 3rd rule prevents me from posting my solution, even though it solves all test cases almost instantly. :-(

@Arnauld What pathological test case is giving you issues and how long does it take? I could definitely ease up on the time restriction if you're not too far off.

Well, this one for instance. (The Perl answer can't solve it either. I don't know about Sledgehammer.)

Sledgehammer, 29 bytes
⠑⡘⣡⡪⡾⢸⢹⣎⡷⡬⢵⣅⢞⣽⣤⡥⠃⠏⢂⢜⠩⡬⢸⠜⡻⣠⡪⢄⡯

That's not very readable, so here's the corresponding Mathematica code:
 AnyTrue[Thread@
   FindHamiltonianPath[
    Subgraph[KnightTourGraph[#2, #3],
     o = First /@ StringPosition[#, "."]], 1, o],
  ListQ@# && Length@# > 0 &] &

This removes unneeded vertices from the knight's graph (first obtained via KnightTourGraph), calls FindHamiltonianPath with all possible end vertices (it either takes nothing and finds any Hamiltonian path, or it takes both a start and an end vertex) and checks whether any paths were actually found.
Example input (for the fourth test case)
{"..X..X...X......X...X..XX", 5, 5}

The first line is a flat version of the grid (obtained by reading it in row-major order).
I have first thought that this doesn't work, but then I investigated and finally found what seems to be a bug in the interpreter: the hammer.wls main script doesn't call postprocess, and (when decoding) it ends up evaluating the code with all slots (#, #2, #3) replaced by variables s1, s2, s3 :(. Fortunately, the interactive app, while even less convenient, doesn't have this bug.

Python 3, 166 bytes
def f(g,s=[0]):w=len(g[0])+2;k='XX'.join(g)+w*'XXX';*p,x=s;return{*s,'.'}>{*p,k[x]}and any(f(g,s+[x+a])|f(g,s+[x-a])for a in(w+2,w-2,w-~w,w+w-1))|len(s)//k.count('.')

Try it online!
Brute force all paths.
Adaptation from my answer to Find the shortest route on an ASCII road.

R, 243 213 bytes
Edit: -30 bytes by merciless code-trimming...
function(p,m,n=1e4,f=function(p,m,x){m[t(p)]=1
d=p+matrix(c(q<-c(1,2,2,1,1,-2,2,-1),-q),2)
`if`(w<-sum(v<-!m[d<-t(d[,!colSums(d<1|d>dim(m))])]),f(d[which(v)[sample(w,1)],],m),!sum(!m))})mean(sapply(1:n,f,p=p,m=m))

Try it online!
This is a stochastic algorithm.
The complete search (163 bytes) of all tours on a 6x6 board without holes can require up to approx 36 (positions) x 2^36 (combinations of already-visited squares or holes), which does not run in a <1 minute time-frame, and even memoising already-tried partial-tours isn't feasible (since unfortunately R vectors are limited to a length of 2^31).
So instead we repeatedly attempt random tours.  1e5 random tours is sufficient to sample the entire, no-hole, 6x6 board and repeatedly find successful tours within 1 minute (although unfortunately not on TIO).
At the cost of 1 wasted byte, the implementation here reports the fraction of successful to unsuccessful attempted tours.

Perl 5, 305 bytes
sub f{my($b,$x,$y)=(@_,1,1);$b=~/.+/;$lx=length$&;$P=sub{($X,$Y)=@_;$X<1||$X>$lx||$Y<1||$Y>$b=~y/\n//?0:($Y-1)*($lx+1)+$X};(!(substr($b,&$P($x,$y)-1,1)=~s,\.,x,)or$b!~/\./)||(any{f($b,@$_)}grep{substr($b,&$P(@$_)-1,1)eq'.'}map[$x+$$_[0],$y+$$_[1]],[2,-1],[2,1],[1,-2],[1,2],[-2,1],[-2,-1],[-1,2],[-1,-2])}

Try it online!

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


text:
Inverse of Conway base 13 function in \$\mathbb{Q}\$
(The \$\mathbb{Q}\$ in the title means rational numbers.)
Background
Conway base 13 function is an example of a strongly Darboux function, a function that takes every real number on any open interval \$(a,b)\$. In other words, for any given real numbers \$a, b, y\$, you can find a value \$x\$ between \$a\$ and \$b\$ such that \$f(x) = y\$.
The function is defined as follows:

Write the input value x in base 13 using thirteen symbols 0 .. 9, A, B, C, without any trailing infinite stream of Cs. (It is related to the fact 0.9999... = 1 in base 10, or 0.CCC... = 1 in base 13.)
Delete the sign and decimal point, if present.
Replace As with +, Bs with -, Cs with ..
Check if some (possibly infinite) suffix of the sequence starts with a sign (+ or -) and contains exactly one . and no extra signs. If such a suffix exists, interpret it as a decimal number; it is the value of \$f(x)\$. Otherwise, \$f(x) = 0\$.

Some examples:

\$f(123B45.A3C14159\dots _{13}) = f(0.A3C14159\dots _{13}) = 3.14159\dots \$
\$f(B1C234 _{13}) = -1.234\$
\$f(1C234A567 _{13}) = 0\$

Task
Given three rational numbers \$a = \frac{a_n}{a_d}, b = \frac{b_n}{b_d}, y = \frac{y_n}{y_d}\$ given as integer fractions, find a value of \$x = \frac{x_n}{x_d}\$ between \$a\$ and \$b\$ (exclusive) such that \$f(x) = y\$ (where \$f\$ is the Conway base 13 function). There are infinitely many values of \$x\$ that satisfy the condition for any input; just output one of them.
You can assume \$a < b\$, \$a_d, b_d, y_d > 0\$, \$y \ne 0\$, and the fractions are given in the reduced form. Negative input numbers are represented using negative numerators. You don't need to reduce the output fraction.
Standard code-golf rules apply. The shortest code in bytes wins.
Examples
a = 0/1, b = 1/1, y = 1/3
Decimal representation of \$y\$ is \$0.\overline{3}\$ (where the overline is the notation for repeating decimal). To get this value, the minimal base-13 suffix of \$x\$ is \$+.\overline{3}\$ or \$AC\overline{3}\$. An example of such an \$x\$ would be \$0.AC\overline{3}_{13} = 569/676\$. Proof by Wolfram|Alpha.
a = 2017/2197, b = 2018/2197, y = -1/5
The minimal base-13 suffix of \$x\$ is \$-.2 = BC2_{13}\$. But the value of a is exactly \$0.BC2_{13}\$, so we can't use that. And the value of b is \$0.BC3_{13}\$, so we're forced to begin with \$0.BC2\$. One possible value of \$x\$ is \$0.BC2BC2_{13} = 4433366 \; / \; 4826809\$.
a = 123/10 = c.3b913b91..., b = 27011/2196 = c.3b93b9..., y = 987/1
One possible answer is \$x = c.3b92a987c_{13} = 130435909031 \; / \; 10604499373\$.
a = -3/2, b = -4/3, y = -1/7
One possible answer is \$x = -1.5bc\overline{142857}_{13} = -28108919 \; / \; 19316024\$.

Why not just put ℚ in the title?

Huh, $\mathbb{Q}$ works, who knew?

Python 2, 254 237 219 216 207 bytes
-3 bytes thanks to @KevinCruijssen !
Can save 1 more byte by replacing X=e**(A+B) with X=e**A**B, but the result will be humongous, and the time taken to run will be very long.
e=13
a,A,b,B,y,Y=input()
X=e**(A+B)
x=a*X/A+2
r=abs(y)
s="AB"[y<0]+`r/Y`+"C"
R=[]
exec"R=[r]+R;r=r%Y*10;s+=`r/Y`;"*-~Y
n=~R.index(r)
T=e**-n-1
S=e**len(s)*T
print(int(s,e)*T+int(s[n:],e))*((x>0)*2-1)+x*S,X*S

Try it online! or Check all test cases!
A program that takes in 6 integers from STDIN, and prints out the numerator and denominator of the result.
Big idea

First, find a number \$c\$ such that \$a < c < b\$ and \$c\$ has finite base-13 representation. Note that \$c\$ should be "sufficiently far away" from \$a\$ and \$b\$. This will be the prefix of \$x\$.
For example: \$a = 1.1..._{13}, b = 1.3..._{13}\$ then \$c = 1.2_{13}\$. We say that \$c\$ is sufficiently far away from \$a\$ and \$b\$, since we can add any suffix to \$c\$ and it is guaranteed to stay in the range \$(a,b)\$.

Then find the suffix of \$x\$ by finding the base-10 representation of \$y\$, then replacing +-. with ABC. E.g with \$y = 1/3\$, the suffix is \$+0.(3)=A0C(3)\$

Join the prefix and suffix together. E.g \$x = 1.2A0C(3)\$.

Details
Finding the prefix:
The prefix has the form \$x/X\$, where \$X\$ is a power of 13.
Consider the integers \$\Bigl \lfloor \frac{aX}{A} \Big \rfloor \$ and \$\Bigl \lfloor \frac{bX}{B} \Big \rfloor \$ (where \$X = 13^i\$), which are the truncations of \$a/A\$ and \$b/B\$ to a certain base-13 precision. If there is an integer \$x\$ between those 2 numbers such that \$x\$ is at least 2 away from both numbers, then \$x/X\$ can be the prefix. This is because no matter what suffix is added, the value of \$x/X\$ won't change by more than \$1/X\$.
\$X=13^{A+B}\$ is guaranteed to be large enough to see a large gap between the truncation of \$a/A\$ and \$b/B\$.
This is the part that finds the prefix:
X=e**(A+B)
x=a*X/A+2

Finding the suffix:
First, the long division \$y/Y\$ is performed to find the decimal representation (with repeated digit). r is the current remainder, and R keeps track of the seen remainder after each digit division, in order to detect repeating decimals. \$y/Y\$ is calculated until \$Y+1\$ digits after the decimal point, which is sufficient to detect repeating groups of digits.
r=abs(y)
s="AB"[y<0]+`r/Y`+"C"
R=[]
exec"R=[r]+R;r=r%Y*10;s+=`r/Y`;"*-~Y

The suffix has the form \$stttt... = s(t)\$, where \$s\$ is the result of truncated \$y/Y\$ above, and \$t\$ is the repeating decimals found in \$s\$.
n=~R.index(r)
t = s[n:]

Thus, our result should have the form \$\frac{x + 0.sttt..._{13}}{X}\$ (or \$\frac{x - 0.sttt..._{13}}{X}\$ if \$x\$ is negative)
To convert 0.s(t) in base 13 to fraction, the following formula is used:
$$ 0.s(t) = 0.sttt... = \frac{s.(t)}{13^i} $$
$$ s.(t) = s.ttt... = s + \frac{t}{13^j-1} $$
where \$i, j\$ are the number of digits in \$s, t\$.

-3 bytes by changing s="AB"[y<0];y=abs(y);s+=`y/Y`+"C" to t=abs(y);s="AB"[y<0]+`t/Y`+"C" (and replacing all y after that with t). Nice approach btw!

Wolfram Language (Mathematica), 156 bytes
a=13;b=Floor;c=RealDigits@#~FromDigits~a&;(d=b[+##2/2,e=a^b@Log[a,#3-#2]/a])+If[d<0,-e,e]/a(If[#<0,11,10]+(c[f=b[g=Abs@#]]a+12+c[g-f])/a^IntegerLength@f/a)&

Try it online! Pure function. Takes the rational numbers \$y\$, \$a\$, and \$b\$ (in that order) as input and returns the rational number \$x\$ as output. The function directly uses rational arithmetic; I wrote another algorithm which manipulates the individual digits, but it took 192 bytes. I'm pretty sure that another few bytes can be squeezed out of this one, though, since the negative-number handling is somewhat sloppy. Also, here's an ungolfed version to clarify the logic:
Block[{y = #, a = #2, b = #3, conv = FromDigits[RealDigits[#], 13] &,
   pref, prefexp, ipart, sign},
  prefexp = 13^Floor[Log[13, b - a]]/13;
  pref = Floor[(a + b)/2, prefexp];
  ipart = Floor[Abs[y]];
  pref + If[pref < 0, -1, 1] prefexp/
     13 (If[y < 0, 11, 10] +
      13^-(IntegerLength[ipart] + 1) (13 conv[ipart] + 12 +
         conv[Abs[y] - ipart]))] &


text:
Generate *all* coprime tuples
Given integers k and n, generate a sequence of n unique k-tuples of pairwise coprime integers. Every such tuple must occur once eventually, that is, for any existing k-tuple of pairwise coprime integers, some n will eventually generate it.
The output may be printed or evaluated in any list/tuple-like form.
Definitions

Two numbers a and b are coprime if gcd(a, b) = 1, i.e. they share no common divisor other than 1.
A tuple of k numbers (a1, a2, ..., ak) is pairwise coprime if every pair of numbers in the tuple is coprime.

Examples
 k =  1, n =  5 -> [[1],[2],[3],[4],[5]]
 k =  2, n =  7 -> [[2,1],[3,1],[3,2],[4,1],[4,3],[5,1],[5,2]]
 k =  3, n = 10 -> [[3,2,1],[4,3,1],[5,2,1],[5,3,1],[5,3,2],[5,4,1],[5,4,3],[6,5,1],[7,2,1],[7,3,1]]
 k =  4, n =  2 -> [[5,3,2,1],[5,4,3,1]]
 k =  5, n =  0 -> []

Notes

Standard code golf rules, shortest code wins.
k is assumed to be positive, and n non-negative.
The numbers within each tuple must be positive, distinct, and may appear in any order.
Uniqueness is up to ordering: e.g. (1,2,3) is the same as (1,3,2).
Good luck and have fun!

Is "print [1, 1, ...[k-1 ones]..., x] for x in range from 1 to n" valid?

@mypronounismonicareinstate Lol I see, "every tuple of k pairwise coprime integers is seen exactly once", but I'll clarify.

I think your comment reduced clarity. Do we have to write a program that can output all possible tuples, or it simply has to produce no repetitions?

"such that as n grows large..." This confused me too.  The input is a fixed n and k -- how are we talking about what happens when n grows large?  Indeed, you might say I am a bit confused.

@Jonah Removed the mathy stuff, tried making it more concrete. Thank you!

I believe k = 0 should be excluded from the input range, as there is only one possible k-tuple [].

@Bubbler good point!

Does the output have to be the sequence of the first n tuples that satisfy the condition, or any n tuples that satisfy the condition? The second sentence is very confusing to me.

I think maybe the first sentence is saying that it's the "first n tuples", but the order can be specified by the submission - as long as it can guarantee that a given tuple will eventually appear for some finite n?

Suggested test case: k=4, n=2 (or any other with k>n>0).

05AB1E, 13 bytes
I think it has been 389 days since I last posted something here haha. There is definitely some golfing potential left in this program.
Code
Uses the 05AB1E-encoding.
∞æ¹ùʒPy.¿Q}²£

Try it online!

Explanation
It is worth noting that for two numbers \$n, m \in \mathbb{Z}^+\$ that:
$$
\tag{1} \label{1}
\gcd(n, m) \cdot \text{lcm}(n, m) = n \cdot m
$$
This means that for two numbers \$n, m \in \mathbb{Z}^+\$ where the \$\gcd(n, m) = 1\$, we can conclude that the \$\text{lcm}(n, m) = n \cdot m\$.
Furthermore, the \$\gcd\$ function is a multiplicative function, which means that if \$n_1\$ and \$n_2\$ are relatively prime, then:
$$
\gcd(n_1 \cdot n_2, m) = \gcd(n_1, m) \cdot \gcd(n_2, m)
$$

From this, we obtain the fact that:
$$
\tag{2} \label{2}
\gcd(a, bc) = 1 \iff \gcd(a, b) = 1 \wedge \gcd(a, c) = 1
$$

Let us denote a \$k\$-tuple of positive integers as \$S = \{x_1, x_2, \dots, x_k\}\$. A set \$S\$ is pairwise coprime, if and only if:
$$
\tag{3} \label{3}
\forall a, b \in S \wedge a \not = b \rightarrow \gcd(a, b) = 1
$$

Using Equations \$\eqref{1}, \eqref{2}\$ and \$\eqref{3}\$, we can conclude that a set \$S = \{x_1, x_2, \dots, x_k\}\$ is pairwise coprime, if and only if:
$$
\text{lcm}(x_1, x_2, \dots, x_k) = \prod_{x \in S} x
$$
Code Explanation

∞æ¹ùʒPy.¿Q}²£

∞æ              # Powerset of the infinite list [1, ..., ∞].
  ¹ù            # Keep only lists of length k.
    ʒ     }     # Filter. Keep lists where the
     P          #   product of the list
         Q      #   is equal to
      y.¿       #   the least common multiple of the list
           ²£   # Retrieve the first n elements.

Hey, Adnan, it's been long!

Hey @LuisMendo, it has been a long time indeed! Good to see you ;).

Brilliant solution!

Why doesn't ù and £ take existing items on the stack?

@Λ̸̸  – Mostly shitty programming when I developed the language.

Husk, 9 bytes
↑fËoε⌋`ṖN

Try it online!
Explanation
A straightforward solution, not the most exciting.
↑fËoε⌋`ṖN  Implicit inputs, say k=3, n=2.
        N  Natural numbers: [1,2,3,4,..
      `Ṗ   All k-element subsets: [[1,2,3],[2,3,4],[1,3,4],..
           ` flips the arguments of Ṗ since it expects the number first.
 f         Keep those that satisfy this:
  Ë          All pairs x,y (not necessarily adjacent) satisfy this:
     ⌋         their gcd
   oε          is at most 1.
           Result is all pairwise coprime subsets: [[1,2,3],[1,3,4],..
↑          Take the first n: [[1,2,3],[1,3,4]]

Wolfram Language (Mathematica), 106 bytes
(s=Range[#2#];If[#==1,List/@s,SortBy[Select[s~(S=Subsets)~{#},Union[GCD@@@#~S~{2}]=={1}&],Last][[;;#2]]])&

Try it online!

Jelly, 16 bytes
‘×ÆNœcŒcg/€$ÐṂḣ⁸

A dyadic Link accepting n on the left and k on the right.
Try it online!
There must be a better way than this inefficient monstrosity! It'll time out for quite small inputs since it inspects all k-tuples of the natural numbers up to the (n+1)*k-th prime! (The +1 is only needed to handle n=0.)

Python 3, 153 bytes
lambda n,k,R=range:[[*t,r]for r in R(n+k+2)for t in combinations(R(1,r),k-1)if all(sum(x%i<1for x in[*t,r])<2for i in R(2,r))][:n]
from itertools import*

Try it online!
A function that takes n, k as arguments and returns out the list of n co-prime k-tuples.
The tuple are generated with increasing maximum, so it's guaranteed that every co-prime tuple will eventually be printed as n increases.

JavaScript (ES6), 143 bytes
Takes input as (k)(n).
(k,x=0)=>F=n=>n?(g=a=>x>>i?x>>i++&1?a.some(x=>(C=(a,b)=>b?C(b,a%b):a>1)(x,i))?[]:g([...a,i]):g(a):b=a)(i=[],x++).length-k?F(n):[b,...F(n-1)]:[]

Try it online!
Commented
( k,                        // outer function taking k
  x = 0                     // x = bit mask of integers to include in the tuple
) =>                        //
F = n =>                    // F = recursive function taking n
n ?                         // if n is not equal to 0:
  ( g = a =>                //   g is a recursive function taking a[]:
      x >> i ?              //     if x is greater than or equal to 2**i:
        x >> i++ & 1 ?      //       if the i-th bit is set in x:
          a.some(x =>       //         for each value x in a[]:
            ( C = (a, b) => //           C tests whether a and b are coprime:
              b ?           //             if b is not equal to 0:
                C(b, a % b) //               recursive call with (b, a mod b)
              :             //             else:
                a > 1       //               true if *not* coprime
            )(x, i)         //           initial call to C with (x, i)
          ) ?               //         end of some(); if truthy:
            []              //           abort by returning an empty array
          :                 //         else:
            g([...a, i])    //           append i to a[] and call g again
        :                   //       else:
          g(a)              //         just call g with a[] unchanged
      :                     //     else:
        b = a               //       done: return a[] and save it in b[]
  )(i = [], x++)            //   initial call to g with a = [], i = 0; increment x
  .length - k ?             //   if the length of the result is not equal to k:
    F(n)                    //     just call F with n unchanged
  :                         //   else:
    [b, ...F(n - 1)]        //     append b[] to the final result and decrement n
:                           // else:
  []                        //   stop recursion

Charcoal, 58 bytes
ＮθＮη≔⁰ζ⊞υ⟦⟧Ｗ‹ＬΦυ⁼Ｌκθη«≦⊕ζＦΦυ⬤κ⬤…²ζ∨﹪μξ﹪ζξ⊞υ⁺⟦ζ⟧κ»Ｉ…Φυ⁼Ｌιθη

Try it online! Link is to verbose version of code. Explanation:
ＮθＮη

Input k and n.
≔⁰ζ⊞υ⟦⟧

Start the master list with a 0-tuple whose largest number is 0.
Ｗ‹ＬΦυ⁼Ｌκθη«

Repeat until we have at least k n-tuples.
≦⊕ζ

Increment the candidate number.
ＦΦυ⬤κ⬤…²ζ∨﹪μξ﹪ζξ

Filter out all of the existing tuples where at least one member has a common factor with the candidate.
⊞υ⁺⟦ζ⟧κ

Prepend the candidate to each remaining tuple and push all the resulting tuples back to the master list.
»Ｉ…Φυ⁼Ｌιθη

Print the first n k-tuples.