title: Polycops and Robbers (Cops' Thread)

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

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

---

# Allowed languages

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

---

# Cops' Challenge

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

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

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

---

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

---

# Winning

Most upvoted safe answer is the winner.

---

# Extra rules

Cops must know there *is* a language that the program runs in other than the ones they wrote, so that there's a guarantee that all answers are *possible* to crack.

And as always, standard loopholes apply.

# Answer
# Wow, cracked by Jo King while I'm still typing the explanations lol

```
'<?php '//'; #@ SPELL,WITH,ME, ,H,E,L,L,O, ,W,O,R,L,D,"'Hello, World!'"
$a = "'Hello, World!'";
if ([])
 console.log($a);
else {
 for ($i = 1; $i < strlen($a) - 1; $i++)
  echo($a[$i]);
}
// ?>'

```

Prints `'Hello, World!'` (with single quotes) in both JavaScript and PHP. This should be an easy one to solve.

## How this works

`'<?php '//'; #@ SPELL,WITH,ME, ,H,E,L,L,O, ,W,O,R,L,D,"'Hello, World!'"`

JS treats this line as a string `'<?php '` followed by a `//` comment, and PHP prints `'` (outside the tag, so literally), then starts the script with open tag, and a string `'//'`, then a `#` comment.

`$a = "'Hello, World!'";`

Both JS and PHP defines the variable `a` to be the string `"'Hello, World!'"`.

```
if ([])
 console.log($a);

```

In JS, since `[]` is consider truly, `console.log($a)` is executed and this prints out the string \`"'Hello, World!'".

```
else {
 for ($i = 1; $i < strlen($a) - 1; $i++)
  echo($a[$i]);
}

```

In PHP, since `[]` is consider falsy, the `for` loop is executed and this prints out the characters `Hello, World!` (notice the absence of quotes) subsequently.

`// ?>'`

In JS this is a comment, but in PHP the close tag ends the script and the `'` after the tag is printed out literally.

---

## Yes, the remaining language is Befunge-93.

`'<?php '//'; #@ SPELL,WITH,ME, ,H,E,L,L,O, ,W,O,R,L,D,"'Hello, World!'"`

`<` redirects the IP to the end of the line, then `"'Hello, World!'"` is pushed in reversed order. After that the 15 `,`s are used to output the characters (in normal order because of the double reversal). Finally `@` terminates the program.
> 7 votes

# Answer
# Almost all Befunges, Safe!

```
 &<v
@.+<

```

Try it online!

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

---

### The answer is Flobnar!

Try it online!

By the makers of Befunge, Flobnar is described as "what happens when you get Befunge drunk". It uses a lot of the same instructions, but goes backwards in comparison, starting at the `@`.

```
....
@...   Start here going left

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

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

Implicitly output the return value

```

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

# Answer
# Jelly and , 15 bytes

```
+19Ð¡1-4181ḢFḊĊ

```

Try it online!

Prints the first 20 terms in the Fibonacci sequence.

Hexdump is

```
1B 21 29 0F 00 21 1D 24 21 28 21 B5 36 B1 B0

```

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

# Answer
# Hello World, Cracked

```
puts "Hello World!"

```

List of Languages it works in (minus a few :D):

05AB1E

05AB1E (Legacy)

2sable

Oasis

Ruby

Tcl

Cracked:

Working Language is Foo
> 2 votes

# Answer
# Python, vulnerable

Also works in Coconut (Thanks BMO!)

Also works in Cython (which is a superset of Python, so why wouldn't it)

Adds two inputs together

~~(may have some garbage output before the output when run in the second language, let me know if that's not okay)~~

No longer has garbage output

Hint: The language name is somewhere on this page.

```
"""
" "- Z B.m " "" "" "" "" "" "" "[ K O.a- F R.d " "" "" "- C P.u- O T.h " "" "" "" "" "" "" "" "" "- T I.q- O K.a " "" "" "- H C.n- G Y.t " "" "" "" "" "" "" "" "> W C.a+ M T.a " "" "< D N.h] V T.r " "" "" "" "" "" "" "" "> D K.b- M S.i " "" "" "" "" "" "" "" ". U Y.u- I J.x " "" "" "" "" "[ X C.e- K U.m " "" "" "> L W.y+ F X.l " "" "" "+ D B.n+ V N.e " "" "" "" "" "" "" "" "" "+ L F.g+ T Q.k " "" "" "" "" "" "" "" "< L Z.f] V I.b " "" "" "" "" "" "" "" "" "> I O.s+ D F.p " "" "" "" "" "" "" "+ D P.g. W B.j" "+ J S.z+ X U.l " "" "+ J A.o+ L V.t " "" "" "" "" "" "" "" "" "+ R P.x+ Y L.j " "" "" "+ H W.s. Q P.l " "" "" "" "" ". N U.d+ C K.l " "" "" "" "" "" "" "" "+ U B.h+ W L.n " "" "" ". X L.k[ Q Y.v " "" "" "- F B.r- B X.z " "" "" "" "" "- M F.t> W L.v " "" "" "" "" "+ O W.x< F W.g " "" "" "" "" "" "] L P.y> M A.m " "" "" "" "" "" "" "- I K.x- F A.i " "" "" "" "" "- Z U.a- M M.t " "" "" "- C L.s. C C.j " "" "" "" "" "" "" "" "" "- T R.u- N U.i " "" "" "" "" "" "" "- U R.p[ F D.x " "" "" "" "" "" "" "" "" "- S P.o> C H.d " "" "" "" "" "" "" "" "+ O W.p+ N W.i " "" "" "" "" "" "" "" "" "+ U A.r< O A.k " "" "" "" "" "" "" "" "" "" "] A M.y> W H.m " "" "" "" "" "" "" "" "" ". G J.g- L M.p " "" "" "" "" "[ J K.k- P E.n " "" "" "" "" "" "" "- S V.y- U U.j " "" "" "" "" "" "" "" "> P T.v+ Z F.h" "< X R.g] J A.d " "" "" "" "" "" "" "" "> A U.f- U G.u " "" "" "" "- P L.o- I V.q " "" "" "" "" "" ". B Y.b+ H Y.r " "" "" "" "" "+ O Y.u+ P N.w " "" ". F K.n- D L.c " "" "" "" "" "- I G.g- D Y.m " "" "" "" "" "" "" "" "" "- B Y.h- S H.x " "" "" "" "- N R.k. K A.n " "" "" "" "" "" "- N F.r- F S.l " "" "" "" "" "" "" "" "" "- Q L.e- L J.f" "- S Q.o- K U.k " "" "- C I.h- A N.s" ". N P.t- D J.b " "" "" "" "" "" "[ I S.t- D A.j " "" "" "" "" "" "- N F.a- Z S.b " "" "" "" "" "> A G.g+ Z N.g " "" "< A K.t] U W.g " "" "" "" "" "" "> V D.b. Y U.j " "" "" "" "" "" "" "" "" "" "+ K F.j+ G M.t " "" "+ J E.c+ X S.i " "" "" "" "" "" "" "+ K F.r+ Z R.e " "" "" "" "" "" "" "" "+ S X.p+ Q R.h " "" "" "" "" "+ E L.p+ J U.p " "" "" "" "" "" "" "" "+ F G.z. K S.s " "" "" "- Y O.k- C P.i " "" "" "" "" "" "" "- H N.v- O C.k " "" "" "" "- S J.x- H O.p " "" "" "- X D.p- W E.h " "" "" "- K F.v- B X.q " "" "" "" "- M Z.a- W E.d " "" "" "" "" "" "" ". N Y.a+ T H.r " "" "" "" "" "" "" "" "" "+ R S.c+ U Q.k " "" "" "" "" "" "" "" "+ U D.s[ U L.o " "" "" "" "- E U.u> V C.l " "" "" "" "" "" "" "" "" "" "+ N U.d+ E H.x " "" "" "" "" "< M W.v] C S.i " "" "" "" "> F U.p+ G F.a " "" "" "" ". G S.c- K C.l " "" "" "" "" "" "[ M J.p- R G.w " "" "> Z M.q+ Z J.e " "" "" "" "+ Y Q.k+ S L.c " "" "" "" "" "+ Q R.i< Y C.l " "" "" "" "" "] L F.h> M K.r " "" "" "" "" "" "" "" ". Z K.q- K R.c " "" "" "" "" "" "" "" "" "" "[ Q R.u- W L.x " "" "" "" "" "" "" "- D C.g- Z T.a " "" "" "" "" "" "" "" "" "" "> L G.u+ R M.h " "" "" "+ G U.c< R C.s " "" "] N D.n> W T.u " "" "" "" "" "" "" "" "- I X.d- W Q.l " "" "" "" "" "" "" ". H Z.a- P C.n " "" "- F P.i- R O.x " "" "- R R.w- J Q.j " "" "- H R.y- C D.y " "" "" "" ". L A.t+ K C.t " "" "" "" "" "" "" "" "" "[ G P.o- N N.j " "" "- Q V.x- S V.b " "" "" "" "> U K.u+ Q F.x " "" "" "" "" "" "< M U.v] P I.c " "" "" "" "" "" "" "" "" "> S U.t. U G.t " "" "" "+ Z N.k[ X Y.t " "" "" "" "- E Y.v> L W.c" "+ K S.g+ S B.h " "" "" "+ K V.a< Z C.z " "" "" "] G C.n> J Z.u " "" "" "" "" "" "" "" ". U K.t- G V.o " "" "" "" "" "- K Z.f[ K J.e " "" "" "" "" "" "" "" "" "" "- J B.l- S N.f " "" "" "" "" "" "" "" "" "- O L.w> G J.z " "" "" "+ X V.y< G F.a " "" "" "" "" "" "" "" "] M V.z> L N.x" "- Z R.r. V R.x " "" "" "" "[ G R.h- D O.g " "" "" "" "" "" "" "> W I.g+ R C.x " "" "" "" "+ S F.h+ B G.m " "" "< B G.f] L D.z " "" "" "" "" "> F O.a+ K M.h " "" "" "" "" "" "+ V F.x. P V.w " "" "" "" "" "" "" "" "" "- C X.z. A L.x " "" "" "" "" "" "" "" "" "+ M J.b+ I O.t " "" "" "" "" "" "+ Z Y.q. N I.h" "- T W.e[ W K.o " "" "" "" "" "" "" "" "" "- S M.a- P O.d " "" "" "" "" "- B T.g> W K.s " "" "" "" "" "" "" "" "+ D V.g< O J.f " "" "" "" "" "" "] O O.r> C Z.f " "" "- W L.b. P F.d " "" "" "" "" "" "" "" "" "" "+ Y P.t[ H O.h " "" "" "" "- O Z.c- C A.z " "" "" "" "" "- X Y.g- O Q.g " "" "" "" "" "" "- N E.n> G C.s " "" "" "" "" "" "" "+ B I.g< Z P.a " "" "" "] H F.y> G J.j " "" "" "" "" "" "+ N R.u. G D.q " "" "" "" "" "" "" "" "- A F.e- P C.i " "" "" "" "- W L.i- L V.d " "" "" "" "" "" "- X P.r- Y S.x " "" "- F C.n- G N.o" "- Z A.q. K Q.j " "" "" "" "" "" "[ S B.n- W C.l " "" "" "" "" "" "" "- N Q.g- O M.h " "" "" "" "" "" "" "" "" "" "> J T.f+ M N.h " "" "" "" "" "" "< O C.w] J E.l " "" "" "" "" "" "" "" "" "" "> F N.c. Z H.d " "" "" "" "" "" "- G M.n- L S.x " "" "" "" "" "" "- S Z.h- C M.l" ". C S.z+ G I.a " "" "" "" "" "" "" "" "[ D W.g- C P.j " "" "- H V.t- C T.p " "" "" "" "- F F.o> Y A.s " "" "" "" "" "" "" "" "" "" "+ O R.g< I V.h " "" "" "" "" "" "] D H.p> H D.j " "" "" "" "" "+ O G.c+ I Z.p " "" "" "" "" "" "" "" "+ S R.f. I J.m " "" "" "" "" "" "+ H Z.l+ X V.h " "" "" "" "" "" "" "[ Y M.m- L O.r " "" "" "" "" "" "" "" "" "" "> B Z.n+ D W.x " "" "" "" "+ Z C.m+ X Q.t " "" "" "" "" "" "" "" "" "" "< S E.w] L Y.n" "> V F.b. V S.z " "" "+ C M.n+ L K.n" "+ S S.y+ S O.b " "" "" "" "" "" "" "" "" "" "+ R G.y+ K X.j " "" "" "" "+ F O.g+ A C.z " "" "+ R L.q. S N.g " "" "" "" "" "" "" "" "" "" "+ X L.x+ C F.x " "" "" "" "" "" "" "+ C O.x. G A.h " "" "" "" "" "" "" "" "" "" "[ Z L.u- A P.o " "" "" "" "- O H.i> U Q.v" "+ F A.d+ E T.n " "" "" "+ B S.o+ F B.y " "" "" "+ L S.r< O X.n " "" "" "" "" "" "" "] C D.h> H O.d " "" "" "" "" "" "+ X O.x+ H Q.b " "" "+ E S.n. M X.q " "" "" "- D S.j- U E.l " "" "" "" "" "" "" "[ H J.g- A R.a " "" "" "" "> T X.s+ D C.d " "" "" "" "" "" "+ G X.p+ I J.l " "" "" "" "" "" "" "" "" "" "+ F K.i< C Q.h" "] X L.c> X V.i " "" "" "" "" "+ B Q.t. S J.j " "" "" "" "" "- L J.v- D C.h " "" "" "" "" "" "- F D.f- R N.u " "" "" "" "" "" "- T Y.p- R S.p " "" "" "" "" "" "" "- V S.y- X U.r " "" "" "" "" "" "" "- H E.r- H O.l" ". I A.a+ C S.u " "" "" "" "" "" "" "" "" "+ S B.q+ L N.j " "" "" "" "" "" "" "+ B F.u+ L X.r " "" "" "" "" "" "" "+ V C.b. K P.l" "- U K.l[ P S.q " "" "" "" "" "" "" "- Z E.u- P M.s " "" "" "" "" "" "- I P.z- A W.f " "" "" "" "> W A.x+ S B.l " "" "" "" "" "" "< P H.m] T C.l " "" "" "" "" "" "" "" "" "" "> D N.o+ H T.w " "" "" "+ H X.n+ S Y.g " "" "" "" "" ". L C.b- M N.h " "" "" "" "" "- D B.q- X C.s " "" "" "" "" "" "[ D Y.o- L W.z " "" "" "> D N.n+ C P.o " "" "" "" "" "+ A V.a+ X X.w " "" "" "" "" "+ L T.l< V K.s" "] C E.f> C I.o " "" "" "" "" "" "" "" "" "" ". O C.a- L B.a " "" "- E Q.c- I F.h " "" "" "" "" "" "- A Y.q- K T.a" "- C Y.h- F A.e " "" "" "" "" "" "- M D.h- L I.z " "" "" "" "" "- X G.c- M F.x " "" "" "" "- P U.s. N F.f " "" "" "" "" "" "" "" "" "+ A E.c+ F B.k " "" "" "" "" "" "" "+ Q K.f+ W I.y " "" "" "" "" "+ E S.a+ R S.o " "" "" "+ N Y.a. J G.u " "" "+ L V.i+ X T.y " "" "" "+ S F.l+ O Y.i " "" "" "" "" "" "" "" "" "" "+ Q V.e+ S Q.l " "" "" "" "" "" "" ". O A.g+ W S.r " "" "" "" "" "" "" "" "" "+ Z D.e[ N A.l " "" "" "" "- A D.b> I K.a " "" "" "" "" "" "+ E U.c+ E O.x " "" "" "" "" "" "" "" "+ P D.h< G K.g " "" "" "" "" "] G X.b> H W.g " "" "" "" "" "" "" "" "+ K D.c+ H B.f " "" "" ". K Z.e+ M P.p " "" "" "" "" "" "" "" "" ". A L.n- O B.m" "- P T.z- C S.w " "" "" "" "" "" "" "" "- Q Y.e[ I N.g " "" "- X A.q> Y L.i" "+ I Y.u+ T A.w " "" "+ B Z.t< W U.z " "" "" "" "" "" "" "] R S.i> U S.a " "" "" "" "" "" "" "" "" ". O T.a- M D.f " "" "" "" "" "" "- H U.s- V O.g " "" "" "" "" "" "" "" "- O H.p- O L.v " "" "" "" "" "" "" "" "" "" "- X R.b- U V.w " "" "" "" "" "" "- G H.w- E R.n " "" "" "" "" "" "" "" "" "" "- R J.c- H S.p " "" "" "" "- J A.x. F W.h " "" "" "" "" "" "" "" "" "[ J R.s- F R.c " "" "" "" "" "" "" "> L H.w+ Z A.z " "" "" "" "+ Z O.s+ S D.u " "" "" "" "" "" "" "" "< B C.k] J F.k" "> P C.t+ H C.q " "" "" "" "" "" "" "" "" "+ N B.e. V S.t " "" "" "" "" "[ Q M.p- M C.m " "" "" "" "" "" "" "- B A.r- Q C.y " "" "" "> F D.t+ A G.r " "" "< A V.d] X H.m " "" "" "" "" "" "" "" "> J E.x- Y P.d " "" "- E T.h- P I.p " "" "" "" "" "" "" "" "- R O.f. I B.f" "+ P M.n+ N L.j " "+ N Z.c[ Y V.z " "" "" "- K G.k> D F.u " "" "" "+ L D.e+ W I.k " "" "" "" "" "" "+ P M.k< X Y.y " "" "" "" "" "" "] O L.n> Q K.e " "" "" "" "+ R M.t+ C B.i " "" "" ". E J.g+ I C.a " "" "" "" "" "" "" "" "" "" "+ C C.k+ B I.e " "" "" "" "" "" "" "" "" "+ T U.d+ K D.x " "" "" "" "" "" "" "+ F K.p+ M O.h " "" "" "" "" "" "" "+ Q H.e. M Z.a " "" "" "" "+ I Q.m+ W M.d " "" "" "" "+ A I.y+ G H.u " "" "" "" "" "" "" "+ E U.j. Z W.z " "" "" "" "" "" "" "" "" "- G X.r- R V.h " "" "- I P.a- M X.d " "" "" "" "" "" "" "" "" "- V M.q- C M.z " "" "" "" "" "" "- P K.l- N L.r " "" "" "" "" "" ". L D.t- G A.f " "" "" "" "" "" "" "" "" "" "[ T J.f- M X.p " "" "" "" "" "" "" "- V P.t- G Z.f " "" "> T O.h+ S Q.r " "" "" "" "" "" "" "" "" "< Z S.r] D P.v " "" "" "" "" "" "" "> G Q.n- F M.v " "" "" "" "" "" "" "" "" "- P Z.g. N S.d " "" "" "" "" "" "" "" "" "" "+ E G.x[ U N.t " "" "" "- R J.z> Y Y.e " "" "" "" "" "" "" "" "+ V N.x+ V U.s " "" "" "" "" "+ W P.s< S P.m " "" "" "" "" "" "" "" "] G O.x> X J.d " "" "" "" "" "" "+ X E.l. Z T.o " "" "" "" "+ T N.l+ L U.t " "" "" "" "+ C L.i+ Z M.g" "+ M K.k+ E P.p " "" "" "" "" "+ P T.l+ S Z.h" ". F W.k- Q D.q " "[ O I.r+ K W.r " "" "" "+ J B.x> F A.s " "" "" "" "" "" "" "" "" "- Y D.b- O H.r " "" "" "" "" "" "- W N.a< H S.e" "] N F.o> Q I.y " "" "" "" "" "" "+ B V.w. Q G.b " "" "" "- J R.i[ B M.j" "- Q R.a- K V.v " "" "" "- M S.b> W O.i " "" "" "" "" "" "" "" "" "+ C D.t+ T X.o " "" "" "" "" "" "" "" "" "< S C.m] T F.f " "" "" "" "" "" "" "" "" "" "> E Q.z- O B.w " "" "" "" "" "" "" ". Z T.a+ X L.t" "+ H U.f+ B E.x " "" "" "" "" "" "" "" "+ K A.c+ A E.p " "" "" "" "" "+ S N.v+ P P.h " "" "" "" "" "" "" "" "+ R C.f+ I I.y " "" "" "" "" "" "" "" "" "+ N C.h. U P.x " "" "" "" "" "" "" "- D Q.c- I K.k " "" "" "" "" "" "" "" "" "- U U.c- A X.j " "" "" "" "" "" "" "" "" "" "- N B.u. A J.p " "" "" "" "" "[ N K.j+ L H.t " "" "" "" "" "+ D E.j> T Q.c" "- B U.z- A N.e " "" "" "- C J.k< D O.n " "" "" "" "" "" "" "" "" "] O U.c> Z J.e " "" "" "" "" "" "+ K E.m+ B O.p" ". H S.l[ T N.r " "- Z M.e> D Q.i " "" "" "" "" "" "" "" "+ K B.v+ S P.o " "" "" "" "" "+ Q O.w< Y D.o " "" "" "" "] I C.n> R H.i " "" "" "" "" "" "" "- I F.z. L Q.t " "" "[ W U.q- A C.q " "" "" "" "- H U.l- V P.f " "" "" "- J Z.n> C Y.j " "" "" "" "" "" "" "+ E Y.b< J Q.g " "" "" "" "" "" "] F W.x> X H.c " "" "+ Z X.r+ O K.g " "" "" "" "+ Y Q.f. X Z.d " "" "" "" "" "" "" "[ O G.z- F K.u " "" "> P Z.o+ M D.s " "" "" "" "" "" "" "" "+ L G.h+ Z M.l " "" "" "" "" "" "" "" "" "" "< J L.y] O U.x " "" "" "" "" "> L K.q+ P U.c " "" "" "" ". F H.l+ X W.j " "" "" "" "" "" "" "+ N I.x. U A.u " "" "" "" "" "" "" "" "- Y B.m[ X W.a " "" "" "" "" "" "" "" "" "" "- B X.u- V G.w " "" "" "" "" "- D N.d> M Q.g " "" "" "" "" "" "" "" "+ I I.w< E P.u " "" "] F V.k> I U.s " "" "" "" "" "" "" "- F P.b- B H.u " "" "" "" "" "" ". J X.n+ G E.e " "" "" "" "" "" "" "" "" "" ". U J.t[ T C.l " "" "" "" "" "- O K.g> T L.r " "" "" "" "" "" "" "" "+ W A.a+ O Z.g " "" "+ A N.e< Q N.q " "" "" "" "" "] W U.k> Y J.w " "" "" "" "" "" "" "" "" "+ V V.k+ Y L.w " "" "" "" ". S V.k+ P C.h " "" "" "" "" "" "+ C G.v+ N F.d " "" "" "" "" "" "" "" "" "" "+ K P.u+ R J.z " "" "+ E R.y+ I I.p " "" "" "" "" "" "" "" "" "" "+ Y H.z+ G U.v " "" "+ T E.o+ G S.g " "" "" "" ". S A.u. Z X.n " "" "- L S.x[ M X.z " "" "" "" "" "" "" "" "" "- V Z.e- S C.p " "" "" "" "" "- T H.m> E B.m " "" "" "" "" "" "" "" "" "" "+ Q T.t< N Z.g " "" "" "] R I.y> B J.k " "" "" "" "" ". V V.r- L T.x " "" "" "" "" "" "" "" "[ L Z.s- T Y.p " "" "" "" "" "" "- N A.p- W X.q " "" "" "" "" "" "" "- M D.t> Z Y.r " "" "" "" "+ B Q.u< L C.m" "] V R.j> Z D.y " "+ A C.j+ P S.w " "" "" "" ". V K.r- E N.s " "" "" "" "" "- C F.n- Q B.p " "" "" "" "" "" "[ R E.d- H Y.r " "" "" "" "" "" "> H D.v+ X E.h" "+ V R.j+ C C.m " "+ C Q.j< Q X.b " "" "" "" "" "" "" "" "" "] Y J.g> K Y.s " "" "" "" "" "" "" "" ". T R.i- K R.f " "" "" "" "" "" "" "" "- B U.o- Z I.n " "" "" "" "" "" "" "" "- I X.s- G D.p" "- B C.i- K G.c " "- V G.i- P Y.f " "" "" "" "- V G.t- U D.s " "" "" "" "" "" "" "" "" "- K P.f. F X.m " "" "" "" "" "- O B.l- S C.e " "" "" "" "" "" "- B K.l. D Z.f " "" "- U K.m- J F.z " "" "" "" "[ H N.l- D G.i " "" "" "" "" "" "" "" "" "- Y T.u- Z R.s " "" "> Z O.p+ D V.g" "< Q W.w] W K.w " "" "" "" "" "" "> O V.l- I A.w " "" "" "" "" "" "" ". B L.j+ H C.k " "" "" "" "" "" "" "+ B W.w[ H T.q " "" "" "" "" "" "" "" "- Z F.z- H S.u" "- K B.j> M T.w " "" "" "" "" "" "" "+ Q N.d+ G K.a " "" "" "" "" "" "< W U.e] H M.u " "" "" "" "" "> B Q.u. O J.r " "" "" "" "" "" "" "" "- Z G.n- H K.i " "" "" "" "" "" "" "" "" "- I E.j- X U.y " "" "" "" "" "- L O.u- J D.h " "" "" "- X F.q- P J.v " "" "- E T.u- X M.c " "" "" "" "" "- S P.y. U S.z " "" "" "" "" "" "" "" "" "+ E C.l+ S N.y " "" "+ T N.r+ J F.s " "" "" "" "" "" "" "" "+ U I.x+ I P.o " "" "" "" "+ F Z.e+ P E.k " "" "" "" "" "" "" "+ G J.k+ X Y.w " "" "" "" "" "" "" "+ Z Z.d+ Y B.b " "" "+ F A.d. R W.p " "" "" "- M A.z- Y R.l " "" "" "" "" "" "" "- Z L.a- E X.h " "" "" "" "" "" "" "" "" "" "- I G.d- H J.b " "" "- U E.n. H X.k " "" "" "- V E.s- S F.h " "" "" "" "[ L A.x- A C.l " "" "" "" "- P O.q- X J.x " "" "" "> M X.u+ W H.s " "" "" "< H T.p] V U.o " "" "" "" "" "> P Z.v- C K.a " "" "" "- U J.p. V N.l " "" "" "" "" "" "" "" "" "" "[ L T.u- N K.d " "" "" "" "" "" "" "" "" "> I G.u+ Z N.g " "" "" "" "" "" "" "" "" "" "+ H K.j+ M S.h " "" "" "" "" "" "" "" "< F M.t] D J.z " "" "" "" "" "" "" "> E K.d+ J M.c " "" "" "" "" "" "" "" "" "+ O M.u. A P.k " "" "" "" "" "" "" "" "" "+ R V.v+ U I.e " "" "+ Z C.m+ L L.m " "" "" "" "" "+ B Z.d+ O R.s " "" "" "" "" "" ". B D.m- W R.x " "" "" "" "" "" "" "" "- W H.b. S R.g " "" "- Y N.a- P L.b " "" "" "" "" "" "" "" "[ T M.k- D H.x " "" "" "" "" "" "" "" "" "- P I.s- U A.z " "" "" "" "> E B.m+ O I.t " "" "" "" "" "< T N.c] A D.t " "" "" "> Q I.y- Z P.y " "" "" "" "" "" "" "" "" ". M B.t- N E.j " "" "" "- K T.z- Y S.p " "" "" "" "" "" "" "" "[ D J.x- V R.z" "> R Q.i+ C G.h " "" "+ Z V.a+ U C.n " "" "" "" "" "" "" "" "+ D U.s< W C.x " "" "" "" "" "" "] F A.j> J L.h " "" "" "" "" "" ". N U.r- R F.n " "" "" "" "" "- V N.s- T L.n " "" "" "" "- V E.i- T G.n" "- O M.r- Z A.g " "" "" "" "" "" "" "- A Q.h- S Z.n " "" "" "" "" "" "- Q G.q- L X.p " "" "- Z D.k. M C.a" "- P M.e- V S.u " "" "" "" "" "" "" "- S I.k- B W.o " "" "" "" "" "" "" "" "" "" "- C W.o- U U.m " "" "" "" "" "" "" "" "" "- V C.o. Q F.i " "" "" "" "" "" "" "" "" "" "- P N.w- S Y.l " "" "" "" "" "" "" "" "" "" "[ J R.h- D A.k " "" "" "" "" "" "" "" "" "" "- N A.o- Q L.g " "" "> P L.c+ L T.n " "" "" "" "" "" "" "< O W.o] P O.v " "" "" "" "" "" "> K G.h- T O.j " "" "" "" "" ". P J.u[ O W.x " "" "" "" "" "" "- I F.c- N Z.c" "- S U.e- L D.y " "" "" "" "" "" "" "" "" "" "> E Y.l+ X Y.l " "" "" "" "" "" "< L S.q] P K.c " "" "" "" "" "" "" "> D V.l+ M F.a " "" "" "" "" "" "" "" "+ F F.f+ C N.z " "" "" "" "" "" "" "" ". E D.d- P J.p " "" "" "" "" "" "- Q Z.c- E T.w " "" "" "" "" "[ O E.t- C G.w " "" "" "" "" "" "> D F.a+ S X.d " "" "" "" "+ V Z.a+ O V.x " "" "" "" "" "" "" "" "" "+ I Z.z< N H.f " "" "" "" "" "] E L.n> U V.m " "" "" "" ". G E.r- P T.n " "" "" "" "" "" "- H U.p- N J.v " "" "" "" "" "" "" "" "" "" "- D W.g- Q P.f " "" "" "" "" "" "- I S.w- L L.d " "" "" "" "" "" "" "" "- O S.j- I W.u " "" "" "" "" "" "" "" "- F J.m- Q D.s " "" "" "- T C.v. F L.z " "" "" "" "" "" "" "" "+ C J.k. Z B.m " "" "" "" "" "" "" "" "" "" "+ Y J.r+ B G.n " "" "" "" "" "" "" "" "" "+ P P.c+ T F.x " "" "" "" "" "" "" "" "" "" "+ U A.k+ A W.x " "" "" "" "" "" "" "" "" "+ L R.s+ U U.b " "" "" "" "" "" "" "" "+ Z B.t+ C J.g " "" "" "" ". Z Q.v+ Q W.l " "" "" "[ M C.i- J A.p" "- N V.p- V V.s " "" "- V O.v> M C.w " "" "" "" "" "" "" "" "+ M O.f< I U.j" "] A G.b> Z D.z " "" "" "" "" "+ O J.h+ X K.u " "" "" "" "" "" "" "+ Y I.r. Y E.u " "" "" "" "" "" "" "" "" "- V P.s- R I.g " "" "- Q J.u[ V I.e " "" "" "" "" "- D B.g- C Z.f " "" "" "" "" "" "" "- C E.f- U K.k " "" "" "" "" "" "" "" "" "- Z P.e> D N.y " "" "" "" "" "+ V K.k+ A J.b" "< C E.l] B E.t " "" "" "> D R.p. D L.a " "" "" "" "+ A H.q+ H Y.w " "" "" "" "+ K A.o. M X.k " "" "" "" "- M C.o- B N.c " "" "- F T.w- J F.u " "" "" "" "" "- N Q.i- W K.j " "" "" "- D V.q. E W.g " "" "" "+ C X.p+ R T.y" "+ R P.j+ B S.a " "" "+ D B.i. M G.c" "+ N B.l[ I N.x " "" "" "" "" "" "" "" "" "- Z R.w- P W.n " "" "" "" "" "" "" "" "- C B.h- R P.m " "" "" "" "> S I.t+ H L.n " "" "" "" "" "" "" "" "< G O.e] T Z.w " "" "" "" "" "" "> A Q.k+ N V.q " "" "" "" "" "+ E S.y+ D C.n " "" "" "" ". U E.f- Z A.p" "[ Y C.q- D O.p " "" "" "" "" "" "" "- D R.g- M A.k " "" "" "" "" "> Q D.j+ D E.r " "" "" "" "+ W W.p< E T.y " "" "" "" "" "" "" "" "" "] V P.g> G E.x " "" "" "- L O.p. S P.r " "" "" "" "" "" "" "" "+ B F.q+ G X.x " "" "" "" "" "" "" "" "" "" "+ W X.q+ O E.o" "+ E Z.v. Q G.w " "[ H H.n- C F.x " "" "" "- N L.j- Z N.t " "" "" "" "" "" "" "" "- L G.e- F Y.y " "" "" "" "" "" "" "" "> C L.l+ T R.l " "" "" "" "" "" "" "" "" "" "+ Q F.e< Z D.g " "" "" "" "" "" "" "" "" "" "] W I.i> S T.z " "" "" "" "+ V Z.s+ Y W.r " "" "" "" "" "" "" "" ". R C.e+ O A.d " "" "" "" "" "" "" "" "" "+ J P.b[ H W.i " "" "" "" "" "" "- L F.u- H D.k" "- H Q.w> L Y.c " "" "" "" "" "" "" "" "+ B F.p+ J U.y " "" "" "< X U.c] N E.p " "" "" "" "" "" "" "" "" "> W M.k. J W.n " "" "" "> C K.i- T R.l " "" "" "" "" "" "" "" "" "" "[ S A.c- D W.w " "" "" "" "" "" "" "" "" "" "- R I.g- M F.p " "" "" "" "" "" "" "" "" "> I V.e+ Q U.j " "" "" "< T U.p] I C.j " "" "" "" "" "> W E.t- U O.y " "" "" "" "" "- I S.l. H M.t " "" "" "" "[ A Z.w- F H.x " "" "" "" "" "" "" "" "" "- M A.p- S J.k " "" "" "" "" "" "" "" "" "" "> F X.s+ F A.a" "< P A.c] I G.r " "" "> Y W.m- K F.l " "" "" "" "" "" "" "- V W.e. G Q.u " "" "" "" "" "" "" "" "" "" "+ S C.t+ F W.y " "" "" "" "+ I S.v. N Y.k " "" "" "" "" "" "" "" "" "" ". U Q.f+ V K.f " "" "+ N S.m+ W Y.u " "" "" "+ X X.j+ I I.m " "" "" "" "" "" "+ V I.g+ B Z.f" ". Q Q.q- L A.e " "" "" "" "" "" "[ F O.w- Z K.v " "" "- P I.b- M X.r " "" "" "" "" "" "- H O.n> I R.e " "" "" "+ V S.b< P U.a " "" "" "" "] Y G.g> S C.l " "" "" "" "" "" "" "" "" "+ X I.z+ P I.n"+ Q E.q" ""- Z B.m " "" "" "" "" "" "" "[ K O.a- F R.d " "" "" "- C P.u- O T.h " "" "" "" "" "" "" "" "" "- T I.q- O K.a " "" "" "- H C.n- G Y.t " "" "" "" "" "" "" "" "> W C.a+ M T.a " "" "< D N.h] V T.r " "" "" "" "" "" "" "" "> D K.b- M S.i " "" "" "" "" "" "" "" ". U Y.u- I J.x " "" "" "" "" "[ X C.e- K U.m " "" "" "> L W.y+ F X.l " "" "" "+ D B.n+ V N.e " "" "" "" "" "" "" "" "" "+ L F.g+ T Q.k " "" "" "" "" "" "" "" "< L Z.f] V I.b " "" "" "" "" "" "" "" "" "> I O.s+ D F.p " "" "" "" "" "" "" "+ D P.g. W B.j" "+ J S.z+ X U.l " "" "+ J A.o+ L V.t " "" "" "" "" "" "" "" "" "+ R P.x+ Y L.j " "" "" "+ H W.s. Q P.l " "" "" "" "" ". N U.d+ C K.l " "" "" "" "" "" "" "" "+ U B.h+ W L.n " "" "" ". X L.k[ Q Y.v " "" "" "- F B.r- B X.z " "" "" "" "" "- M F.t> W L.v " "" "" "" "" "+ O W.x< F W.g " "" "" "" "" "" "] L P.y> M A.m " "" "" "" "" "" "" "- I K.x- F A.i " "" "" "" "" "- Z U.a- M M.t " "" "" "- C L.s. C C.j " "" "" "" "" "" "" "" "" "- T R.u- N U.i " "" "" "" "" "" "" "- U R.p[ F D.x " "" "" "" "" "" "" "" "" "- S P.o> C H.d " "" "" "" "" "" "" "" "+ O W.p+ N W.i " "" "" "" "" "" "" "" "" "+ U A.r< O A.k " "" "" "" "" "" "" "" "" "" "] A M.y> W H.m " "" "" "" "" "" "" "" "" ". G J.g- L M.p " "" "" "" "" "[ J K.k- P E.n " "" "" "" "" "" "" "- S V.y- U U.j " "" "" "" "" "" "" "" "> P T.v+ Z F.h" "< X R.g] J A.d " "" "" "" "" "" "" "" "> A U.f- U G.u " "" "" "" "- P L.o- I V.q " "" "" "" "" "" ". B Y.b+ H Y.r " "" "" "" "" "+ O Y.u+ P N.w " "" ". F K.n- D L.c " "" "" "" "" "- I G.g- D Y.m " "" "" "" "" "" "" "" "" "- B Y.h- S H.x " "" "" "" "- N R.k. K A.n " "" "" "" "" "" "- N F.r- F S.l " "" "" "" "" "" "" "" "" "- Q L.e- L J.f" "- S Q.o- K U.k " "" "- C I.h- A N.s" ". N P.t- D J.b " "" "" "" "" "" "[ I S.t- D A.j " "" "" "" "" "" "- N F.a- Z S.b " "" "" "" "" "> A G.g+ Z N.g " "" "< A K.t] U W.g " "" "" "" "" "" "> V D.b. Y U.j " "" "" "" "" "" "" "" "" "" "+ K F.j+ G M.t " "" "+ J E.c+ X S.i " "" "" "" "" "" "" "+ K F.r+ Z R.e " "" "" "" "" "" "" "" "+ S X.p+ Q R.h " "" "" "" "" "+ E L.p+ J U.p " "" "" "" "" "" "" "" "+ F G.z. K S.s " "" "" "- Y O.k- C P.i " "" "" "" "" "" "" "- H N.v- O C.k " "" "" "" "- S J.x- H O.p " "" "" "- X D.p- W E.h " "" "" "- K F.v- B X.q " "" "" "" "- M Z.a- W E.d " "" "" "" "" "" "" ". N Y.a+ T H.r " "" "" "" "" "" "" "" "" "+ R S.c+ U Q.k " "" "" "" "" "" "" "" "+ U D.s[ U L.o " "" "" "" "- E U.u> V C.l " "" "" "" "" "" "" "" "" "" "+ N U.d+ E H.x " "" "" "" "" "< M W.v] C S.i " "" "" "" "> F U.p+ G F.a " "" "" "" ". G S.c- K C.l " "" "" "" "" "" "[ M J.p- R G.w " "" "> Z M.q+ Z J.e " "" "" "" "+ Y Q.k+ S L.c " "" "" "" "" "+ Q R.i< Y C.l " "" "" "" "" "] L F.h> M K.r " "" "" "" "" "" "" "" ". Z K.q- K R.c " "" "" "" "" "" "" "" "" "" "[ Q R.u- W L.x " "" "" "" "" "" "" "- D C.g- Z T.a " "" "" "" "" "" "" "" "" "" "> L G.u+ R M.h " "" "" "+ G U.c< R C.s " "" "] N D.n> W T.u " "" "" "" "" "" "" "" "- I X.d- W Q.l " "" "" "" "" "" "" ". H Z.a- P C.n " "" "- F P.i- R O.x " "" "- R R.w- J Q.j " "" "- H R.y- C D.y " "" "" "" ". L A.t+ K C.t " "" "" "" "" "" "" "" "" "[ G P.o- N N.j " "" "- Q V.x- S V.b " "" "" "" "> U K.u+ Q F.x " "" "" "" "" "" "< M U.v] P I.c " "" "" "" "" "" "" "" "" "> S U.t. U G.t " "" "" "+ Z N.k[ X Y.t " "" "" "" "- E Y.v> L W.c" "+ K S.g+ S B.h " "" "" "+ K V.a< Z C.z " "" "" "] G C.n> J Z.u " "" "" "" "" "" "" "" ". U K.t- G V.o " "" "" "" "" "- K Z.f[ K J.e " "" "" "" "" "" "" "" "" "" "- J B.l- S N.f " "" "" "" "" "" "" "" "" "- O L.w> G J.z " "" "" "+ X V.y< G F.a " "" "" "" "" "" "" "" "] M V.z> L N.x" "- Z R.r. V R.x " "" "" "" "[ G R.h- D O.g " "" "" "" "" "" "" "> W I.g+ R C.x " "" "" "" "+ S F.h+ B G.m " "" "< B G.f] L D.z " "" "" "" "" "> F O.a+ K M.h " "" "" "" "" "" "+ V F.x. P V.w " "" "" "" "" "" "" "" "" "- C X.z. A L.x " "" "" "" "" "" "" "" "" "+ M J.b+ I O.t " "" "" "" "" "" "+ Z Y.q. N I.h" "- T W.e[ W K.o " "" "" "" "" "" "" "" "" "- S M.a- P O.d " "" "" "" "" "- B T.g> W K.s " "" "" "" "" "" "" "" "+ D V.g< O J.f " "" "" "" "" "" "] O O.r> C Z.f " "" "- W L.b. P F.d " "" "" "" "" "" "" "" "" "" "+ Y P.t[ H O.h " "" "" "" "- O Z.c- C A.z " "" "" "" "" "- X Y.g- O Q.g " "" "" "" "" "" "- N E.n> G C.s " "" "" "" "" "" "" "+ B I.g< Z P.a " "" "" "] H F.y> G J.j " "" "" "" "" "" "+ N R.u. G D.q " "" "" "" "" "" "" "" "- A F.e- P C.i " "" "" "" "- W L.i- L V.d " "" "" "" "" "" "- X P.r- Y S.x " "" "- F C.n- G N.o" "- Z A.q. K Q.j " "" "" "" "" "" "[ S B.n- W C.l " "" "" "" "" "" "" "- N Q.g- O M.h " "" "" "" "" "" "" "" "" "" "> J T.f+ M N.h " "" "" "" "" "" "< O C.w] J E.l " "" "" "" "" "" "" "" "" "" "> F N.c. Z H.d " "" "" "" "" "" "- G M.n- L S.x " "" "" "" "" "" "- S Z.h- C M.l" ". C S.z+ G I.a " "" "" "" "" "" "" "" "[ D W.g- C P.j " "" "- H V.t- C T.p " "" "" "" "- F F.o> Y A.s " "" "" "" "" "" "" "" "" "" "+ O R.g< I V.h " "" "" "" "" "" "] D H.p> H D.j " "" "" "" "" "+ O G.c+ I Z.p " "" "" "" "" "" "" "" "+ S R.f. I J.m " "" "" "" "" "" "+ H Z.l+ X V.h " "" "" "" "" "" "" "[ Y M.m- L O.r " "" "" "" "" "" "" "" "" "" "> B Z.n+ D W.x " "" "" "" "+ Z C.m+ X Q.t " "" "" "" "" "" "" "" "" "" "< S E.w] L Y.n" "> V F.b. V S.z " "" "+ C M.n+ L K.n" "+ S S.y+ S O.b " "" "" "" "" "" "" "" "" "" "+ R G.y+ K X.j " "" "" "" "+ F O.g+ A C.z " "" "+ R L.q. S N.g " "" "" "" "" "" "" "" "" "" "+ X L.x+ C F.x " "" "" "" "" "" "" "+ C O.x. G A.h " "" "" "" "" "" "" "" "" "" "[ Z L.u- A P.o " "" "" "" "- O H.i> U Q.v" "+ F A.d+ E T.n " "" "" "+ B S.o+ F B.y " "" "" "+ L S.r< O X.n " "" "" "" "" "" "" "] C D.h> H O.d " "" "" "" "" "" "+ X O.x+ H Q.b " "" "+ E S.n. M X.q " "" "" "- D S.j- U E.l " "" "" "" "" "" "" "[ H J.g- A R.a " "" "" "" "> T X.s+ D C.d " "" "" "" "" "" "+ G X.p+ I J.l " "" "" "" "" "" "" "" "" "" "+ F K.i< C Q.h" "] X L.c> X V.i " "" "" "" "" "+ B Q.t. S J.j " "" "" "" "" "- L J.v- D C.h " "" "" "" "" "" "- F D.f- R N.u " "" "" "" "" "" "- T Y.p- R S.p " "" "" "" "" "" "" "- V S.y- X U.r " "" "" "" "" "" "" "- H E.r- H O.l" ". I A.a+ C S.u " "" "" "" "" "" "" "" "" "+ S B.q+ L N.j " "" "" "" "" "" "" "+ B F.u+ L X.r " "" "" "" "" "" "" "+ V C.b. K P.l" "- U K.l[ P S.q " "" "" "" "" "" "" "- Z E.u- P M.s " "" "" "" "" "" "- I P.z- A W.f " "" "" "" "> W A.x+ S B.l " "" "" "" "" "" "< P H.m] T C.l " "" "" "" "" "" "" "" "" "" "> D N.o+ H T.w " "" "" "+ H X.n+ S Y.g " "" "" "" "" ". L C.b- M N.h " "" "" "" "" "- D B.q- X C.s " "" "" "" "" "" "[ D Y.o- L W.z " "" "" "> D N.n+ C P.o " "" "" "" "" "+ A V.a+ X X.w " "" "" "" "" "+ L T.l< V K.s" "] C E.f> C I.o " "" "" "" "" "" "" "" "" "" ". O C.a- L B.a " "" "- E Q.c- I F.h " "" "" "" "" "" "- A Y.q- K T.a" "- C Y.h- F A.e " "" "" "" "" "" "- M D.h- L I.z " "" "" "" "" "- X G.c- M F.x " "" "" "" "- P U.s. N F.f " "" "" "" "" "" "" "" "" "+ A E.c+ F B.k " "" "" "" "" "" "" "+ Q K.f+ W I.y " "" "" "" "" "+ E S.a+ R S.o " "" "" "+ N Y.a. J G.u " "" "+ L V.i+ X T.y " "" "" "+ S F.l+ O Y.i " "" "" "" "" "" "" "" "" "" "+ Q V.e+ S Q.l " "" "" "" "" "" "" ". O A.g+ W S.r " "" "" "" "" "" "" "" "" "+ Z D.e[ N A.l " "" "" "" "- A D.b> I K.a " "" "" "" "" "" "+ E U.c+ E O.x " "" "" "" "" "" "" "" "+ P D.h< G K.g " "" "" "" "" "] G X.b> H W.g " "" "" "" "" "" "" "" "+ K D.c+ H B.f " "" "" ". K Z.e+ M P.p " "" "" "" "" "" "" "" "" ". A L.n- O B.m" "- P T.z- C S.w " "" "" "" "" "" "" "" "- Q Y.e[ I N.g " "" "- X A.q> Y L.i" "+ I Y.u+ T A.w " "" "+ B Z.t< W U.z " "" "" "" "" "" "" "] R S.i> U S.a " "" "" "" "" "" "" "" "" ". O T.a- M D.f " "" "" "" "" "" "- H U.s- V O.g " "" "" "" "" "" "" "" "- O H.p- O L.v " "" "" "" "" "" "" "" "" "" "- X R.b- U V.w " "" "" "" "" "" "- G H.w- E R.n " "" "" "" "" "" "" "" "" "" "- R J.c- H S.p " "" "" "" "- J A.x. F W.h " "" "" "" "" "" "" "" "" "[ J R.s- F R.c " "" "" "" "" "" "" "> L H.w+ Z A.z " "" "" "" "+ Z O.s+ S D.u " "" "" "" "" "" "" "" "< B C.k] J F.k" "> P C.t+ H C.q " "" "" "" "" "" "" "" "" "+ N B.e. V S.t " "" "" "" "" "[ Q M.p- M C.m " "" "" "" "" "" "" "- B A.r- Q C.y " "" "" "> F D.t+ A G.r " "" "< A V.d] X H.m " "" "" "" "" "" "" "" "> J E.x- Y P.d " "" "- E T.h- P I.p " "" "" "" "" "" "" "" "- R O.f. I B.f" "+ P M.n+ N L.j " "+ N Z.c[ Y V.z " "" "" "- K G.k> D F.u " "" "" "+ L D.e+ W I.k " "" "" "" "" "" "+ P M.k< X Y.y " "" "" "" "" "" "] O L.n> Q K.e " "" "" "" "+ R M.t+ C B.i " "" "" ". E J.g+ I C.a " "" "" "" "" "" "" "" "" "" "+ C C.k+ B I.e " "" "" "" "" "" "" "" "" "+ T U.d+ K D.x " "" "" "" "" "" "" "+ F K.p+ M O.h " "" "" "" "" "" "" "+ Q H.e. M Z.a " "" "" "" "+ I Q.m+ W M.d " "" "" "" "+ A I.y+ G H.u " "" "" "" "" "" "" "+ E U.j. Z W.z " "" "" "" "" "" "" "" "" "- G X.r- R V.h " "" "- I P.a- M X.d " "" "" "" "" "" "" "" "" "- V M.q- C M.z " "" "" "" "" "" "- P K.l- N L.r " "" "" "" "" "" ". L D.t- G A.f " "" "" "" "" "" "" "" "" "" "[ T J.f- M X.p " "" "" "" "" "" "" "- V P.t- G Z.f " "" "> T O.h+ S Q.r " "" "" "" "" "" "" "" "" "< Z S.r] D P.v " "" "" "" "" "" "" "> G Q.n- F M.v " "" "" "" "" "" "" "" "" "- P Z.g. N S.d " "" "" "" "" "" "" "" "" "" "+ E G.x[ U N.t " "" "" "- R J.z> Y Y.e " "" "" "" "" "" "" "" "+ V N.x+ V U.s " "" "" "" "" "+ W P.s< S P.m " "" "" "" "" "" "" "" "] G O.x> X J.d " "" "" "" "" "" "+ X E.l. Z T.o " "" "" "" "+ T N.l+ L U.t " "" "" "" "+ C L.i+ Z M.g" "+ M K.k+ E P.p " "" "" "" "" "+ P T.l+ S Z.h" ". F W.k- Q D.q " "[ O I.r+ K W.r " "" "" "+ J B.x> F A.s " "" "" "" "" "" "" "" "" "- Y D.b- O H.r " "" "" "" "" "" "- W N.a< H S.e" "] N F.o> Q I.y " "" "" "" "" "" "+ B V.w. Q G.b " "" "" "- J R.i[ B M.j" "- Q R.a- K V.v " "" "" "- M S.b> W O.i " "" "" "" "" "" "" "" "" "+ C D.t+ T X.o " "" "" "" "" "" "" "" "" "< S C.m] T F.f " "" "" "" "" "" "" "" "" "" "> E Q.z- O B.w " "" "" "" "" "" "" ". Z T.a+ X L.t" "+ H U.f+ B E.x " "" "" "" "" "" "" "" "+ K A.c+ A E.p " "" "" "" "" "+ S N.v+ P P.h " "" "" "" "" "" "" "" "+ R C.f+ I I.y " "" "" "" "" "" "" "" "" "+ N C.h. U P.x " "" "" "" "" "" "" "- D Q.c- I K.k " "" "" "" "" "" "" "" "" "- U U.c- A X.j " "" "" "" "" "" "" "" "" "" "- N B.u. A J.p " "" "" "" "" "[ N K.j+ L H.t " "" "" "" "" "+ D E.j> T Q.c" "- B U.z- A N.e " "" "" "- C J.k< D O.n " "" "" "" "" "" "" "" "" "] O U.c> Z J.e " "" "" "" "" "" "+ K E.m+ B O.p" ". H S.l[ T N.r " "- Z M.e> D Q.i " "" "" "" "" "" "" "" "+ K B.v+ S P.o " "" "" "" "" "+ Q O.w< Y D.o " "" "" "" "] I C.n> R H.i " "" "" "" "" "" "" "- I F.z. L Q.t " "" "[ W U.q- A C.q " "" "" "" "- H U.l- V P.f " "" "" "- J Z.n> C Y.j " "" "" "" "" "" "" "+ E Y.b< J Q.g " "" "" "" "" "" "] F W.x> X H.c " "" "+ Z X.r+ O K.g " "" "" "" "+ Y Q.f. X Z.d " "" "" "" "" "" "" "[ O G.z- F K.u " "" "> P Z.o+ M D.s " "" "" "" "" "" "" "" "+ L G.h+ Z M.l " "" "" "" "" "" "" "" "" "" "< J L.y] O U.x " "" "" "" "" "> L K.q+ P U.c " "" "" "" ". F H.l+ X W.j " "" "" "" "" "" "" "+ N I.x. U A.u " "" "" "" "" "" "" "" "- Y B.m[ X W.a " "" "" "" "" "" "" "" "" "" "- B X.u- V G.w " "" "" "" "" "- D N.d> M Q.g " "" "" "" "" "" "" "" "+ I I.w< E P.u " "" "] F V.k> I U.s " "" "" "" "" "" "" "- F P.b- B H.u " "" "" "" "" "" ". J X.n+ G E.e " "" "" "" "" "" "" "" "" "" ". U J.t[ T C.l " "" "" "" "" "- O K.g> T L.r " "" "" "" "" "" "" "" "+ W A.a+ O Z.g " "" "+ A N.e< Q N.q " "" "" "" "" "] W U.k> Y J.w " "" "" "" "" "" "" "" "" "+ V V.k+ Y L.w " "" "" "" ". S V.k+ P C.h " "" "" "" "" "" "+ C G.v+ N F.d " "" "" "" "" "" "" "" "" "" "+ K P.u+ R J.z " "" "+ E R.y+ I I.p " "" "" "" "" "" "" "" "" "" "+ Y H.z+ G U.v " "" "+ T E.o+ G S.g " "" "" "" ". S A.u. Z X.n " "" "- L S.x[ M X.z " "" "" "" "" "" "" "" "" "- V Z.e- S C.p " "" "" "" "" "- T H.m> E B.m " "" "" "" "" "" "" "" "" "" "+ Q T.t< N Z.g " "" "" "] R I.y> B J.k " "" "" "" "" ". V V.r- L T.x " "" "" "" "" "" "" "" "[ L Z.s- T Y.p " "" "" "" "" "" "- N A.p- W X.q " "" "" "" "" "" "" "- M D.t> Z Y.r " "" "" "" "+ B Q.u< L C.m" "] V R.j> Z D.y " "+ A C.j+ P S.w " "" "" "" ". V K.r- E N.s " "" "" "" "" "- C F.n- Q B.p " "" "" "" "" "" "[ R E.d- H Y.r " "" "" "" "" "" "> H D.v+ X E.h" "+ V R.j+ C C.m " "+ C Q.j< Q X.b " "" "" "" "" "" "" "" "" "] Y J.g> K Y.s " "" "" "" "" "" "" "" ". T R.i- K R.f " "" "" "" "" "" "" "" "- B U.o- Z I.n " "" "" "" "" "" "" "" "- I X.s- G D.p" "- B C.i- K G.c " "- V G.i- P Y.f " "" "" "" "- V G.t- U D.s " "" "" "" "" "" "" "" "" "- K P.f. F X.m " "" "" "" "" "- O B.l- S C.e " "" "" "" "" "" "- B K.l. D Z.f " "" "- U K.m- J F.z " "" "" "" "[ H N.l- D G.i " "" "" "" "" "" "" "" "" "- Y T.u- Z R.s " "" "> Z O.p+ D V.g" "< Q W.w] W K.w " "" "" "" "" "" "> O V.l- I A.w " "" "" "" "" "" "" ". B L.j+ H C.k " "" "" "" "" "" "" "+ B W.w[ H T.q " "" "" "" "" "" "" "" "- Z F.z- H S.u" "- K B.j> M T.w " "" "" "" "" "" "" "+ Q N.d+ G K.a " "" "" "" "" "" "< W U.e] H M.u " "" "" "" "" "> B Q.u. O J.r " "" "" "" "" "" "" "" "- Z G.n- H K.i " "" "" "" "" "" "" "" "" "- I E.j- X U.y " "" "" "" "" "- L O.u- J D.h " "" "" "- X F.q- P J.v " "" "- E T.u- X M.c " "" "" "" "" "- S P.y. U S.z " "" "" "" "" "" "" "" "" "+ E C.l+ S N.y " "" "+ T N.r+ J F.s " "" "" "" "" "" "" "" "+ U I.x+ I P.o " "" "" "" "+ F Z.e+ P E.k " "" "" "" "" "" "" "+ G J.k+ X Y.w " "" "" "" "" "" "" "+ Z Z.d+ Y B.b " "" "+ F A.d. R W.p " "" "" "- M A.z- Y R.l " "" "" "" "" "" "" "- Z L.a- E X.h " "" "" "" "" "" "" "" "" "" "- I G.d- H J.b " "" "- U E.n. H X.k " "" "" "- V E.s- S F.h " "" "" "" "[ L A.x- A C.l " "" "" "" "- P O.q- X J.x " "" "" "> M X.u+ W H.s " "" "" "< H T.p] V U.o " "" "" "" "" "> P Z.v- C K.a " "" "" "- U J.p. V N.l " "" "" "" "" "" "" "" "" "" "[ L T.u- N K.d " "" "" "" "" "" "" "" "" "> I G.u+ Z N.g " "" "" "" "" "" "" "" "" "" "+ H K.j+ M S.h " "" "" "" "" "" "" "" "< F M.t] D J.z " "" "" "" "" "" "" "> E K.d+ J M.c " "" "" "" "" "" "" "" "" "+ O M.u. A P.k " "" "" "" "" "" "" "" "" "+ R V.v+ U I.e " "" "+ Z C.m+ L L.m " "" "" "" "" "+ B Z.d+ O R.s " "" "" "" "" "" ". B D.m- W R.x " "" "" "" "" "" "" "" "- W H.b. S R.g " "" "- Y N.a- P L.b " "" "" "" "" "" "" "" "[ T M.k- D H.x " "" "" "" "" "" "" "" "" "- P I.s- U A.z " "" "" "" "> E B.m+ O I.t " "" "" "" "" "< T N.c] A D.t " "" "" "> Q I.y- Z P.y " "" "" "" "" "" "" "" "" ". M B.t- N E.j " "" "" "- K T.z- Y S.p " "" "" "" "" "" "" "" "[ D J.x- V R.z" "> R Q.i+ C G.h " "" "+ Z V.a+ U C.n " "" "" "" "" "" "" "" "+ D U.s< W C.x " "" "" "" "" "" "] F A.j> J L.h " "" "" "" "" "" ". N U.r- R F.n " "" "" "" "" "- V N.s- T L.n " "" "" "" "- V E.i- T G.n" "- O M.r- Z A.g " "" "" "" "" "" "" "- A Q.h- S Z.n " "" "" "" "" "" "- Q G.q- L X.p " "" "- Z D.k. M C.a" "- P M.e- V S.u " "" "" "" "" "" "" "- S I.k- B W.o " "" "" "" "" "" "" "" "" "" "- C W.o- U U.m " "" "" "" "" "" "" "" "" "- V C.o. Q F.i " "" "" "" "" "" "" "" "" "" "- P N.w- S Y.l " "" "" "" "" "" "" "" "" "" "[ J R.h- D A.k " "" "" "" "" "" "" "" "" "" "- N A.o- Q L.g " "" "> P L.c+ L T.n " "" "" "" "" "" "" "< O W.o] P O.v " "" "" "" "" "" "> K G.h- T O.j " "" "" "" "" ". P J.u[ O W.x " "" "" "" "" "" "- I F.c- N Z.c" "- S U.e- L D.y " "" "" "" "" "" "" "" "" "" "> E Y.l+ X Y.l " "" "" "" "" "" "< L S.q] P K.c " "" "" "" "" "" "" "> D V.l+ M F.a " "" "" "" "" "" "" "" "+ F F.f+ C N.z " "" "" "" "" "" "" "" ". E D.d- P J.p " "" "" "" "" "" "- Q Z.c- E T.w " "" "" "" "" "[ O E.t- C G.w " "" "" "" "" "" "> D F.a+ S X.d " "" "" "" "+ V Z.a+ O V.x " "" "" "" "" "" "" "" "" "+ I Z.z< N H.f " "" "" "" "" "] E L.n> U V.m " "" "" "" ". G E.r- P T.n " "" "" "" "" "" "- H U.p- N J.v " "" "" "" "" "" "" "" "" "" "- D W.g- Q P.f " "" "" "" "" "" "- I S.w- L L.d " "" "" "" "" "" "" "" "- O S.j- I W.u " "" "" "" "" "" "" "" "- F J.m- Q D.s " "" "" "- T C.v. F L.z " "" "" "" "" "" "" "" "+ C J.k. Z B.m " "" "" "" "" "" "" "" "" "" "+ Y J.r+ B G.n " "" "" "" "" "" "" "" "" "+ P P.c+ T F.x " "" "" "" "" "" "" "" "" "" "+ U A.k+ A W.x " "" "" "" "" "" "" "" "" "+ L R.s+ U U.b " "" "" "" "" "" "" "" "+ Z B.t+ C J.g " "" "" "" ". Z Q.v+ Q W.l " "" "" "[ M C.i- J A.p" "- N V.p- V V.s " "" "- V O.v> M C.w " "" "" "" "" "" "" "" "+ M O.f< I U.j" "] A G.b> Z D.z " "" "" "" "" "+ O J.h+ X K.u " "" "" "" "" "" "" "+ Y I.r. Y E.u " "" "" "" "" "" "" "" "" "- V P.s- R I.g " "" "- Q J.u[ V I.e " "" "" "" "" "- D B.g- C Z.f " "" "" "" "" "" "" "- C E.f- U K.k " "" "" "" "" "" "" "" "" "- Z P.e> D N.y " "" "" "" "" "+ V K.k+ A J.b" "< C E.l] B E.t " "" "" "> D R.p. D L.a " "" "" "" "+ A H.q+ H Y.w " "" "" "" "+ K A.o. M X.k " "" "" "" "- M C.o- B N.c " "" "- F T.w- J F.u " "" "" "" "" "- N Q.i- W K.j " "" "" "- D V.q. E W.g " "" "" "+ C X.p+ R T.y" "+ R P.j+ B S.a " "" "+ D B.i. M G.c" "+ N B.l[ I N.x " "" "" "" "" "" "" "" "" "- Z R.w- P W.n " "" "" "" "" "" "" "" "- C B.h- R P.m " "" "" "" "> S I.t+ H L.n " "" "" "" "" "" "" "" "< G O.e] T Z.w " "" "" "" "" "" "> A Q.k+ N V.q " "" "" "" "" "+ E S.y+ D C.n " "" "" "" ". U E.f- Z A.p" "[ Y C.q- D O.p " "" "" "" "" "" "" "- D R.g- M A.k " "" "" "" "" "> Q D.j+ D E.r " "" "" "" "+ W W.p< E T.y " "" "" "" "" "" "" "" "" "] V P.g> G E.x " "" "" "- L O.p. S P.r " "" "" "" "" "" "" "" "+ B F.q+ G X.x " "" "" "" "" "" "" "" "" "" "+ W X.q+ O E.o" "+ E Z.v. Q G.w " "[ H H.n- C F.x " "" "" "- N L.j- Z N.t " "" "" "" "" "" "" "" "- L G.e- F Y.y " "" "" "" "" "" "" "" "> C L.l+ T R.l " "" "" "" "" "" "" "" "" "" "+ Q F.e< Z D.g " "" "" "" "" "" "" "" "" "" "] W I.i> S T.z " "" "" "" "+ V Z.s+ Y W.r " "" "" "" "" "" "" "" ". R C.e+ O A.d " "" "" "" "" "" "" "" "" "+ J P.b[ H W.i " "" "" "" "" "" "- L F.u- H D.k" "- H Q.w> L Y.c " "" "" "" "" "" "" "" "+ B F.p+ J U.y " "" "" "< X U.c] N E.p " "" "" "" "" "" "" "" "" "> W M.k. J W.n " "" "" "> C K.i- T R.l " "" "" "" "" "" "" "" "" "" "[ S A.c- D W.w " "" "" "" "" "" "" "" "" "" "- R I.g- M F.p " "" "" "" "" "" "" "" "" "> I V.e+ Q U.j " "" "" "< T U.p] I C.j " "" "" "" "" "> W E.t- U O.y " "" "" "" "" "- I S.l. H M.t " "" "" "" "[ A Z.w- F H.x " "" "" "" "" "" "" "" "" "- M A.p- S J.k " "" "" "" "" "" "" "" "" "" "> F X.s+ F A.a" "< P A.c] I G.r " "" "> Y W.m- K F.l " "" "" "" "" "" "" "- V W.e. G Q.u " "" "" "" "" "" "" "" "" "" "+ S C.t+ F W.y " "" "" "" "+ I S.v. N Y.k " "" "" "" "" "" "" "" "" "" ". U Q.f+ V K.f " "" "+ N S.m+ W Y.u " "" "" "+ X X.j+ I I.m " "" "" "" "" "" "+ V I.g+ B Z.f" ". Q Q.q- L A.e " "" "" "" "" "" "[ F O.w- Z K.v " "" "- P I.b- M X.r " "" "" "" "" "" "- H O.n> I R.e " "" "" "+ V S.b< P U.a " "" "" "" "] Y G.g> S C.l " "" "" "" "" "" "" "" "" "+ X I.z+ P I.n""";import ast
print(ast.literal_eval(input())+ast.literal_eval(input()))

```
> 2 votes

# Answer
# Python 3 - Hello, World!

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

```

(Second language technically doesn't print a newline, but the interpreter adds one automatically)

...I just realised that I failed to read the date of the challenge, and the secondary language postdates the challenge. Many apologies.
> 1 votes

# Answer
# 05AB1E, 7 bytes, safe

```
”Ÿ™,‚ï!

```

Try it online!

Also works in

* 05AB1E (legacy)
* 2sable
> 0 votes

# Answer
# \>\<\>, 39 bytes, safe

```
vdvII$$$$$$$$$>r+n;O@
>ri68*-i~i68*-^u

```

Try it online!

Works in \>\<\>, Gol\>\<\>, somehow not \*\>\<\>, and *Backhand*.

## Explanation

```
vdv                   Push the speed down twice
   II                 Take 2 inputs
     $$$$$$$$$>r      A bunch of stuff that do nothing
                +     Add
                 n;   More nothing
                   O  Output
                    @ End

```
> 0 votes

# Answer
# Hello, World!, cracked

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

```

This works in Python, Lisp, and ~~one other language~~ Deadfish~.
> -1 votes

---
Tags: popularity-contest, cops-and-robbers, polyglot
---


# Question
Title: Robbers: Smallest subset of characters required for Turing Completeness
**This is the robbers' challenge. The cops' one is here.**

In Fewest (distinct) characters for Turing Completeness, the goal is to find the minimum number of characters which make a language Turing Complete...in other words, allow it to do any computation possible with any other language. In this challenge, we'll be doing somewhat of the opposite, and finding the minimum number of characters, without which Turing Completeness is impossible.

**Task:**

Robbers should include an explanation of how Turing Completeness can be achieved without any characters in the cop, or a proof that this is impossible.

**Scoring:**

Scoring, as per normal robbers' rules, is that whoever cracks the most cops wins.

**Chat room:** https://chat.stackexchange.com/rooms/136437/smallest-subset-of-characters-required-for-turing-completeness

# Answer
> 12 votes
# Python, cracks Felipe Soares

```
class   X:__class_getitem__=exec
X["print\50'Hello,\40world!')"]

```

Lack of spaces is no problem because you can use tabs. Calling an arbitrary function without parentheses is tricky but possible.

# Answer
> 10 votes
# Python, cracks pxeger

```
__builtins__.__dict__["\x65x\x65c"]("<stuff>")
```

Attempt This Online!

Replace the `<stuff>` with code you want to execute, escaping the banned chars.

# Answer
> 8 votes
# tinylisp, cracks des54321's answer

```
(d A (q (
  (y x)
  (v (c (h x)
       (c
        (c (q q) (c y ()))
        (t x))))
)))
(d K (q (
  (x)
  (c (q K1) (c (c (q q) (c x ())) ()))
)))
(d K1 (q (
  (y x)
  x
)))
(d S (q (
  (x)
  (c (q S1) (c (c (q q) (c x ())) ()))
)))
(d S1 (q (
  (y x)
  (c (q S2) (c (c (q q) (c y ())) (c (c (q q) (c x ())) ())))
)))
(d S2 (q (
  (z y x)
  (A (A z y) (A z x))
)))

```

Try it online! (The three examples are the identity combinator `(S K K)`, the mockingbird combinator `(S (S K K) (S K K))`, and an infinite loop, so you'll need to halt the program to see the output from the first two.)

This is an interpreter for SK combinator calculus (which is Turing complete), built in tinylisp-without-`i`.

## Usage, and principles behind this

The basic idea is to do control flow via `v`, which lets us inspect an atom via using it as the name of a function. As is usual in implementations of combinator calculus, we make use of five families of combinators (`S` and `K` themselves, plus partially applied versions of them; `K` can be given one argument to produce `K1`, `S` can be given one or two arguments to produce `S1` or `S2`).

In order to be able to use these for control flow with `v`, we store our combinators in a form that looks like a tinylisp function call but with one argument missing, and the arguments in reverse order:

* `S` is stored as `(S)`;
* `K` is stored as `(K)`;
* `S` applied to one argument *x* is stored as `(S1 (q *x*))`;
* `K` applied to one argument *x* is stored as `(K1 (q *x*))`;
* `S` applied to two arguments *x* and *y* is stored as `(S2 (q *y*) (q *x*))`.

Our combinator application operator `A` works by inserting the argument it's being given as the second element of the function it's given, in the form `(q *arg*)` (thus producing a complete tinylisp function call), and then evaluating it with `v`. (This is the reason that the arguments have to be reversed – we can't insert a value at the *end* of a list of unknown length when we have no workable control flow, but we can insert an element in any specific position relative to the start via using hardcoded chains of `h` and `t`.) `A` can be used directly to write programs (allowing specification of arbitrarily complex input), and is used indirectly in the implementation of `S2` (which is what makes loops possible).

To write a complete program, you write `S` as `(q (S))`, `K` as `(q (K))`, and application of *f* to *x* as `(A *x* *f*)` (I decided to consistently reverse arguments everywhere, which is probably less confusing then reversing them only in some places). For example, the implementation of the identity function, which in Lisp syntax would be `(S K K)`, looks like this when used as input to this interpreter:

```
(A (q (K)) (A (q (K)) (q (S))))

```

## Explanation

Most of this program is just list manipulation, building up lists from templates. The "inside" of most of these is the fragment `(c (q q) (c x ()))`. `(c x ())` inserts (`c`) `x` as the first element of an empty list (`()`), thus producing `(x)`. The fragment as a whole inserts (`c`) a literal `q` (`(q q)`) as the first element of that, thus producing `(q x)`. The same technique is then repeated to produce a list whose elements are of the form `(q x)` and which starts with an appropriate combinator, and this is the only thing done in the implementations of `S`, `S1` and `K`.

`A` is very similar – the only differences are that the resulting list is evaluated as tinylisp code (`v`) rather than simply being returned, and that the list is constructed as the head of the function (`(h x)`), followed by the argument formatted as `(q y)`, followed by any arguments that may have been curried into the combinator (this is the tail of x, `(t x)`).

`K1` and `S2` contain all the actual logic, and are implementations of the `K` and `S` combinators, as per the definition of SK combinator calculus; `K` returns its first argument `x` and ignores its second argument `Y`, whereas `S` returns `(A (A z y) (A z x))` (which can simply be written directly in the function body).

# Answer
> 7 votes
# C (nonportable), cracks Pyautogui's answer

```
const char main[]="\x48\x8d\x35\xf9\xff\xff\xff\xbf\x01\x00\x00\x00\x89\xf8\x89\xfa\x0f\x05\xeb\xf8";

```

Try it online!

Very platform- and compiler-specific. This worked on old versions of tcc, but not on the current version. On my computer and on TIO, it works on current gcc with the `-zexecstack` command-line option, but not without. On platforms with no memory protection (e.g. DOS), this should work on pretty much any compiler (although you would of course need to change the contents of the string literal to fit the platform you were running on).

The basic idea is to run arbitrary machine code by misinterpreting a string literal as a function (the "function" given above prints the letter `H` – its own first byte – infinitely many times, if run on a Linux x86-64 system). In C, type-checking is done only by the compiler, not the linker, so if you place a string literal in one translation unit (i.e. file) and a function call to it in a different translation unit, neither the compiler nor the linker will notice that one unit declared the symbol in question to be a function but the other declared it to be a character array. (Function pointers and character array pointers are the same width on most platforms, which is all the linker cares about, so it'll happily misinterpret one as the other.)

How to call a function without `(`? We can't write the function call, but luckily there's an implicit call to `main` at the start of the program, and as a bonus, the implicit call is in a different file (one provided by the C implementation) than our program is, so neither the compiler nor the linker will produce an error (although several compilers have a warning for this sort of thing nowadays). So as long as our string literal is used to initialise a variable named `main`, it'll get called automatically.

Further reading: @Dennis discussing how to various get C implementations to run a variable as though it were a function.

# Answer
> 7 votes
# R, cracks Dominic van Essen

```
autoload -> `%aut%`
'%>%' %aut% 'magrittr'
'1+1' %>% str2expression %>% eval
```

Replace '1+1' with arbitrary expressions, using unicode characters as necessary.

Unfortunately was not able to run on TIO due to needing R version \>=3.6 for `str2expression`. Does work on rdrr.io.

This uses `->` which is not banned unlike `<-` and `=` to create an infix version of `autoload`, which is used to give me `magrittr` pipes, which can then be used to evaluate arbitrary strings.

# Answer
> 6 votes
# Batch script, cracks Yousername

Conditional control flow is still possible using `goto` instructions with variables, like this:

```
set /a cond = 1+1
goto tag%cond%
:tag1
echo foo
goto end
:tag2
echo bar
goto end
:end

```

Where the `set /a` instruction allows you to set a variable to the result of an expression, and this variable can then be used as part of a label for a `goto` instruction.

This allows arbitrary flow control, and therefore should make Batch scripts Turing complete without `if` statements

# Answer
> 6 votes
# C# (Visual C# Compiler), cracks Not A Chair's answer

Brainfuck interpreter, updated to crack the third cop (`.=;`). Input by command line arguments; I couldn't figure out how to do output without `.`, but IO is not necessary for Turing-completeness. Maybe it's possible to do it by using something from the namespace `System.Linq.Expressions`.

```
namespace System {
namespace Collections {
namespace Generic {
	class MyList : Dictionary<int, byte>
	{
		public MyList(string s, string inp)
		{
			if(0 is var pc) {}
			if(0 is var i) {}
			if(0 is var inp_i) {}
		 	if(TryAdd(i, 0) is int) {}
			try { // to exit cleanly at end of program
			while(true)
			{
				if((s[pc] ^ '+') < 1) if(Set(i,(byte)-~this[i]) is int) {}
				if((s[pc] ^ '-') < 1) if(Set(i,(byte)~-this[i]) is int) {}
				if((s[pc] ^ '>') < 1)
				{
					if(i++ < 0) {}
					if(TryAdd(i, 0) is int) {}
				}
				if((s[pc] ^ '<') < 1)
				{
					if(i-- < 0) {}
					if(TryAdd(i, 0) is int) {}
				}
				//if((s[pc] ^ 46) < 1 && Console.Write((char)this[i]) is int) {} // uncomment for output
				if((s[pc] ^ ',') < 1)
				{
					try
					{
						if(Set(i, (byte)inp[inp_i++]) is int) {}
					} catch { }
				}
				if((s[pc] ^ '[') < 1 && this[i] < 1)
				{
					if(1 is var bal) {}
					if(pc++ > 0) {}
					while(bal > 0)
					{
						if((s[pc] ^ '[') < 1 && bal++ < 0) {}
						if((s[pc] ^ ']') < 1 && bal-- < 0) {}
						if(pc++ > 0) {}
					}
					if(pc-- < 0) {}
				}
				if((s[pc] ^ ']') < 1 && this[i] > 0)
				{
					if(1 is var bal) {}
					if(pc-- > 0) {}
					while(bal > 0)
					{
						if((s[pc] ^ ']') < 1 && bal++ < 0) {}
						if((s[pc] ^ '[') < 1 && bal-- < 0) {}
						if(pc-- > 0) {}
					}
				}
				if(pc++ < 0) {}
			}
			} catch {}
		}
		void Set(int i, byte s)
		{
			try { if(Remove(i) is int){} } catch {}
			if(Add(i, s) is int) {}
		}
	}

	class Program {
		static void Main(string[] args) {
			try {
				if(new MyList(args[0], args[1]) is var x) {}
			} catch {
				if(new MyList(args[0], "") is var x) {}
			}

		}
	}
}}}

```

Try it online!

# Answer
> 6 votes
# Haskell, cracks Unrelated String's second answer

The basic idea is to define a function `a` that makes it possible to write `a[x][y]` instead of `(x y)`. Here's the definition, and an example of using it:

```
a[x][y]=head[x]y
main=a[putStrLn][a[reverse]["codegolf"]]

```

Try it online!

This works around the bans on horizontal whitespace and on parentheses; function arguments are now separated by `][` rather than whitespace, and because each argument is surrounded by square brackets, there's no need for any further grouping characters. Haskell uses currying for functions that take multiple arguments, meaning that `a` can handle these too (`f x y` becomes `a[a[f][x]][y]`), and we don't need a special case for them.

It's also possible to define functions using similar syntax, including defining functions by cases (e.g. `f[0]=1` and on the next line `f[1]=3`); these don't need `a` to call because they have the square brackets built in, but otherwise work the same way (the square brackets still handle the grouping).

This means that most of the core functionality of Haskell is available – we can call most of the built-in functions, and define our own, including conditionals. That's a Turing-complete subset (loops via recursion and conditionals via functions-defined-by-cases are available, in addition to complex data structures), so the ban on whitespace and parentheses doesn't really hurt at all, and `{` and `$` aren't required to make this subset work either.

## Explanation

`head[x]` trivially evaluates to `x` – it's taking the first element of a 1-element list. The advantage over using `x` directly is that it ends with a non-identifier character, meaning that we can put a letter directly after it without needing to use whitespace.

`a[x][y]=` is a pattern match, used to define a function `a`; it defines the function only in the case where it's given two single-element lists as arguments, and defines `x` and `y` to be their arguments. As such, if we call `a` as `a[x][y]`, then the `x` and `y` in the definition of `a` will be the same as the `x` and `y` at the call site. (It would be possible to give further definitions to cover the cases where `x` and `y` aren't single-element lists, but this isn't necessary to make the answer work.)

# Answer
> 5 votes
# Python, cracks pxeger's other answer

```
__import__('os').__dict__.pop('syst\x65m')('ls -la')
```

Attempt This Online!

# Answer
> 4 votes
# Cracks Unrelated String's Haskell answer

```
main=fix{--}id
```

Attempt This Online!

You can do function application by inserting an empty block comment between the function and its argument. Here I made a loop just to demonstrate.

# Answer
> 4 votes
# Headass, cracks `E` by thejonymyster

This is Turing complete because it can simulate a Minsky machine with two registers.

r1 and r2 will be used as the two registers of the Minsky machine. r3 will store the state.

The program has the following structure: `*initialisation* { *state handlers* ;}:;`

Each non-halting state, with one exception, has a positive state number and a state handler of the form `>>+<sup>*state number*</sup>) *core* :` (the superscript denotes repetition). `>>` sets r0 to 0, then the `+`s increase it to the state number, and the `)` checks if that equals the current state. If it does, the core executes, and then the `:` jumps to after the first `;`. Otherwise, the `)` jumps to after the `:`, continuing execution into the next state handler.

The exception is the last non-halting state, which omits the `:`, so that a mismatch instead jumps to the `:` *outside* the loop, ending the execution.

The core of a state handler has these four possibilities:

* **Increment r1 and change to state s**: `D+^>>+<sup>s</sup>(`
* **Increment r2 and change to state s**: `>>]+[+<sup>s</sup>(`
* **If r1 is zero, change to state s; otherwise decrement it and change to state t**: `>>+<sup>s</sup>(D^+<sup>s</sup>>)D-^>>+<sup>t</sup>(`
* **If r2 is zero, change to state s; otherwise decrement it and change to state t**: `>>+<sup>s</sup>(<]>)>>]-[+<sup>t</sup>(`

For both of the decrement cases, the state handler for state s must come after the decrementing one; otherwise, the program will incorrectly stop. This can be ensured by rearranging the state handlers or, if necessary, inserting extra states in between.

Finally, the initialisation is `D>>+<sup>a</sup>^>>+<sup>b</sup>[+<sup>s</sup>(` to set r1 to *a*, r2 to *b*, and the state (r3) to *s*.

# Answer
> 4 votes
# LOLCODE, cracks Pyautogui's answer

So it turns out that in LOLCODE, you can use a variable as a loop variable even if it hasn't been declared, and then assign to it and otherwise treat it as a normal variable while you're still inside the loop:

```
HAI 1.2
IM IN YR ROUTER UPPIN YR HAX WILE DIFFRINT HAX AN 8388607
HAX R DIFF OF HAX AN PRODUKT OF HAX AN -1
IM OUTTA YR ROUTER
KTHXBYE

```

Try it online! (Adds a `VISIBLE HAX` to show what's happening in the program; this can't be included in the crack itself due to `VISIBLE` containing an `S`.)

This means that it's fairly easy to work around the inability to use `S` for variable declaration, at least for integer variables; simply create a lot of nested loops that declare all the variables you need, then run your entire program on the first iteration of those loops. (You can break out of the loops via setting all the variables to known values other than 0, and using those known values as the sentinels which terminate the loops.)

Other uses of `S`, and how to work around them:

* `SUM`: instead of adding, multiply the right-hand side by -1 and subtract (as shown in the code sample above)
* `SMALLR`: multiply by sides by -1, use `BIGGR` then multiply the result by -1
* `QUOSHUNT`: represent every number as a pair of numbers, a numerator and a denominator, effectively treating it as a rational; to multiply, multiply the numerators and denominators; to divide, multiply one number's numberator by the other's denominator and vice versa; addition, subtraction and comparison can be done by multiplying each number's numerator and denominator by the other's denominator first; if the rounding behaviour of integer division is required, you can subtract the numerator modulo the denominator from the denominator; if a crash on division by zero is required, you can manually check for the denominator being zero and exit the program manually via setting all the variables to values that will cause it to drop out of loops
* `BOTH SAEM`: replace with `NOT DIFFRINT`
* `VISIBLE`: there's no replacement for this, but I/O is not needed for Turing completeness
* `IF U SAY SO`: there's no direct replacement for this, so you have to write the program without using functions
* `SMOOSH`: there's no direct replacement for this, so you have to write the program without using strings other than string literals

The `S` in `SMOOSH` almost leads to a difficult philosophical problem: is LOLCODE Turing-complete without functions or calculated strings? The issue is that the stock LOLCODE interpreter has limits on the size of integers, and on the length of strings, but only the former is mentioned in the specification. If you consider both limits to be implementation details that don't block Turing-completeness, then the language is Turing-complete – you can use bignum integers to implement, e.g., Blindfolded Arithmetic. If you consider integers to be limited size but strings to be unlimited size, then the language is not Turing-complete without `S` due to the inability to store arbitrary amounts of data – there's no way but `SMOOSH` to create new strings. Fortunately, the problem was probably resolved in advance by the cop question itself (which specifies that "actual 'Turing Completeness'" is not required when running into "things like maximum sizes for pointers" – the issue of maximum integer sizes seems to be comparable, although we might need a clarification from the OP to make sure), so I hope that this is a valid crack.

# Answer
> 3 votes
# Nim, cracks Pyautogui's answer

```
proc main =
  asm ".intel_syntax noprefix\nlea rdi, [rip+xyz]\ncall system\nxor edi, edi\ncall exit\nxyz\x3a\n.asciz \"ls -la /\"\n.att_syntax prefix"

main()

```

I don't know Nim, but you didn't block assembly statements. This crack may need to be modified depending on the system and compiler parameters (this assumes the C backend and a Unix-like x86-64 system). Of course, it is possible to perform arbitrary computation in assembly without using the shell.

Attempt This Online!

---
Tags: restricted-source, cops-and-robbers
---


title: Download a file from the Internet

text:
# Question
Title: Download a file from the Internet
# Introduction

Yes, it's as simple as that. Download any file from the internet!

# Rules

You must use your language's API.

You must output the file you downloaded to STDOUT, the console, a file, etc.

Input should be empty, or the URL you wish to download, but the url must count to byte count..

Good luck!

# Answer
> 16 votes
# Bash, ~~21~~ ~~17~~ ~~11~~ ~~9~~ 7 bytes

```
curl ai

```

# Answer
> 13 votes
# Röda, 29 bytes

```
{saveResource"http://ai","a"}

```

This is an anonymous function that creates a file `a` containing the HTML code of `http://ai`.

# Answer
> 6 votes
# MATL, 8 bytes

```
'v.ht'Xi

```

The URL provided to `Xi` (`urlread`) is prepended with `http://` if it isn't already. Additionally the output of `urlread` contains the contents of the response and this is implicitly printed when the program exits.

Unfortunately this does not work for the online compilers since loading data from an arbitrary URL is disallowed in online-mode, so here's a GIF.

# Answer
> 6 votes
# Bash, ~~45~~ 43 bytes

```
exec 3<>/dev/tcp/ai/80;echo GET />&3;cat<&3

```

opens a tcp socket with ai site on file descriptor 3, issues a get, and cats the result. perhaps can be golfed further.

# Answer
> 5 votes
# PowerShell, 7 Bytes

Since we're all using `www.ai`...

```
irm ai.

```

uses `Invoke-RestMethod` \- prints the result to StdOut

alternate answer, saves to file named 'a' in run directory, using `Invoke-WebRequest` and `-OutFile` param.

```
iwr ai. -OutF a

```

# Answer
> 4 votes
## Mathematica 18 Bytes

```
URLDownload@"v.ht"

```

# Answer
> 4 votes
## C#, 96 93 bytes

```
async()=>Console.Write(await new System.Net.Http.HttpClient().GetStringAsync("http://3.ly"));

```

# Answer
> 3 votes
# JS (ES6), ~~38~~ ~~36~~ ~~31~~ 29 bytes

```
fetch`//ai`.then(x=>x.text())

```

Depending on the promise consensus, (41 bytes)

```
fetch`//ai`.then(x=>x.text()).then(alert)

```

# Answer
> 3 votes
# PHP, 22 bytes

If `allow_url_include=1` is in your ini file:

```
<?=include"http://ai";

```

# Answer
> 3 votes
# C (Clang, ARMv7-a Linux/Android, AT&T Wireless), 162 bytes

Since we're hardcoding URLs, why not hardcode ISPs?

```
main(s){int b[500]={5<<28|2,**((int***)gethostbyname("ai"))[4]};connect(s=socket(2,1,0),b,16);write(s,"GET / HTTP/1.0\n\n",16);read(s,b,-1);read(s,b,-1);puts(b);}

```

I can't show a demo because none of the demos have online enabled :(

This abuses two things. One is that I assume `http://ai` is smaller than 2000 bytes and just casually read a max of 4GB onto the stack (what could possibly go wrong), and two is that I take advantage of how I discovered that AT&T Wireless converts `\n` to `\r\n` in HTTP requests for some reason (new data saving hack?).

Termux screenshot, showing how it works on data (AT&T via Cricket) but *not* on my Wi-Fi (Xfinity).

Ungolfed and commented:

**note**: I have removed the punning and buffer reusing for this.

```
#include <unistd.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>

int main(void)
{
    // Look up the IP address of http://ai
    // Note that I mess around with type punning and the documented
    // layout of the structure in the golfed version.
    struct hostent *ent = gethostbyname("ai");
    // Extract the first IP address (already in network order)
    uint32_t ip;
    memcpy(&ip, ent->h_addr_list[0], sizeof(uint32_t));
    // Create the sockaddr struct
    struct sockaddr_in header = (struct sockaddr_in) {
        .sin_family = AF_INET,
        .sin_port = htons(80),
        .sin_addr = { ip }
    };
    // Copy over to the pun
    struct sockaddr_storage header_raw;
    memcpy(&header_raw, &header, sizeof(header));

    // Create an IPv4 socket
    int soc = socket(AF_INET, SOCK_STREAM, 0);
    // Connect the socket to the interwebs
    connect(soc, (const struct sockaddr *)&header_raw, sizeof(header_raw));

    // Send an HTTP GET request
    // Note that because It Works™ on AT&T, I use \n instead of the proper \r\n. Two newlines are still required though.
#ifdef ATT
    const char get_request[] = "GET / HTTP/1.0\n\n";
#else
    const char get_request[] = "GET / HTTP/1.0\r\n\r\n";
#endif
    write(soc, get_request, strlen(get_request));

    char buf[2000] = {0};
    // Note: I use -1 to just read the entire thing. Hopefully it is all shorter than
    // 1999 chars :P
#ifdef BUF_HACK
    size_t len = -1;
#else
    size_t len = sizeof(buf) - 1;
#endif
    // Receive the HTTP response header
    read(soc, buf, len);
    // But ignore it because I don't care about parsing HTTP stuff
    // Just read again for the real data
    read(soc, buf, len);
    // Print to stdout (assuming the HTTP header was shorter)
    puts(buf);
    // I don't actually bother closing the socket in the golfed code, sue me.
#ifndef RESOURCE_HOG
    close(soc);
#endif
}

```

I just decided to see how painful this was, I knew before I started that it didn't have a chance.

# Answer
> 2 votes
# Python 2, ~~55~~ ~~49~~ 47 bytes

~~Not shorter but~~ I really thought I could go further.

```
from urllib import*
urlopen('http://ai').read

```

# Answer
> 2 votes
# R, 24 bytes

```
readLines('http://g.co')

```

prints the output to console in the usual R format -- vector of strings, one element per line of the site.

# Answer
> 2 votes
# Mathematica, 13 bytes

```
URLFetch@"ai"

```

# Answer
> 1 votes
# Vim Ex command, 14 bytes

```
e http://3.ly/

```

Opens the URL as a new buffer. Netrw seriously suffers from a restrictive URL format.

# Answer
> 1 votes
## nc -v v.ht 80 \< file - 31 bytes

Where file contains:

```
GET / HTTP/1.1\r\n
Host: v.ht\r\n
\r\n

```

I profess ignorance about how I should score this. The file is 31 bytes and contains the URL I want, the `-v` flag value decides if I get the file I want or an error response.

# Answer
> 1 votes
# Kdb+, ~~34~~ 15 bytes

**KDB+ \>= 3.4**

```
 q).Q.hg`http://ai

```

from here.

**KDB+ \< 3.4**

```
q)`:http://ai"GET / HTTP/1.0",4#"\n"
"HTTP/1.1 200 OK\r\nDate: Thu, 11 May 2017 21:45:01 GMT\r\nServer: Apache/1.3..

```

# Answer
> 1 votes
# Racket, 71 bytes

```
(require net/url)(port->string(get-pure-port(string->url"http://ai")))

```

# Answer
> 1 votes
# , 33 bytes

Sadly, this only works on the J shell.

```
load 'web/gethttp'
gethttp 'g.co'

```

# Answer
> 0 votes
# Python + requests, ~~55~~ ~~53~~ 50 bytes

```
from requests import*
print(get('http://ai').text)

```

-2 bytes by switching URLs -3 bytes thanks to ovs

# Answer
> 0 votes
# Vim, 2 + 12 = 14 bytes

```
gf

```

Expects the URL `http://3.ly/` as input. `gf` opens the current file under the cursor. Thanks to netrw, this works fine for URLs. I found this just now while trying to remember the command to open URLs in your browser (found it, it's `gx`).

# Answer
> 0 votes
# HTML, 24 bytes

```
<iframe src="http://ai">

```

This technically fails as it renders the result...

# Answer
> 0 votes
## PowerShell, 62 bytes

PowerShell 5

```
-join[char[]][net.webclient]::new().downloaddata('http://ai.')

```

66 bytes for more older versions of PowerShell

```
-join[char[]](new-object net.webclient).downloaddata('http://ai.')

```

# Answer
> 0 votes
# AHK, 31 bytes

```
URLDownloadToFile,http://g.co,g

```

There's a built-in so it's not very exciting. Try to fashion, though, the function is fairly long.

# Answer
> 0 votes
## Bash + wget, 7 bytes

```
wget ai

```

Downloads the page at http://ai

# Answer
> 0 votes
## Ruby, 27 + 10 = 37 bytes

```
puts open('http://ai').read

```

+10 bytes for `-ropen-uri` flag (to require open-uri library)

# Answer
> 0 votes
# Pyth, 4 + 11 = 15 bytes

```
jk'z

```

With URL `http://v.ht` as input. Takes an URL string as input, downloads the file, and prints its content.

Explanation:

```
jk'z
   z    Get the input string (URL)
  '     Download the file from the URL, return a list of lines
jk      Join the list on k which is the empty string

```

Note that we cannot use the function `s` for concatenating the list because of bytes types issues.

**Slightly cheating, 2 + 11 = 13 bytes** (it displays the list of the lines in the file instead of a single string for the whole file):

```
'z

```

You will need to install Pyth on your machine to test it (the online interpreter does not execute unsafe operations).

# Answer
> 0 votes
## C#, 76 bytes

```
Console.WriteLine(new System.Net.WebClient().DownloadString("http://3.ly"));

```

# Answer
> 0 votes
## MATLAB, 20 bytes

```
urlread('http://ai')

```

Nothing fancy here...

# Answer
> 0 votes
# 05AB1E, 4 bytes

```
.w

```

Beats all other answers. Takes `ai` as input.

---
Tags: code-golf, internet
---


title: Find run ascending lists faster

text:
# Question
Title: Find run ascending lists faster
In this question I asked you to determine if a run ascending list could be made. It was code-golf so naturally most the answers are very slow. But what if we want it to be *fast*. In this challenge I ask you to solve the same task except your goal will be to minimize asymptotic time complexity.

Here's the challenge restated:

> A *run ascending list* is a list such that runs of consecutive equal elements are strictly increasing in length.
>
> In this challenge you will be given a list of \\$n\\$ positive integers, \\$x\_i\\$, as input. Your task is to determine if a run ascending list can be made from the numbers \\$1\\$ to \\$n\\$ with each number \\$k\\$ appearing *exactly* \\$x\_k\\$ times.

## Rules

You should take as input a non-empty list of positive integers. You should output one of two distinct values. One if a run ascending list can be made the other if it cannot.

Your answers will be scored by their worst case asymptotic time complexity with respect to the *size* of the input.

The size of an input list \\$x\_i\\$ will be considered to be \\$\sum\_{n=0}^i 8+\lfloor\log\_2(x\_i)\rfloor\\$ bits. Although you are allowed to use formats that do not have this exact memory usage for convenience.

The brute force algorithm has a complexity of \\$O(2^n!)\\$.

The tie breaker will be .

## Testcases

Inputs that cannot make a run ascending list

```
[2,2]
[40,40]
[40,40,1]
[4,4,3]
[3,3,20]
[3,3,3,3]

```

Inputs that can make a run ascending list a potential solution is given after the `,` for clarity but is not necessary for you to compute.

```
[1], [1]
[10], [1,1,1,1,1,1,1,1,1,1]
[6,7], [1,1,1,1,1,1,2,2,2,2,2,2,2]
[7,6], [2,2,2,2,2,2,1,1,1,1,1,1,1]
[4,4,2], [1,3,3,1,1,1,2,2,2,2]
[4,4,7], [1,3,3,1,1,1,2,2,2,2,3,3,3,3,3]
[4,4,8], [1,3,3,1,1,1,2,2,2,2,3,3,3,3,3,3]

```

# Answer
Python, I'm not sure of the exact complexity. Probably exponential in the worst case.

```
import itertools

bad = set()

def run_ascending(sizes, low=1, prev=0):
    if not any(sizes):
        return True
    if any(0 < x < low for x in sizes):
        return False
    key = (low, prev) + tuple(sorted(n for n in sizes if n))
    if key in bad:
        return False
    for i, s in enumerate(sizes):
        if not s:
            continue
        if s == prev:
            prev = 0
            continue
        s = sizes[i]
        for k in itertools.chain((s,), range(low, (s + 1) // 2)):
            sizes[i] -= k
            r = run_ascending(sizes, k + 1, sizes[i])
            sizes[i] += k
            if r:
                return True
    bad.add(key)
    return False

```
> 1 votes

---
Tags: decision-problem, combinatorics, fastest-algorithm
---


title: Draw an S-Chain

text:
# Question
Title: Draw an S-Chain
# Background

When I was younger, I was taught a method of drawing a weird "S" shape, that I (along with my classmates) found fascinating. Today, I rediscovered it, and due to its formulaic approach to drawing it, thought it could lead to an interesting challenge :P

# Drawing the "S"

The S can be drawn by following these simple steps:

First, draw 2 rows of three vertical lines like so

```
| | |

| | |

```

Next, connect the top left line with the bottom middle line and the top middle with the bottom right line to produce

```
| | |
 \ \
| | |

```

Finally, draw a top and bottom on the currently drawn image so that it ends up looking like

```
  ^
 / \
| | |
 \ \
| | |
 \ /
  v

```

As you can see, this results in an "S" shape. When extended however (drawing it with more than 2 rows), it produces a very interesting pattern. Your task is reproduce this interesting pattern.

# Task

Given an integer where `n >= 2`, output The S with `n` rows to be made from it. Output may be returned from a function, and input may be taken in standard methods. Trailing/leading whitespace for both the overall image, as well as each line, is fine. However, leading line spaces must be consistent so that the " isn't broken. You may output as a list of lines.

# Test cases

```
input
output
---

2

  ^
 / \
| | |
 \ \
| | |
 \ /
  v

---

8
  ^
 / \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ /
  v

---

10

  ^
 / \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ \
| | |
 \ /
  v

```

This is a so shortest code wins! Good luck,

# Answer
> 16 votes
# Python 2, 47 bytes

```
lambda k:'  ^\n / '+'\\\n| | |\n \ '*k+'/\n  v'

```

Try it online!

# Answer
> 11 votes
# C# (.NET Core), ~~73~~ ~~69~~ ~~66~~ ~~64~~ 62 bytes

Two less bytes and perl-like appearance thanks to Barodus. Didn't think of using int? for nulls.

```
n=>$@"  ^
 / {string.Join(@"\
| | |
 \ ",new int?[++n])}/
  v"

```

Try it online!

# Answer
> 7 votes
# SOGL V0.12, ~~26~~ ~~25~~ 18 bytes

```
°I-‘*"∑ūCƨΩ)¹‘@∑5n

```

Try it Here!

Uses the same strategy as ETHproductions's Japt answer

Explanation:

```
..‘           push "\|||\"
   *          repeat input times
    "..‘      push " ^ /ŗ/ v ", with ŗ replaced with POP. The reason why there's a trailing
              space is because otherwise it didn't have enough repeating characters to compress
        @∑    join with spaces
          5n  split to line lengths of 5

```

# Answer
> 7 votes
# Python 3, 48  ~~56 59 61~~  bytes

```
lambda k:'  ^\n / %s/\n  v'%('\\\n| | |\n \ '*k)

```

Try it online!

# Answer
> 7 votes
# 05AB1E, ~~27~~ 26 bytes

```
…^
/ð"\
| | |
\ "I×…/
vJ.c

```

Try it online!

**Alternate 27 byte version**

```
'^…/ \©IF…| |û…\ \}\®R'v».c

```

Try it online!

**Explanation**

```
'^                             # push "^"
  …/ \©                        # push "/ \" and store a copy in register
       IF                      # input times do:
         …| |û                 # push "| | |"
              …\ \             # push "\ \"
                  }            # end loop
                   \           # discard top of stack (the extra "\ \")
                    ®R         # push "/ \" reversed = "\ /"
                      'v       # push "v"
                        »      # join stack on newlines
                         .c    # center each row

```

# Answer
> 7 votes
# Japt, ~~34~~ ~~25~~ 23 bytes

```
" ^ /{ç'\²i|³1}/ v"¬¸ò5

```

Test it online! Outputs as an array of lines; `-R` flag added to join on newlines. (Thanks @Shaggy)

~~First~~ Second attempt, might be improvable...

### How it works

```
" ^ /{ ç'\²  i |³  1}/ v"¬ ¸  ò5
" ^ /{Uç'\p2 i'|p3 1}/ v"q qS ò5   Ungolfed
                                   Implicit: U = input number
        '\p2                       Repeat a backslash twice, giving "\\".
             i     1               Insert at index 1
              '|p3                   3 vertical bars. This gives "\|||\".
      Uç                           Make U copies of this string. U = 2: "\|||\\|||\"
" ^ /{              }/ v"          Insert this into this string.    " ^ /\|||\\|||\/ v"
                         q qS      Split into chars; join on spaces."  ^   / \ | | | \ \ | | | \ /   v"
                              ò5   Split into rows of length 5.    ["  ^  "," / \ ","| | |"," \ \ ","| | |"," \ / ","  v"]
                                   Joining on newlines gives "  ^
                                                               / \
                                                              | | |
                                                               \ \
                                                              | | |
                                                               \ /
                                                                v"

```

# Answer
> 6 votes
# JavaScript (ES6), 60 bytes

```
n=>`  ^
 / \\
${`| | |
 \\ \\
`.repeat(n-1)}| | |
 \\ /
  v`

```

## Test Snippet

```
let f=
n=>`  ^
 / \\
${`| | |
 \\ \\
`.repeat(n-1)}| | |
 \\ /
  v`
;(I.oninput=_=>O.innerHTML=I.value+"\n"+f(+I.value))()
```

```
<input id=I type=range min=2 max=15 value=2><pre id=O></pre>
```

# Answer
> 6 votes
# Charcoal, ~~27~~ ~~26~~ 25 bytes

*-1 byte thanks to Carlos Alejo. -1 byte thanks to ASCII-only.*

```
  ^⸿ / ×\⸿| | |⸿ \ Ｎ/⸿  v

```

Try it online! Link is to verbose version. *#charcoal-verbose-obfucation*

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

```
f(n){for(puts("  ^\n / \\");--n;puts("| | |\n \\ \\"));puts("| | |\n \\ /\n  v");}

```

Try it online!

# Answer
> 5 votes
# Perl 5, ~~39~~ 37 bytes

```
say"  ^
 / ".'\
| | |
 \ 'x<>."/
  v"

```

Try it online!

*Shaved two bytes with @DomHastings' suggestion*

# Answer
> 3 votes
# Actually, 49 bytes

```
"| | |"@α;lD" \ \"@α@Z♂ii"  v"" \ /"))" / \""  ^"

```

Try it online!

Explanation:

```
"| | |"@α;lD" \ \"@α@Z♂ii"  v"" \ /"))" / \""  ^"
"| | |"@α                                          push a list containing n copies of the vertical lines
         ;lD" \ \"@α                               push a list containing n-1 copies of the diagonal connections
                    @Z♂i                           interleave
                        i                          flatten
                         "  v"" \ /"))             make the bottom
                                      " / \""  ^"  make the top

```

# Answer
> 3 votes
# 05AB1E, 38 bytes

```
…| |ûU"  ^
 / \"XI<F„ \2×X}" \ /
  v"»

```

Try it online!

```
…| |                         # Push "| |"
    û                        # Palindromize
     U                       # Store in X
      "..."X                 # Push the top three rows
            I<F      }       # One less than input times do:
               „ \           #   Push " \"
                  2×         #   Concatenate that with itself
                    X        #   Push "| | |"
                      "..."  # Push the last two rows
                           » # Join stack with newlines

```

# Answer
> 3 votes
# C# (.NET Core), ~~101~~ ~~77~~ 73 bytes

Saved 24 bytes thanks to **i cri everytim**!
Saved 4 bytes thanks to **Kevin Cruijssen**!

```
n=>{var s="  ^\n / ";for(;n-->0;s+="\\\n| | |\n \\ ");return s+"/\n  v";}

```

Try it online!

As per usual, string repeating in C# is a pain.

# Answer
> 3 votes
## Retina, 38 bytes

```
.+
$*
1
¶|||¶x\\
^
 ^¶x/\
.$
/¶ v
x?

```

Try it online!

Prints a column of leading spaces and on trailing space on each line.

### Explanation

The main byte savings come from omitting the spaces in all the literal parts and inserting them at the end. The figure is structured such that there are never two non-spaces next to each other, so if we just remove them all, we can almost fix the shape by inserting a space at every position at the end:

```
^
/\
|||
\\
|||
\/
v

```

becomes:

```
 ^
 / \
 | | |
 \ \
 | | |
 \ /
 v

```

That's almost correct, except for indentation. The `^` and `v` are missing two spaces. That's actually easier to fix, because if we just insert an explicit space in front of each of them, that'll result in two additional spaces at the end. The lines with the slashes are trickier because they require just one additional space. To fix this, we insert a placeholder character there (`x`). When we insert the spaces at the end, we don't just insert them for every empty match, but we optionally match that `x`. That means instead of inserting a space in front of the `x`, the `x` itself gets replaced. And then there will still be an empty match right after the `x`. That means, every `x` adds exactly one space without changing anything else. So what we want to set up is this:

```
 ^
x/\
|||
x\\
|||
x\/
 v

```

which will give us the desired result. So here's the code:

```
.+
$*

```

Convert the input to unary.

```
1
¶|||¶x\\

```

Convert each `1` to two lines with `|||` and `x\\` (and a leading linefeed).

```
^
 ^¶x/\

```

Inser the first two lines with `^` and `x/\`.

```
.$
/¶ v

```

Fix the final `x\\` by turning the last `\` into `/` and appending a line with the `v`.

```
x?

```

Replace each `x` or empty match with a space.

# Answer
> 3 votes
# Stax, ~~21~~ 20 bytes

```
⌐èüYΩ╜yu╝√♪╪▌yº⌐▌2Σ⌠

```

Run and debug it

Uses ETHProductions' idea.

-1 after changing `1/` to `M` (from recursive).

# Answer
> 2 votes
# Pyth, 46 bytes

```
"  ^
 / \\"
+*j[jd*\|3" \ \\"k))Q" \ /
  v

```

Test suite.

# Answer
> 2 votes
# Pyth, 40 bytes

```
K" / \ ""  ^"Kj+b+*2+d\\b*Q]*3"| "_K"  v

```

Fairly similar to Steven Hewitt's, but developed independently.

Try it Online

### Explanation

```
K" / \ ""  ^"Kj+b+*2+d\\b*Q]*3"| "_K"  v
K" / \ ""                                 Set K = " / \ "
        "  ^"                       "  v  Draw the end points.
             K                    _K      Draw the slants.
                         *Q]*3"| "        Draw the vertical bars...
              j+b+*2+d\\b                 ... interspersed with slants.

```

# Answer
> 2 votes
# Pyth, ~~33~~ ~~32~~ 31 bytes

Thanks Mr. Xcoder for one byte.

```
%"  ^
 / %s/
  v"*tj\|_B" \\
|

```

Try it online: Demonstration or Test Suite

# Answer
> 2 votes
# Retina, 45 bytes

This is a pretty simple solution.

```
.+
$*
^1
  ^¶ /x
$
 \ /¶  v
1
 \x
x
 \¶| | |¶

```

**Try it online**

If the art could be 1-indexed instead, it'd be a bit shorter (44 bytes):

```
.+
  ^¶ /x$0$*1
$
 \ /¶  v
1
 \x
x
 \¶| | |¶

```

# Answer
> 2 votes
# Pip, ~~45~~ ~~42~~ 33 bytes

```
"  ^
 / "."\
| | |
 \ "Xa."/
  v"

```

Try it online!

### Explanation

The code is really simple, though the newlines make it harder to read. Here's a better way to see the structure:

```
"prefix" . "repeated" X a . "suffix"

```

The repeated element in the S-chain is

```
   \
| | |
 \

```

Take this as a literal string and repeat it `a` times (where `a` is the first command-line argument). Then prepend the prefix:

```
  ^
 /

```

and append the suffix:

```
   /
  v

```

and print.

(I like how this ended up looking kinda like a \>\<\> program.)

# Answer
> 2 votes
# MATL, ~~47~~ ~~44~~ 43 bytes

-3 bytes thanks to Giuseppe

```
'  ^' ' / \ 'XK'| | |'XJGq:"' \'thJ]KP'  v'

```

Try it online!

# Answer
> 2 votes
# AsciiDots, 88 bytes

```
.*$"  ^"$" / \"
/>#?)--*$"| | |"$" \ \"
*#1\ /-~$"| | |"$" \ /"$"  v"
*-{-}*[<]
\#0----/

```

Try it online!

# Answer
> 2 votes
# bash, 67 bytes

```
printf -v a %\*s $1 \ ;echo '  ^
 / '"${a// /\\
| | |
 \\ }"'/
  v'

```

Try it online

# Answer
> 2 votes
# Ruby, 39 bytes

```
->n{"  ^
 / #{"\\
| | |
 \\ "*n}/
  v"}

```

Try it online!

# Answer
> 2 votes
# ///, 54 bytes

```
/*/
| | |
b//b>///b/ \\\\ \\\\/  ^
 \/ \\**> \\ \/
  v

```

Try it online!

For input, change the number of asterisks

```
 \/ \\**> \\ \/
      ^^

```

# Answer
> 1 votes
# PowerShell, ~~83~~, 57 bytes

```
"  ^
 / \"
1..--$args[0]|%{"| | |
 \ \"}
"| | |
 \ /
  v"

```

Try it online!

Per @AdmBorkBork's suggestions,

* Simplified `for` by using a number range.
* Replaced `;`'s and combined strings.
* Removed an unnecessary variable definition.

# Answer
> 1 votes
## Haskell, 53 bytes

```
f n="  ^\n /"++([1..n]>>" \\\n| | |\n \\")++" /\n  v"

```

Try it online!

# Answer
> 1 votes
# Java 8, ~~93~~ 76 bytes

```
n->{String r="  ^\n / ";for(;n-->0;r+="\\\n| | |\n \\ ");return r+"/\n  v";}

```

Port of *@IanH.*'s C# .NET answer after I golfed it a bit more.

Try it here.

# Answer
> 1 votes
# Excel, 60 bytes

```
="  ^
 / \
"&REPT("| | |
 \ \
",A1-1)&"| | |
 \ /
  v"

```

# Answer
> 1 votes
# SpecBAS - 74 bytes

```
1 INPUT n
2  ?"  ^"'" / \"'("| | |"#13" \ \"#13)*(n-1);"| | |"'" \ /"'"  v"

```

Apostrophe moves to next line, but doesn't work inside the string being repeated, so have to use `#13` to insert line feeds in that part.

# Answer
> 1 votes
# QBIC, 48 bytes

```
?@  ^`?@ / \ `[:|?@| | |`~a=b|?_fB|?@  v`\?@ \ \

```

## Explanation

```
Note that every '?' inserts a linebreak
Also note that @...` creates a string literal and assigns that to A$, B$, ... Z$
?@  ^`      print ^ prefixed with 2 spaces
?@ / \ `    print the other start bit, pre- and postfixed with spaces
[:|         FOR a = 1 to (chain-length given as cmd line param, read as 'b')
?@| | |`    PRINT the pipes
~a=b|       IF we are in the last iteration THEN
?_fB|           print the reversed of B$
                    _f...| flips a string
                    B$ holds " / \ ", which reversed is " \ / "
?@  v`          and print "  v"
\           ELSE
?@ \ \          print the connector to the next section
The final string lit, the IF and the FOR are auto-closed at EOF

```

# Answer
> 1 votes
# Batch, 109 bytes

I believe this isn't completely golfed yet.

```
@echo   ^^
@echo  / \
@for /l %%G in (2,1,%1)do @echo ^| ^| ^|&@echo  \ \
@echo ^| ^| ^|
@echo  \ /
@echo   v

```

This script just:

* Output the top of the Cool S
* Loop `n` times the chain body
* Output the bottom of the Cool S

# Answer
> 1 votes
# Jelly, 32 bytes

Boring port of Lynn's Python solution.

```
“\¶| | |¶ \ ”ẋṭ“  ^¶ / ”;“/¶  v”

```

Try it online!

**Explanation:**

```
“\¶| | |¶ \ ”ẋṭ“  ^¶ / ”;“/¶  v”    Example input: 5
“\¶| | |¶ \ ”                       Literal string "\¶| | |¶ \ " (¶ = newline). Result: "\¶| | |¶ \ "
             ẋ                      Repeat as many times as the (implicit) input. Result: "\¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ "
              ṭ                     Tack that on the end of...
               “  ^¶ / ”            ...the string "  ^¶ / ". Result: "  ^¶ / \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ "
                        ;           Append...
                         “/¶  v”    The string "/¶  v". Result: "  ^¶ / \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ \¶| | |¶ \ /¶  v"
                                    Implicit print

```

# Answer
> 1 votes
# , 90 bytes

```
function(n){cat('  ^
 / \\
| | |
')
for(i in 2:n-1)cat(' \\ \\
| | |
')
cat(' \\ /
  v
')}

```

Try it online!

pretty lame, but this is the best we've got to work with in R.

# Answer
> 1 votes
# Retina, 37 bytes

```
.*
$*
1
\¶| | |¶ \
^
  ^¶ /
$
/¶  v

```

Try it online!

I must be missing something, this is a super basic approach...

# Answer
> 1 votes
# Actually, 30 bytes

This works on the same principle as ETHproductions's Japt answer, where extra spaces are added later, and the whole string is split into rows of 5 for implicit printing. Try it online!

```
"\|||\"*" ^ /"+"/ v"@+#' j5@╪i

```

**Ungolfing**

```
            Implicit input.
"\|||\"*    Add the middle portion and multiply that by the input.
" ^ /"+     Append the top.
"/ v"@+     Append the bottom.
#           Convert into a list of strings
' j         Join with spaces.
5@╪         Split into a list of length-5 strings.
i           Flatten list onto the stack for implicit printing with newlines.

```

# Answer
> 1 votes
# Jelly, ~~25~~ 23 bytes

This works on the same principle as ETHproductions's Japt answer, where extra spaces are added later, and the whole string is split into strings of length 5 before printing. Try it online!

**Edit:** I knew there was a way to join the top and bottom of the S-chain in a golfier way. Thanks to Erik the Outgolfer for -2 bytes.

```
“\|||\”ẋ“ ^ /“/ v”jKs5Y

```

**Ungolfing**

```
                Left argument: n
“\|||\”ẋ        Repeat the middle portion n times.
“ ^ /“/ v”j     Append the top and bottom.
K               Join with spaces.
s5              Split into a list of length-5 strings.
Y               Print the strings with linefeeds.

```

# Answer
> 1 votes
# Excel VBA, 71 Bytes

Anonymous VBE immediate window function that takes input from cell `A1` and outputs to the VBE immediate window

```
a="| | |":?"  ^":?" / \":For i=2To[A1]:?a:?" \ \":Next:?a:?" \ /":?"  v

```

# Answer
> 1 votes
# Charcoal, 25 bytes

```
↘^\¶/¶Ｇ→⁵↓⊕⊗Ｎ←⁵|¶ \↗¶\¶v/

```

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

# Answer
> 1 votes
# , 51 50 48 bytes

```
'  v',~'  ^','/'(0 1;_1 3)}' \ \ | | |'$~5,~1++:

```

Try it online!

# Answer
> 1 votes
# PHP, 73 bytes

```
<?='  ^
 / \
'.join('
 \ \
',array_fill(0,$argv[1],'| | |')).'
 \ /
  v';

```

Try it online!

# Answer
> 1 votes
### x86\_16 machine code - 76 bytes

```
8B CB         MOV CX, BX
49            DEC CX
B4 09         MOV AH, 09H
           ATAS:
BA 02 01      MOV DX, OFFSET RANTAI_S_1
CD 21         INT 21H
85 C9         TEST CX, CX
74 09         JE BAWAH
          .LOOP:
BA 15 01      MOV DX, OFFSET RANTAI_LOOP
CD 21         INT 21H
E3 02         JCXZ BAWAH
E2 F7         LOOP .LOOP
          BAWAH:
BA 23 01      MOV DX, OFFSET RANTAI_S_2
CD 21         INT 21H
          EXIT:
B8 00 4C      MOV AX, 4C00H
CD 21         INT 21H

RANTAI_S_1      DB 020H, 020H, 05EH, 00AH, 00DH, 020H, 02FH, 020H, 05CH
                DB 00AH, 00DH, 07CH, 020H, 07CH, 020H, 07CH, 00AH, 00DH
                DB 024H

RANTAI_LOOP     DB 020H, 05CH, 020H, 05CH, 00AH, 00DH, 07CH, 020H, 07CH
                DB 020H, 07CH, 00AH, 00DH, 024H

RANTAI_S_2      DB 020H, 05CH, 020H, 02FH, 00AH, 00DH, 020H, 020H, 076H
                DB 024H

```

Tested on DOSBox

# Answer
> 1 votes
# CSASM v2.1.2.3, 130 bytes

By far the shortest answer I'll submit with this language. (Probably)
Hooray for builtins!

```
func main:
in ""
conv i32
pop $a
push "  ^\n / \\\n| | |\n"
push " \\ \\\n| | |\n"
push $a
push 1
sub
mul
add
push " \\ /\n  v"
add
print
ret
end

```

**Commented and ungolfed:**

```
func main:
    ; Get the input, convert it to an integer and store it in the accumulator
    in ""
    conv i32
    pop $a

    ; Push the first three rows of the chain
    push "  ^\n / \\\n| | |\n"

    ; Push the next two rows of the chain
    push " \\ \\\n| | |\n"

    ; Duplicate those two rows ($a - 1) times
    push $a
    push 1
    sub
    mul

    ; Append the duplicated rows to the first three rows
    add

    ; Push the final 2 rows
    push " \\ /\n  v"

    ; Append them
    add

    ; Print the result string on the stack
    print
    ret
end

```

# Answer
> 1 votes
# Pyth, 28 bytes

```
jcjd++" ^ /"*Q"\|||\\""/ v"5

```

Test suite

Translation of Sherlock9's Jelly answer.

# Answer
> 1 votes
# Canvas, 22 bytes

```
| | |¶\ \＊ｋ^¶/ \：↕└∔∔ｒ

```

Try it here!

---

Explanation:

```
Code                       # Explanation               # Stack visualization
#############################################################################################
                           # Stack starts with input   # <input>
| | |¶\ \                  # Push string literal       # <input>, | | |¶\ \
         ＊                # Repeat vertically n times # | | |¶\ \...| | |¶\ \
           ｋ              # Remove last line          # | | |¶\ \...| | |
             ^¶/ \         # Push string literal       # | | |¶\ \...| | |, ^¶/ \
                  ：       # Duplicate TOS             # | | |¶\ \...| | |, ^¶/ \, ^¶/ \
                    ↕      # Mirror vertically         # | | |¶\ \...| | |, ^¶/ \, \ /¶v
                     └     # Swap 2nd and 3rd in stack # ^¶/ \, | | |¶\ \...| | |, \ /¶v
                      ∔    # Add vertically            # ^¶/ \, | | |¶\ \...| | |¶\ /¶v
                       ∔   # Add vertically            # ^¶/ \¶| | |¶\ \...| | |¶\ /¶v
                        ｒ # Center each line          #   ^¶ / \¶| | |¶ \ \...| | |¶ \ /¶  v
                           # Print TOS                 #

```

represents a newline in the stack visualization.

# Answer
> 1 votes
# 05AB1E, 22 bytes

```
…\||û×" ^ /ÿ/ v"Sðý5ô»

```

Try it online!

```
…\||û×" ^ /ÿ/ v"Sðý5ô»  # full program
                     »  # split...
      " ^ /ÿ/ v"        # literal...
                        # (implicit) with ÿ replaced by...
…\||                    # literal...
    û                   # concatenated with...
…\||                    # literal...
    û                   # reversed excluding the first character...
     ×                  # repeated...
                        # implicit input...
     ×                  # times...
                  ý     # with each...
                S       # character...
                  ý     # joined by...
                 ð      # spaces...
                     »  # into rows...
                    ô   # of length...
                   5    # literal
                        # implicit output

```

# Answer
> 1 votes
# GolfScript, 46 bytes

```
~['
| | |
']*' \\'2**' \\ /
  v'+
'  ^
 / \\'\

```

Try it online!

# Answer
> 1 votes
# Vyxal, 24 bytes

```
`\||`∞*` ^ /`p`/ v`JṄ5ẇ⁋

```

Try it Online!

---
Tags: code-golf, string, ascii-art
---