title: Can you spot the liar?

text:
# Question
Title: Can you spot the liar?
It's the end of the year, you and your friends have just received your grades and ranks for the GOLF101 class. On a chat group, everyone sends their grade and rank to see who's got the best one.

**Problem:** someone is lying.

Here is an excerpt from the chat:

```
<A> I'm ranked 1 with a grade of 85.
<B> Ranked 3, got 50.
<C> Ranked 1st, prof. gave me 65/100.
<D> Got ranked second with 70/100

```

Obviously here, student C is lying (at least) on their rank; they can't be 1st with a grade of 65 since both A and D got a better grade.

There can also be cases where someone is lying but we can't know who, specifically.

```
Rank | Grade
-------------
  2     71
  1     80
  3     60
  2     70

```

Here, one of the two rank-2 students is lying (since two students can't have the same rank while having different grades) but we can't know which one.

# Challenge

Create a function or program that, when given a sequence of (rank, grade) tuples which contains exactly one *lie*, returns the index of the *lie* in the list or a sentinel value if is impossible to know.

A *lie* is a tuple that, when removed from the list, makes the list valid (i.e. without any conflicting ranks/grades).

A valid list contains **all the possible ranks starting from 1** (or 0 if you use 0-indexing), so the rank sequence `1 2 3` is valid while `2 3 4` is not. The only way to not have every possible rank is when there are equal grades, in which case you can get sequences like `1 2 2` or `1 2 3 3 3`.

Multiple tuples may have the same grade, in which case they will have the same rank, and other tuples' ranks will not be affected. Two tuples having the second-best grade will lead to the sequence `1 2 2 4 ...`.

The input format is not fixed, you may use whatever is easier to parse for your language (a 2D int array, a list of tuples, a list of strings containing space-separated ints). The logic is more important than the parser's implementation details.

The output format is not fixed either. The "index" returned may be 0-based or 1-based, and the sentinel value can be anything that is clearly distinguishable from an index (if you're using 1-based indexing, 0 is a valid sentinel value).

# Test Cases

```
Rank | Grade
-------------
  2     71
  1     80
  3     60
  2     70

```

**Output**: impossible to know

```
Rank | Grade
-------------
  1     85
  3     50
  1     65
  2     70

```

**Output**: third student

```
Rank | Grade
-------------
  1     85
  3     50
  1     65
  2     70

```

**Output**: third student

Additional cases, thanks to @tsh:

* `[(1, 100), (2, 60), (3, 90), (3, 90)]` -\> invalid input because we can't remove a single item to get a valid list
* `[(1, 100), (1, 100), (2, 90), (3, 90)]` -\> fourth (if we remove the third we get an invalid list with ranks \[1, 1, 3\])

This is , so the lowest byte count for each language wins!

**EDIT:** printing multiple values is a valid sentinel as long as you specify it. 0-indexing for ranks is fine too.

# Answer
# , 49 47 22 bytes

```
[:I.1(-:\:~i.])/@|:\.]

```

Try it online!

-14 bytes after reading xigoi's idea of comparing the first index matches to the ranks.

Thanks to tsh for a test case showing that we needed "length not equal to 1" rather than "length greater than 1" as the failure criterion.

Returns 0-based index if exactly one liar is found, and 0 or multiple values otherwise. Takes "length" by 2 matrix with 0-indexed rank list as left column, score list as right column.

* `1...\.]` For each 1-item outfix (list with item removed), apply the verb...
* `(...)/@|:` Transpose and put the verb in parens between the two rows, so that the rank list is its left arg, and the score list is its right arg.
* `-:\:~i.]` Does the rank list match `-:` the first index of the score list `i.]` within the score list sorted descending `\:~`? We now have a 0-1 list, where 1 indicates a liar.
* `[:I.` Return the indexes of all ones.
> 6 votes

# Answer
# Jelly, 15 bytes

```
ṙJṖZNÞiⱮḷ⁼ʋ/Ɗ€T

```

Try it online!

I'm pretty sure it works correctly with the multiple equal grades rule, but I'd appreciate a testcase for that.

Takes a list of \[grade, rank\]. Returns a 1-indexed list of all possible liars.

## Explanation

```
ṙJṖZNÞiⱮḷ⁼ʋ/Ɗ€T   Main monadic link
ṙ                 Rotate left by
 J                  all of [1..length]
             €    For each rotation
            Ɗ     (
  Ṗ                 Pop (remove the last pair)
   Z                Zip, change to a pair of [grades, ranks]
           /        Reduce by
          ʋ         (
     Þ                Sort the grades by
    N                   their negation
      iⱮḷ             Find the first index of each grade in the reverse-sorted grades
         ⁼            Is this equal to the list of ranks?
          ʋ         )
            Ɗ     )
              T   Find the indices where this is true

```
> 4 votes

---
Tags: code-golf
---


title: Length of a UTF-8 byte sequence

text:
# Question
Title: Length of a UTF-8 byte sequence
Determine the length of a UTF-8 byte sequence given its first byte. The following table shows which ranges map to each possible length:

```
  Range    Length
---------  ------
0x00-0x7F    1
0xC2-0xDF    2
0xE0-0xEF    3
0xF0-0xF4    4

```

Notes on gaps in the table: 0x80-0xBF are continuation bytes, 0xC0-0xC1 would start an overlong, invalid sequence, 0xF5-0xFF would result in a codepoint beyond the Unicode maximum.

Write a program or function that takes the first byte of a UTF-8 byte sequence as input and outputs or returns the length of the sequence. I/O is flexible. For example, the input can be a number, an 8-bit character or a one-character string. You can assume that the first byte is part of a valid sequence and falls into one of the ranges above.

This is code golf. The shortest answer in bytes wins.

## Test cases

```
0x00 => 1
0x41 => 1
0x7F => 1
0xC2 => 2
0xDF => 2
0xE0 => 3
0xEF => 3
0xF0 => 4
0xF4 => 4

```

# Answer
> 6 votes
## Forth, 6 bytes

```
x-size

```

see https://forth-standard.org/standard/xchar/X-SIZE

Input and output follows a standard Forth model:

**Input**

Memory address + length (i.e. 1) of a single-byte UTF-8 "string".

**Output**

UTF-8 sequence length in bytes.

**Sample Code**

Store **0xF0** in a memory cell, and invoke x-size:

```
variable v
0xF0 v !
v 1 x-size

```

Check the result:

```
.s <1> 4  ok

```

# Answer
> 6 votes
# Z80Golf, ~~19~~ 14 bytes

```
00000000: 2f6f 3e10 37ed 6a3d 30fb ee07 c03c       /o>.7.j=0....<

```

Try it online!

-5 bytes thanks to @Bubbler

Example with input 0x41-Try it online! Assembly

Example with input 0xC2-Try it online!

Example with input 0xE0-Try it online!

Example with input 0xF4-Try it online!

Assembly:

```
;input: register a
;output: register a
byte_count:			;calculate 7^(log2(255^a))||1
	cpl			;xor 255
	ld l,a
	log2:
		ld	a,16
		scf
	log2loop:
		adc	hl,hl
		dec	a
		jr	nc,log2loop
	xor 7
	ret nz
	inc a

```

Try it online!

# Answer
> 5 votes
# C (gcc), 39 bytes

```
t(char x){x=(__builtin_clz(~x)-24)%7u;}

```

Try it online!

# Answer
> 4 votes
# Jelly,  ~~8~~  7 bytes

```
+⁹BIITḢ

```

A monadic link accepting the byte as an integer.

**Try it online!** Or see all inputs evaluated.

If an input of a list of the 8 bits were acceptable then the method is only 6 bytes: `1;IITḢ`, however it has been deemed as talking flexible I/O too far.

### How?

```
+⁹BIITḢ - Link: integer       e.g.: 127 (7f)            223 (df)            239 (ef)            244 (f4)
 ⁹      - literal 256
+       - add                       383                 479                 495                 500
  B     - to a list of bits         [1,0,1,1,1,1,1,1,1] [1,1,1,0,1,1,1,1,1] [1,1,1,1,0,1,1,1,1] [1,1,1,1,1,0,1,0,0]
   I    - increments                [-1,1,0,0,0,0,0,0]  [0,0,-1,1,0,0,0,0]  [0,0,0,-1,1,0,0,0]  [0,0,0,0,-1,1,-1,0]
    I   - increments                [2,-1,0,0,0,0,0]    [0,-1,2,-1,0,0,0]   [0,0,-1,2,-1,0,0]   [0,0,0,-1,2,-2,1]
     T  - truthy indices            [1,2]               [2,3,4]             [3,4,5]             [4,5,6,7]
      Ḣ - head                      1                   2                   3                   4

```

# Answer
> 3 votes
# Haskell, 28 bytes

```
f x=sum[1|y<-"Áßï",x>y]+1

```

Try it online!

# Answer
> 3 votes
# Jelly, ~~8~~ 7 bytes

```
»Ø⁷Ba\S

```

Try it online!

### How it works

```
»Ø⁷Ba\S  Main link. Argument: n (integer)

 Ø⁷      Yield 128.
»        Take the maximum of n and 128.
   B     Yield the array of binary digits.
    a\   Cumulatively reduce by AND, replacing 1's after the first 0 with 0's.
      S  Take the sum.

```

# Answer
> 3 votes
# Python 2, 28 bytes

```
lambda x:1.4**(x/16-11)//1+1

```

Try it online!

# Answer
> 2 votes
# JavaScript (Node.js), 24 bytes

```
x=>7^Math.log2(255^x)||1

```

Try it online!

# Answer
> 2 votes
# Ruby, ~~27~~ 23 bytes

```
->x{2+x[7]+(x/16<=>14)}

```

Try it online!

# Answer
> 1 votes
# Charcoal, 12 bytes

```
Ｉ⌕⍘⌈⟦Ｎ¹²⁸⟧²0

```

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

```
     Ｎ          Input number
      ¹²⁸       Literal 128
   ⌈⟦    ⟧      Take the maximum
  ⍘       ²     Convert to base 2 as a string
 ⌕         0    Find the position of the first `0`
Ｉ               Cast to string
                Implicitly print

```

# Answer
> 1 votes
# 05AB1E, ~~8~~ 7 bytes

```
žy‚àb0k

```

Port of *@Neil*'s Charcoal answer.
-1 byte thanks to *@Grimy*.

Input as integer.

Try it online or verify all test cases.

**Explanation:**

```
žy       # Push 128
  ‚      # Pair it with the (implicit) input-integer
   à     # Take the maximum of this pair (128 and input)
    b    # Convert it to a binary-string
     0k  # Get the 0-based first index of a "0" in this binary-string
         # (and output it implicitly as result)

```

# Answer
> 1 votes
# Jelly, 7 bytes

```
»Ø⁷Bi0’

```

Port of my 05AB1E answer.

Try it online or verify all test cases.

**Explanation:**

```
 Ø⁷        # Push 128
»          # Take the max of 128 and the input
   B       # Convert it to binary
    i0     # Get the 1-indexed first index of a 0
      ’    # Decrease it by 1 to make it 0-indexed (and output it implicitly)

```

# Answer
> 1 votes
# Perl 6, 18 bytes

```
{7-msb(255-$_)||1}

```

Try it online!

Port of user202729's JavaScript answer. Alternatives with WhateverCode:

```
(255-*).msb*6%34%7
-(255-*).msb%6%5+1

```

# Answer
> 1 votes
# x86 Assembly, 11 bytes

```
00000000 <f>:
   0:   f6 d1                   not    %cl
   2:   0f bd c1                bsr    %ecx,%eax
   5:   34 07                   xor    $0x7,%al
   7:   75 01                   jne    a <l1>
   9:   40                      inc    %eax
0000000a <l1>:
   a:   c3                      ret

```

Try it online!

Port of user202729's JavaScript answer. Uses fastcall conventions.

# Answer
> 1 votes
# Labyrinth, 35 bytes

```
? @!1 16/ )!@!
:   ";_ _3&""2
_128&

```

Try it online!

Unwrapped version of the code:

```
?:_128&1!@
      ;
      _16/_3&2!@
            )
            !
            @

```

# Answer
> 1 votes
# Labyrinth, 28 bytes

```
1?:_128/}:_224/}_240/{{+++!@

```

Try it online!

Routing is pretty hard and also takes a lot of bytes, so I figured I'd just make a linear program. Basically computes `1 + n/128 + n/224 + n/240`, where `/` is floor division.

# Answer
> 0 votes
# C, 31 bytes

```
f(x){return(x-160>>20-x/16)+2;}

```

Try it online!

### 27 bytes with gcc (-O0)

```
f(x){x=(x-160>>20-x/16)+2;}

```

### Alternatives, 31 and 33 bytes

```
f(x){return(10>>15-x/16)+7>>2;}
f(x){return x/128-(-3>>15-x/16);}

```

I found these expressions when playing around with the Aha! superoptimizer a few years ago.

# Answer
> 0 votes
# Zsh, 42 bytes

```
>$1
eval ';od>><'{,194,224,240}-\>
wc -l<*

```

Try it online!

Input as a decimal integer.

---
Tags: code-golf, integer
---


title: Elias omega coding: decoding

text:
# Question
Title: Elias omega coding: decoding
Related: Elias omega coding: encoding

## Background

**Elias omega coding** is a universal code which can encode positive integers of any size into a stream of bits.

Given a stream of bits \\$S\\$, the decoding algorithm is as follows:

1. If \\$S\\$ is empty, stop. Otherwise, let \\$N=1\\$.
2. Read the next bit \\$b\\$ of \\$S\\$.
3. If \\$b=0\\$, output \\$N\\$ and return to step 1.
4. Otherwise, \\$b=1\\$. Read \\$N\\$ more bits from \\$S\\$, append to \\$b\\$, and convert it from binary to integer. This is the new value of \\$N\\$. Go back to step 2.

In Python-like pseudocode:

```
s = input()
while s.has_next():
    n = 1
    while (b = s.next()) == 1:
        loop n times:
            b = b * 2 + s.next()
        n = b
    output(n)

```

## Illustration

If the given bit stream is `101001010100`:

1. Initially \\$N = 1\\$.
2. Since the first bit is 1, we read 1 more bit (2 bits in total) to get the new value of \\$N = 10\_2 = 2\\$. Now the stream is `1001010100`.
3. Proceed as the same. Read a bit (1) and \\$N = 2\\$ more bits to get \\$N = 100\_2 = 4\\$. Stream: `1010100`
4. Read a bit (1) and \\$N = 4\\$ more bits to get \\$N = 10101\_2 = 21\\$. Stream: `00`
5. Read a bit (0). Since it is 0, output the current \\$N = 21\\$. The stream has more bits to be consumed, so we reset to \\$N=1\\$ and continue. Stream: `0`
6. Read a bit (0). Output the current \\$N = 1\\$. The stream is empty, and decoding is complete.

The output for the input stream `101001010100` is `[21, 1]`.

## Task

Given a stream of bits which consists of zero or more Elias omega coded integers, decode into the original list of integers. You can assume the input is valid (the input stream won't be exhausted in the middle of decoding a number).

Shortest code in bytes wins.

## Test cases

```
Input => Output
(empty) => []
0       => [1]
00      => [1,1]
00100   => [1,1,2]
101001010100 => [21,1]
1110000111100001110000 => [8,12,1,8]
1111000111000101011001011110011010100001010 => [12,345,6789]

```

# Answer
# convey, 66 bytes

```
1<<<<,<<
/>>>v$1^
,<"<##<^
:`#?@#^^
{1$v>"}%2
  ~,>/+?<
  3 0$,>*2

```

Try it online!

Explanation will follow after I tried some other orientations …
> 9 votes

# Answer
# Charcoal, 32 bytes

```
≔⪪⮌Ｓ¹θ⊞υ¹Ｗθ⊞υ∨⁼0⊟θ⍘⁺1⭆⊟υ⊟θ²Ｉ∧⊟υυ

```

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

```
≔⪪⮌Ｓ¹θ

```

Input the bits and split them into single characters.

```
⊞υ¹

```

Start with `N=1`.

```
Ｗθ

```

Repeat until the bits are exhausted.

```
⊞υ∨⁼0⊟θ⍘⁺1⭆⊟υ⊟θ²

```

If the next bit is a `0` then push a `1` otherwise pop the current value to see how many more bits to extract and convert to base 2 and push that instead.

```
Ｉ∧⊟υυ

```

Print all of the numbers except the last one (which should be a `1` we pushed when we hit the last `0`).
> 4 votes

# Answer
# , ~~108~~ ~~98~~ 95 bytes

```
function(x)while(length(x)){n=1
while({b=x[0:n+1];x=x[0:(-n*b)-1];b})n=sum(b*2^(n:0))
print(n)}

```

Try it online!

This could still be shortened by 3 more bytes (like this) by modifying `sum(b*2^(n:0))` to instead use the inner product operator `b%*%2^(n:0)`, but this gives rather unsatisfying output that mixes 1-element vectors with 1x1 matrices...
> 3 votes

# Answer
# JavaScript (ES6), 57 bytes

*4 bytes saved by @tsh*

Expects a list of `0`'s and `1`'s.

```
a=>a.map(b=>r=a--?r*2+b:(a=b?r:!o.push(r),1),r=1,o=[])&&o

```

Try it online!

---

# JavaScript (ES6), 61 bytes

Expects a list of `0`'s and `1`'s.

```
a=>a.map(b=>r=n--?r|b<<n:1<<(n=b?r:!o.push(r)),r=1,n=o=[])&&o

```

Try it online!

### Commented

```
a =>                   // a[] = array of bits
a.map(b =>             // for each bit b in a[]:
  r =                  //   update r:
    n-- ?              //     if n is not equal to 0 (decrement it afterwards):
      r | b << n       //       set the n-th bit of r to b
    :                  //     else:
      1 << (           //       this expression evaluates to either 1 << r or 1
        n =            //         update n:
          b ?          //           if b is set:
            r          //             set n to r and set r to 1 << r
          :            //           else:
            !o.push(r) //             push r into o[], set n to 0 and set r to 1
      ),               //
                       //   start with:
  r = 1,               //     r = 1,
  n =                  //     n zero'ish
  o = []               //     o[] = empty array
)                      // end of map()
&& o                   // return o[]

```
> 2 votes

# Answer
# Stax, 17 bytes

```
àkÑ╣±╫¬ò^Ü▌}├n╒/ñ

```

Run and debug it

Input as an array of bits.

An almost direct translation of the reference implementation.

## Explanation

```
W|cO{B|csa%aa+:bsWsP
W|c                  while S is truthy:
   O                 push a 1 under it (N)
    {            W   loop forever
                     stack: [N,S]
     B               pop first bit from S and push it
                     stack: [N,S,b]
      |c             break if it's falsy
        s            swap
         a%          split the list at index N
           aa+       prepend b to the first part
              :b     convert from binary
                s    swap for the next iteration
                  sP print N after the loop ends

```
> 2 votes

# Answer
# PowerShell, 78 bytes

```
for($s=$args;""+$s[+$x]){for($n=1;$b=$s[$x++]){1..$n|%{$n=$b+=$b+$s[$x++]}}$n}

```

Try it online!
> 2 votes

# Answer
# Retina 0.8.2, 82 bytes

```
^
_¶
{`¶0(.*)$
¶_¶$1
(_)+¶(1(?<-1>.)+)(.*)$
$2¶$3
1(?=.*¶)
0_
}+`_0
0__
%M`_
1¶0$

```

Try it online! Link includes test cases. Explanation:

```
^
_¶

```

Set `N=1` (in unary).

```
{`
}`

```

Repeat until the bits are exhausted.

```
¶0(.*)$
¶_¶$1

```

If the next bit is a `0` then start a new output value of `1`.

```
(_)+¶(1(?<-1>.)+)(.*)$
$2¶$3

```

But if the next bit is a `1` then extract the next `N` bits.

```
1(?=.*¶)
0_
_0
0__

```

Convert them from binary to unary. (There are 0s left over, but we don't care about them.)

```
%M`_

```

Convert all of the output values from unary to decimal.

```
1¶0$

```

Remove the last two values; the `1` is from the `1` that begins the new output value, while the `0` is from the (now empty) input. (This has to be done here so that the case of an empty input works.)
> 1 votes

# Answer
# Racket, 146 bytes

```
(define(f s[n 1][a'()])(if(null? s)(reverse a)(if(=(car s)0)(f(cdr s)1(cons
n a))(f(drop s(+ n 1))(foldl(λ(a b)(+(* 2 b)a))0(take s(+ n 1)))a))))

```

Try it online!
> 1 votes

# Answer
# Perl 5 (`-l061n`), 49 bytes

```
1while s/^0//?$\=say$\:s/^1.{$\}//?$\=oct"0b$&":0

```

Try it online!
> 1 votes

# Answer
# PowerShell, ~~75~~ ~~73~~ 70 bytes

Finite-state machine, where `$b` is a current state {0, 1, other}.

Inspired by Zaelin Goodman

```
$args|%{if(!($b=2*$b+"$_")){$n+1;$n=1}if($b-1-and!$n--){$n=$b-1;$b=0}}

```

Try it online!
> 1 votes

# Answer
# Wolfram Language (Mathematica), 62 bytes

```
Last@Reap@Fold[If[--n<1,n=1+If[#2<1,0Sow@#,#];1,##+#]&,n=1,#]&

```

Try it online!
> 0 votes

---
Tags: code-golf, binary, encoding
---


# Question
Title: Calculate an integer sequence derived from prime factors
Create a function, expression, or program which does the following:

1. Take the prime factors of any number and sum them. For example, the prime factors of 28 are 2 2 7, summed to 11.
2. Multiply the result by the number of prime factors for the given number. E.g, 28 has 3 prime factors which sum to 11. 11 * 3 is 33.
3. Repeat the process recursively, storing the resulting list (which starts with the original number), until you reach a number that is already included in the list. Halt without adding that final number, so that the list contains no duplicates. The progression for 28 is 28 33, because 33 results in 28 again.
4. Count the elements in the resulting list. In the case of 28, the answer is 2.

Here are the results for `0<n<=10`, so you can check your algorithm.

`2 1 1 10 1 11 1 9 5 10`

(As balpha pointed out, the answer for `higley(1)` is 2, from the list 1 0. I originally had 1, due to a bug in my original algorithm written in J.)

Since I'm a conceited SOB and haven't found this on OEIS, let's call this the "Higley Sequence," at least for the duration of this round of code golf. As an added bonus, find the first two `n` having the lowest `higley(n)` where `n` is not prime and `n>1`. (I think there are only two, but I can't prove it.)

This is standard code golf, so as usual the fewest keystrokes win, but I ask that you please upvote clever answers in other languages, even if they are verbose.

# Answer
> 6 votes
# J, 47 45

```
#@((~.@,[:(+/@{:*+/@:*/)2 p:{:)^:_)`2:@.(=&1)

```

It's possible this would be much shorter without using `^:_`, but my brain is sufficiently fried already.

**Edit:** (47-\>45) Double coupon day.

Usage:

```
   higley =: #@((~.@,(+/@{:*+/@:*/)@(2&p:)@{:)^:_)`2:@.(=&1)
   higley 1
2
   higley"0 (1 + i. 10)
2 1 1 10 1 11 1 9 5 10

```

# Answer
> 5 votes
### Golfscript, 68 67 62 61 chars

```
[.]({[.2@{1$1$%{)}{\1$/1$}if}*;;].,*0+{+}*.2$?@@.@+\@)!}do;,(

```

This is an expression: it takes `n` on the stack and leaves the result on the stack. To turn it into a program which takes `n` from stdin and prints the result to stdout, replace the leading `[` with `~`

The heart of it is `[.2@{1$1$%{)}{\1$/1$}if}*;;]` (28 chars) which takes the top number on the stack and (by an incredibly inefficient algorithm) generates a list of its prime factors. C-style pseudocode equivalent:

```
ps = [], p = 2;
for (int i = 0; i < n; i++) {
    if (n % p == 0) {
        ps += p;
        n /= p;
    }
    else p++;
}

```

The `0+` just before `{+}*` is to handle the special case `n==1`, because Golfscript doesn't like folding a binary operation over the empty list.

One of the non-prime fixpoints is 27; I found this without using the program by considering the mapping (pa `->` a2p), which is a fixpoint if a == p(a-1)/2, and trying small `a`. (`a==1` gives the fixpointedness of primes).

Searching with the program turns up a second fixpoint: 30 = (2+3+5)\*3

---

### Appendix: proof that there are only two non-prime fixpoints

Notation: `sopfr(x)` is the sum of prime factors of `x`, with repetition (A001414). `Omega(x)` is the number of prime factors of `x` (A001222). So the Higley successor function is `h(x) = sopfr(x) Omega(x)`

Suppose we have a fixpoint `N = h(N)` which is a product of `n=Omega(N)` primes.

`N = p_0 ... p_{n-1} = h(N) = n (p_0 + ... + p_{n-1})`

Basic number theory: `n` divides into `p_0 ... p_{n-1}`, so `w=Omega(n)` of those primes are the prime factors of `n`. Wlog we'll take them to be the last `w`. So we can divide both sides by `n` and get

`p_0 ... p_{n-w-1} = p_0 + ... + p_{n-1}`

or

`p_0 ... p_{n-w-1} = p_0 + ... + p_{n-w-1} + sopfr(n)`

Given that all of the primes `p_0` to `p_{n-w-1}` are greater than 1, increasing any of them increases the LHS more than the RHS. So for a given `n`, we can enumerate all candidate solutions.

In particular, there can be no solutions if the LHS is greater than the RHS setting all the "free" primes to 2. I.e. there are no solutions if

`2^{n-w} > 2 (n-w) + sopfr(n)`

Since `sopfr(n) <= n` (with equality only for n=4 or n prime), we can make the weaker statement that there are no fixpoints if

`2^{n-w} > 3 n - 2 w`

Holding `w` fixed we can select different values of `n` satisfying `w=Omega(n)`. The smallest such `n` is `2^w`. Note that if `2^{n-w}` is at least 3 (i.e. if `n-w>1`, which is true if `n>2`) then increasing `n` while holding `w` constant will increase the LHS more than the RHS. Note also that for `w>2` and taking the smallest possible `n` the inequality is satisfied, and there are no fixpoints.

That leaves us with three cases: `w = 0` and `n = 1`; `w = 1` and `n` is prime; or `w = 2` and `n` is semi-prime.

Case `w = 0`. `n = 1`, so `N` is any prime.

Case `w = 1`. If `n = 2` then `N = 2p` and we require `p = p + 2`, which has no solutions. If `n = 3` then we have `pq = p + q + 3` and two solutions, `(p=2, q=5)` and `(p=3, q=3)`. If `n = 5` then `2^4 > 3 * 5 - 2 * 1`, so there are no further solutions with `w = 1`.

Case `w = 2`. If `n = 4` then `N = 4pq` and we require `pq = p + q + 4`. This has integer solution `p=2, q=6`, but no prime solutions. If `n = 6` then `2^4 > 3 * 6 - 2 * 2`, so there are no further solutions with `w = 2`.

All cases are exhausted, so the only non-prime fixpoints are 27 and 30.

# Answer
> 4 votes
## Ruby, 92 characters

```
f=->i{r=[i];(x=s=0;(2..i).map{|j|(s+=j;x+=1;i/=j)while i%j<1};r<<i=s*x)until r.uniq!;r.size}

```

This solution assumes higley(1) is actually 2, not 1 (see balpha's comment above):

```
(1..10).map &f
=> [2, 1, 1, 10, 1, 11, 1, 9, 5, 10]

```

# Answer
> 2 votes
## Octave - 109 chars

```
l=[input('')];while size_equal(unique(l),l);n=factor(l(1));l=[sum(n)*length(n) l];endwhile;disp(length(l)-1);

```

# Answer
> 2 votes
# Husk, 9 bytes

```
LU¡o§*LΣp

```

Try it online! or Verify first 10 tests

## Explanation

```
LU¡o§*LΣp input → n
  ¡o      create an infinite list:
        p get the prime factors
      L   length
    §*    times
       Σ  sum
 U        longest unique prefix of the infinite list
L         length of the prefix

```

# Answer
> 2 votes
# Jelly, 9 bytes

```
ÆfS×LƊ$ƬL

```

Try it online!

## Explanation

```
ÆfS×LƊ$ƬL   Main monadic link
       Ƭ    Repeat and collect results until a duplicate occurs
      $     (
Æf            Prime factorization
     Ɗ        (
  S             Sum
   ×            Multiplied by
    L           Length
     Ɗ        )
      $     )
        L   Length

```

# Answer
> 1 votes
# MATL, 19 bytes

```
i`vt0)Yftnws*yy-]xn

```

Try it online!

# Answer
> 1 votes
# Pyth, 10 bytes

```
l.u*sJPNlJ

```

Try it online!

---

Explanation:

```
 .u       Q | N = input, then N =
    s       |  sum of
      PN    |   list of prime factors of N
     J      |   (call this list J)
   *        |  times
        lJ  |  length of J
 .u         | until a previous result is repeated. return the list of results
l           | print the length of the list

```

---
Tags: code-golf, math
---


title: Print om sign with pi

text:
# Question
Title: Print om sign with pi
This time I will give you an easy challenge:
Print the Om sign with \\$\pi\\$!(Sorry for many challenges with \\$\pi\\$)

Here is the om sign drawn using pi numbers:

```
            59  0  64
              230781
3.14159
      26      502884
     535 83279     1971
   89 433              6939
       79    44         937
       323    749     510
    84            58209
626

```

### Here is the sequence I used to order the numbers of \\$\pi\\$:

# Rules

* There will be no input(except it has to be)
* The program should print the sign to STDOUT
* Its's , so the shortest code in bytes wins!
* You must include all the spaces and line breaks in the original text.

Good luck

# Answer
# 05AB1E, 91 bytes

```
•Eó£ƵZ₃|ã
xWм7qèý`ÚA¿нÏ9,ÖcPÇŸ›ÎŸt¤,,ûUÅ¨ù—¤ï`ÿ¾ζ@η@••7¼P•в•pÏ{ʒÂfĆ¨¿ZF•15вú•DŠ\•4в£»31DT/:

```

Try it online.

**Explanation:**

```
•Eó£ƵZ₃|ã
xWм7qèý`ÚA¿нÏ9,ÖcPÇŸ›ÎŸt¤,,ûUÅ¨ù—¤ï`ÿ¾ζ@η@•
                 # Push compressed integer 31746388586852694571167828992290814184914816000404856451284780420784056983357043462437313025051647834765116670748406087616
 •7¼P•           # Push compressed integer 502885
      в          # Convert the larger integer to base-502885 as list:
                 #  [59,0,64,230781,314159,26,502884,535,83279,1971,89,433,6939,79,44,937,323,749,510,84,58209,626]
•pÏ{ʒÂfĆ¨¿ZF•    # Push compressed integer 60230047425392376760356855
             15в # Convert it to base-15 as list:
                 #  [12,1,1,14,0,6,5,5,0,4,3,0,13,7,3,8,7,3,4,4,11,0]
ú                # Pad the integers in the first list with leading spaces,
                 # where the amount of spaces is that of the second list at the same indices:
                 #  ["            59"," 0"," 64","              230781","314159","      26","     502884","     535","83279","    1971","   89","433","             6939","       79","   44","        937","       323","   749","    510","    84","           58209","626"]
•DŠ\•            # Push compressed integer 880633
     4в          # Convert it to base-4 as list: [3,1,1,2,3,3,3,3,2,1]
       £         # Split the list of strings into parts of that size:
                 #  [["            59"," 0"," 64"],["              230781"],["314159"],["      26","     502884"],["     535","83279","    1971"],["   89","433","             6939"],["       79","   44","        937"],["       323","   749","    510"],["    84","           58209"],["626"]]
        »        # Join each inner list by spaces, and then each string by newlines
31               # Push 31
  D              # Duplicate it
   T/            # Divide the copy by 10: 3.1
     :           # Replace the "31" with "3.1" in the string
                 # (after which the result is output implicitly)

```

Note that all the leading spaces (except for the first integers in the line) are decreased by 1 because the `»` joins by spaces.

See this 05AB1E tip of mine (section *How to compress large integers?* and *How to compress integer lists?*) to understand how the compressed parts works.

---

Since I was curious, I also made a program using the actual PI-digits and drawing them in the specified pattern one by one using the Canvas builtin `Λ`. Which surprisingly enough is not that much larger (**97 bytes**):

```
2žs•3]]\´ë:O•23в£J•ΘüÁи‘•11в0šúS•2q₄BeçqÌÂ§ßI/ÖÅ?¨L×Σ₃ÛuÌÎvêmtTYx¡n‡¢lΛf4ÙI₁¿çÑv•9в.Λ46Â:„ 4„3..;

```

Try it online.

**Explanation:**

```
2            # Push a 2
žs           # Push an infinite list of PI digits: [3,1,4,1,5,...]
  •3]]\´ë:O• # Push compressed integer 243177533433411924
   23в       # Convert it to base-23 as list: [11,2,5,2,3,22,3,3,5,3,2,10,1]
      £      # Split the PI-digits into parts of that size
       J     # Join each inner list of digits together:
             #  [31415926535,89,79323,84,626,4338327950288419716939,937,510,58209,749,44,5923078164,0]
•ΘüÁи‘•      # Push compressed integer 342434478685
 11в         # Convert it to base-11 as list: [1,2,2,2,5,3,3,7,7,1,10,2]
    0š       # Prepend a 0: [0,1,2,2,2,5,3,3,7,7,1,10,2]
      ú      # Pad the strings with that many leading spaces to the integers:
             #  ["31415926535"," 89","  79323","  84","  626","     4338327950288419716939","   937","   510","       58209","       749"," 44","          5923078164","  0"]
       S     # And convert it to a flattened list of characters
•2q₄BeçqÌÂ§ßI/ÖÅ?¨L×Σ₃ÛuÌÎvêmtTYx¡n‡¢lΛf4ÙI₁¿çÑv•
             # Push compressed integer 1107440116348129217561550864085059321059233554362962027078200378907904337318203317830295973758995759889862300097
 9в          # Convert it to base-9 as list:
             #  [2,2,2,2,2,4,2,4,6,6,6,5,2,2,3,2,2,3,6,6,6,6,5,2,5,6,6,6,6,1,1,1,2,1,2,2,2,1,2,2,2,2,1,2,2,2,2,2,4,2,2,2,3,2,2,2,5,6,6,2,2,2,5,6,6,6,2,2,5,6,6,6,6,6,2,6,2,2,2,2,7,6,6,6,6,6,6,6,2,2,7,6,6,8,1,1,2,2,2,2,2,2,2,2,2,2,3,2,2,2,2,2,1,6,6,6,6]
.Λ           # Use the Canvas builtin with these three lists, where
             # - the 2 is the length of each line
             # - the list ["3","1","4",...," "," ","0"] are the characters to draw
             # - the list [2,2,2,...,6,6,6] are the directions
  46         # Push 46
    Â        # Bifurcate it (short for Duplicate & Reverse copy): 64
     :       # Replace the 46 with 64 in the string
  „ 4„3..;   # Replace the first " 4" with "3."
             # (after which the result is output implicitly)

```

See this 05AB1E tip of mine (section *How to compress large integers?* and *How to compress integer lists?*) to understand how the compressed parts works.

So we use the following options for the Canvas builtin:

* \\$a\\$ length: `2` (all lines are of size 2; or basically 1 since they're overlapping previous lines)
* \\$b\\$ the characters we want to display, which are the digits of PI with the spaces we added to travel around
* \\$c\\$ the directions, where `8` is a reset to the origin where we started, and the other directions are:

```
7   0   1
  ↖ ↑ ↗
6 ← X → 2
  ↙ ↓ ↘
5   4   3

```

Here some of the first steps:

```
char: 3; direction: 2→
3

char: 1; direction: 2→
31

char: 4; direction: 2→
314

char: 1; direction: 2→
3141

char: 5; direction: 2→
31415

char: 9; direction: 2→
314159

char: 2; direction: 4↓
314159
     2

char: 6; direction: 2→
314159
     26

char: 5; direction: 4↓
314159
     26
      5

char: 3; direction: 6←
314159
     26
     35

char: 5; direction: 6←
314159
     26
    535

char: space; direction: 6←
314159
     26
    535

char: 8; direction: 5↙
314159
     26
    535
  8

char: 9; direction: 2→
314159
     26
    535
  89

etc.

```

Also note how I take advantage of the palindromized part `535` here so I'm able to draw those digits backwards. With most other digit-substrings I have to first go to the correct position with spaces before drawing the actual digits in direction `2→`.
I use this same palindroized approach also for the digit-substrings `323` and `626`.

The reason the first `3` of the PI-digits is replaced with a `4` is because we use a length of 2 (since lines are overlapping), which causes a minor issue in this case when we reset to the origin location with 'direction' `8`. Since we had to insert the dot anyway this doesn't really matter too much.
The `46` to `64` is because we couldn't move around to the next section with spaces like we did with all the other digits for the final `0`, since it's encapsulated inside other digits and we can't reach it.

See this 05AB1E tip of mine for an in-depth explanation of how the Canvas builtin works.
> 5 votes

# Answer
# JavaScript (ES8),  ~~156 152~~  151 bytes

```
_=>`Qk2 SH
2755Q
1C.4USW
Bq4SGG6
6LxSK4xOC5
13n5Ch2DOE
ZbJoBKP
3Zr990 6AS
11gJYN0
7Q8`.replace(/[0-Z]+\w?/g,s=>''.padEnd((n=parseInt(s,36))%16)+(n>>4))

```

Try it online!

### How?

A group of \\$k\\$ spaces followed by a number \\$N\\$ is encoded as \\$16N+k\\$ in base 36 and upper case.

*Example:*

```
"            59" -> 16 * 59 + 12 = 956 -> "QK"

```

The following rules apply to separate a string from the next one:

* If it's followed by a line-feed or a period, we leave it as-is.
* If it ends with a letter, we put it in lower case.
* Otherwise, we use one of the spaces that should have been encoded in the next group as a separator.

As a result, all strings can be unambiguously matched with `/[0-Z]+\w?/`.
> 2 votes

# Answer
# 05AB1E, 111 bytes

```
•DIÿ₅εïΩǝ>Î*.}Öδµ¼ËüúMeĀ¡ζ¿†)в¡Óa×CÁØÒвÕï#â’“¡TÞm×a¿ǝ¬=ß/L@&„@’…ë¼ïæW5éÓ#c∞ðbΣh¬Á‚q”›?иøç,G$X•12B'§Åu„
‡31DT/:

```

Try it online!

```
•...•12B'§Åu„ \n‡31DT/:  # trimmed program
                      :  # replace...
                 31      # literal...
                      :  # with...
                 31      # literal...
                   D /   # divided by...
                    T    # 10...
                      :  # in...
                ‡        # replaced each character of...
        '§Å              # "ab"...
           u             # in uppercase...
                ‡        # with corresponding character of...
            „ \n         # literal (\n is newline)...
                ‡        # in...
•...•                    # 12929493392715033775373083693785395621840635578238991913835355382477224495770768407855388223047936086665789536281935915002520324655471900188866985320315060383798192979161318650352714212687144153060399193782953565620356798...
       B                 # converted to base...
     12                  # literal
                         # implicit output

```
> 2 votes

# Answer
# ///, 147 bytes

```
/a/    //b/     5/a   b9  0  64
aaa  230781
3.14159
a  26 b02884
b35 83279a 1971
   89 433aaa  6939
a   79a44aa 937
a   323a749b10
a84a   b8209
626

```

Try it online!
> 1 votes

# Answer
# Perl \+ `-p`, 117 bytes

This program contains unprintables so the TIO link is to a Bash program that loads the program from a reversible hex dump.

```
}{s//
     u0z
Q0�1
3.HI9
TlV�
o5�U9M�
�e3a
�f	�7
Z3�9m0
�
  tN9
x6/;s/[^\d
.]/15>($x=ord$&)?$"x$x:$x-58/ge

```

Try it online!

This was generated using the following program which uses RLE for spaces and stores runs of digits as bytes where possible.
> 1 votes

# Answer
# Retina 0.8.2, 122 bytes

```

l59b0b64¶n230781¶3.14159¶f26f502884¶e535a83279e1971¶c89a433n6939¶g79d44i937¶g323d749e510¶d84l58209¶626
{`[a-z]
 $&
T`l`_l

```

Try it online! Uses letters to run-length encode spaces. (The `a`s could be spaces but I couldn't be bothered to special-case them in the encoder.)
> 1 votes

# Answer
# Deadfish~, 842 bytes

```
{i}cc{i}{i}ii{c}cc{i}{i}iciiiic{d}{d}dddddcc{i}iiiiiic{d}ddddddcc{i}{i}iicddc{{d}iiiiii}ddc{i}{i}ii{c}cccc{i}{i}ddcicdddc{i}dddcic{d}iiic{{d}iiiiii}ic{{i}dddddd}icdddddciiiciiicdddciiiiciiiic{{d}iiiii}iiic{i}{i}iicccccc{i}{i}ddciiiic{d}{d}ddcccccc{i}{i}icdddddciiciiiiiiccddddc{{d}iiiiii}ddc{i}{i}iiccccc{i}{i}icddciic{d}{d}dc{i}{i}iiiicdddddcdciiiiiciic{d}{d}dddddccccc{i}{i}dddc{i}ddcddcddddddc{{d}iiiiii}ic{i}{i}iiccc{i}{i}iiiicic{d}{d}dddddc{i}{i}cdcc{d}{d}i{c}cccc{i}{i}iiciiicddddddciiiiiic{{d}iiiii}iiic{i}{i}iiccccccc{i}{i}iiiciic{d}{d}dddddcccc{i}{i}cc{d}{d}ccccccccc{i}{i}iiiiicddddddciiiic{{d}iiiiii}dddddc{i}{i}iiccccccc{i}{i}dcdcic{d}{d}icccc{i}{i}iiicdddciiiiic{d}{d}dddddccccc{i}{i}icddddcdc{{d}iiiiii}iic{i}{i}iicccc{i}{i}iiiicddddc{d}{d}{c}cc{i}{i}iciiicddddddcddc{i}dc{{d}iiiii}iiic{{i}dddddd}iiiicddddciiiic{{d}iiiiii}ddddc

```

Try it online!

The longest answer so far, and proud of it.
> 1 votes

---
Tags: code-golf, kolmogorov-complexity, pi
---


title: Pascal's tree-angle

text:
# Question
Title: Pascal's tree-angle
Print this tree:

```
           1
         1 2 1
        1 3 3 1
       1 4 6 4 1
     1 5 10 10 5 1
        15 20 15
    7 21 35 35 21 7
   8 28 56 70 56 28 8
9 36 84 126 126 84 36 9
          252
        462 462
          924
       1716 1716

```

This is , so shortest code in chars wins!

# Answer
> 7 votes
# , 67 bytes

```
(1785951#:~13#7)(0(,~' '#~12-<.@-:@#)@":-@[}.}.)&>1;2}.<@(!{:)\i.14

```

The pascal's triangle part is adapted from @ephemient's answer here.

Try it online!

### How it works

```
<@(!{:)\i.14

```

The first 14 rows of the triangle.

```
1;2}.

```

Drop the first two rows, prepend 1.

```
(1785951#:~13#7)

```

`0 0 0 0 0 2 1 1 1 5 5 6 6` stored in base 7.

```
":-@[}.}.)&>1

```

Unbox, drop the first N and last N elements from each row, where N is the corresponding item from the base 7 array before.

```
0(…)@":

```

Convert each row to string and …

```
12-<.@-:@#

```

Count its length, halve and round it down.

```
,~' '#~

```

Prepend that amount of spaces before each row.

# Answer
> 6 votes
# Python 2, 118 bytes

```
n=1
exec"a=n/6+n/10*4+(n==6);print' '.join(str(((2**n+1)**n>>n*k)%2**n)for k in range(a,n+1%n-a)).center(23);n+=1;"*13

```

Try it online!

Expresses binomial coefficients inline like in my tip here with `binom(n,k)=((2**n+1)**n>>n*k)%2**n`. The number of entries cut off on each side for the n'th row (one-indexed) is expressed as `n/6+n/10*4+(n==6)`. For the first row, one additional entry on the right is cut off.

Here's a slightly more readable version without an exec so that the syntax highlighting works:

**119 bytes**

```
n=1
while n<14:a=n/6+n/10*4+(n==6);print' '.join(str(((2**n+1)**n>>n*k)%2**n)for k in range(a,n+1%n-a)).center(23);n+=1

```

Try it online!

# Answer
> 4 votes
# 05AB1E, 26 bytes

```
13LεDÝc•6hö¢ðU•RNèF¦¨]»¦.c

```

Try it online.

**Explanation:**

```
13L            # Push a list in the range [1,13]
   ε           # Map each value `y` to:
    D          #  Duplicate the value `y`
     Ý         #  Pop and push a list in the range [0,`y`]
      c        #  Take the binomial coefficient of `y` with each value in this list
               #  (we now have the 0-based `y`'th Pascal row)
    •6hö¢ðU•   #  Push compressed integer 6655111200000
            R  #  Reverse it to "0000021115566"
    Nè         #  Index the map-index into it to get the `N`'th digit
      F        #  Loop that many times:
       ¦¨      #   Remove both the first and last item of the current Pascal row list
   ]           # Close both the inner loop and map
    »          # Join each inner list by spaces, and then each string by newlines
     ¦         # Remove the leading 1 on the very first line
      .c       # Left-focused centralize the newline-delimited string
               # (after which the result is output implicitly)

```

See this 05AB1E tip of mine (section *How to compress large integers?*) to understand why `•6hö¢ðU•` is `6655111200000`.

# Answer
> 3 votes
# JavaScript (ES8), 137 bytes

```
_=>[a=[1],..."000021115566"].map((v,n)=>(s=(a=[i=1,...a.map(v=>v+~~a[i++])]).slice(v,n+2+!n-v).join` `).padStart(23+s.length>>1)).join`
`

```

Try it online!

# Answer
> 3 votes
# Charcoal, 57 bytes

```
Ｆ³⊞υ﹪ι²Ｆ”)⧴→↨w﹪f”«ＵＭυ⁺κ§υ⊖λ⊞υ⁰Ｆ›ⅉ⁰≔⪫✂υＩι±Ｉι¹ ι⟦⁺× ⊘⁻²⁴Ｌιι

```

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

```
Ｆ³⊞υ﹪ι²

```

Start by preparing a list `0 1 0`. (Charcoal's indexing is cyclic, so rather than letting it wrap I need to provide a safety margin.)

```
Ｆ”)⧴→↨w﹪f”«

```

Loop over the compressed string `111113222667` which represents the number of entries to slice off each side (except on the first iteration).

```
ＵＭυ⁺κ§υ⊖λ

```

Add each element to the next element (so the first element remains `0`).

```
⊞υ⁰

```

Append another `0` to the end. (This is done here so that it can be easily sliced off again.)

```
Ｆ›ⅉ⁰≔⪫✂υＩι±Ｉι¹ ι

```

Except on the first loop, slice off the given number of entries from the start and the end (this has to be nonzero to work, which is why we already pushed the `0` only to slice it off again, and also why we have an extra `0` at the start, which otherwise wouldn't be necessary). On the first loop, the `1` just ends up being the output string.

```
⟦⁺× ⊘⁻²⁴Ｌιι

```

Centre the string in a width of 24 (23 would round the sixth and eighth lines down which is not what we want) and output each string on its own line.

# Answer
> 3 votes
# ///, 196 bytes

```
/h/ 3//g/ 2//f/ 1//e/aa//d/
a//c/  //b/ea//a/c /bc1bc
b1gfbdac1hhfecdaf 4 6 4fe dc1 5f0f0 5facdac15g0f5e d 7g1h5h5g1 7a d8g8 56 70 56g8 8c
9h6 84f26f26 84h6 9
bg52b dac462 462ec
b 924b daf716f716e

```

Try it online!

# Answer
> 2 votes
# Ruby, 91 bytes

```
66551112000090.digits.map{|i|n=0;$*.map!{|j|n+n=j}<<1;puts ($*[i..~i]*' ').center 23if i<9}

```

Try it online!

Iterates over the digits of `66551112000090` (from the right), one digit for each row of the tree. Each digit, with the exception of the `9`, specifies the number of elements to be omitted from the beginning and end of the corresponding row of Pascal's triangle. The `9` is a distinct digit used to suppress printing of the second row of the triangle.

The Pascal's triangle code is based on this answer by @manatwork, golfed further by abusing the predefined array `$*`. `$*` normally stores the list of command-line options. Since we use no command-line options, `$*` is initialised to the empty array.

# Answer
> 1 votes
# Deadfish~, 1398 bytes

```
{i}{i}{i}ii{c}c{i}{i}dddc{d}{d}iii{c}c{d}{d}ddc{i}{i}iiccccccccc{i}{i}dddc{d}{d}iiic{i}{i}ddc{d}{d}iic{i}{i}dddc{d}{d}iiiccccccccc{d}{d}ddc{i}{i}iicccccccc{i}{i}dddc{d}{d}iiic{i}{i}dc{d}{d}ic{i}{i}dc{d}{d}ic{i}{i}dddc{d}{d}iiicccccccc{d}{d}ddc{i}{i}iiccccccc{i}{i}dddc{d}{d}iiic{i}{i}c{d}{d}c{i}{i}iic{d}{d}ddc{i}{i}c{d}{d}c{i}{i}dddc{d}{d}iiiccccccc{d}{d}ddc{i}{i}iiccccc{i}{i}dddc{d}{d}iiic{i}{i}ic{d}{d}dc{i}{i}dddcdc{d}ddddddc{i}{i}dddcdc{d}ddddddc{i}{i}ic{d}{d}dc{i}{i}dddc{d}{d}iiiccccc{d}{d}ddc{i}{i}iicccccccc{i}{i}dddciiiic{d}{d}dc{i}{i}ddcddc{d}ddddddc{i}{i}dddciiiic{d}{d}dccccccc{d}{d}ddc{i}{i}iicccc{i}{i}iiic{d}{d}dddc{i}{i}ddcdc{d}{d}iiic{i}{i}dciic{d}{d}dc{i}{i}dciic{d}{d}dc{i}{i}ddcdc{d}{d}iiic{i}{i}iiic{d}{d}dddcccc{d}{d}ddc{i}{i}iiccc{i}{i}iiiic{d}{d}ddddc{i}{i}ddciiiiiic{d}{d}ddddc{i}{i}icic{d}{d}ddc{i}{i}iiic{d}iiic{d}ddddddc{i}{i}icic{d}{d}ddc{i}{i}ddciiiiiic{d}{d}ddddc{i}{i}iiiic{d}{d}ddddcc{d}{d}ddc{{i}ddddd}dddc{d}{d}dddddc{i}{i}dciiic{d}{d}ddc{i}{i}iiiicddddc{d}{d}c{i}{i}dddciciiiic{d}{d}ddc{i}{i}dddciciiiic{d}{d}ddc{i}{i}iiiicddddc{d}{d}c{i}{i}dciiic{d}{d}ddc{i}{i}iiiiic{{d}iiiii}iiic{i}{i}ii{c}{i}{i}ddciiicdddc{d}{d}ii{c}{d}{d}ddc{i}{i}iicccccccc{i}{i}ciicddddc{d}{d}iic{i}{i}ciicddddc{d}{d}iicccccccc{d}{d}ddc{i}{i}ii{c}{i}{i}iiiiic{d}iiiciic{d}{d}{c}{d}{d}ddc{i}{i}iiccccccc{i}{i}dddciiiiiicddddddciiiiic{d}{d}ddc{i}{i}dddciiiiiicddddddciiiiic{d}{d}ddccccccc

```

Try it online!

I tried to fail, and I succeeded!

---
Tags: code-golf, ascii-art, sequence, kolmogorov-complexity
---


title: lc's dvntrs n Wndrlnd

text:
# Question
Title: 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.

# Answer
# 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.
> 12 votes

# Answer
# 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.
> 7 votes

# Answer
# 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!
> 5 votes

# Answer
# 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`.
> 5 votes

# Answer
# 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
> 4 votes

# Answer
## 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``
</code></pre>

<pre><code>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.
> 4 votes

# Answer
# 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.
> 3 votes

# Answer
# 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.
> 3 votes

# Answer
# 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

```
> 2 votes

# Answer
# 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)
> 2 votes

# Answer
# 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]`.
> 1 votes

# Answer
# 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.
> 0 votes

---
Tags: code-golf, kolmogorov-complexity, compression
---