[Question]
  [
Your assignment is to write a program of **even length**, that prints an ASCII-art square (described below), that increases its side length by **1** unit each time the original source code is pasted in the middle of the current code.
It is quite hard for me to define this task very well, so I'll give you an example: 
* Let's say your initial code was `CODE` and that it printed:
```
0
```
* Then, insert `CODE` in the middle: your code becomes `COCODEDE` and it should print:
```
00
00
```
* Re-insert `CODE` in the middle: your code becomes `COCOCODEDEDE`
and should print:
```
000
000
000
```
* And so on. Your answer should theoretically work after any number of iterations, but I understand if, due to language performance limitations, it cannot run reasonably over a certain threshold.
Some rules:
* You can use any **printable ASCII** (32-127) as the character to use for your square. Your choice needs to be constant (You should use the same character for each iteration).
* The initial output square must have side-length **1**.
* An ascii-art square is defined as a string with **N** lines (separated by **N-1** linefeeds / newlines), and with each line containing **N** copies of the chosen character.
* Your output isn't allowed to contain any extraneous whitespace, other than a trailing newline.
* You can use the defaults for input and output (programs or functions are allowed, but snippets are not).
* The *middle* of your code is defined as the point where the source code can be split in two parts such that the two are equal.
* Your answers will be scored by the length of **your original program**, in bytes. The lowest byte count wins. In case there's a tie, the answer that was submitted earlier wins.
* You can use [this program](https://tio.run/##bY5BC4JAEIXv8yvmqEiJehPsUp37AbKI1aYDOrvsboW/flsthMC5vGH45r2nJ9crLrynUSvj0E4WQBnqiNsBK7ypuwwSzvvWdK86E8DP8SpNox4NsZXGkWIbEGIXrVguYoB3T4PETfyAWQkY5uc/S10OkqN5izFNMReY4Nok@SL/RCkWj82EXYUZgDZzreXDe3@8nM6@@AA "Python 3 – Try It Online") to apply the insertions without having to do that by hand.
  
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 2 bytes
```
5
```
[Try it online!](https://tio.run/##K6gsyfj/n8v0/38A "Pyth – Try It Online") Also [Try it doubled](https://tio.run/##K6gsyfj/n4vL1PT/fwA), [tripled](https://tio.run/##K6gsyfj/n4uLy9TU9P9/AA)!
### How does that work?
`\n` is the command that prints its argument with a trailing newline, while **returning it** simultaneously. So, each time you make an insertion, you turn the integer literal **5** into a number containing **N** copies of **5** concatenated, and the leading newlines basically make sure it's printed the appropriate number of times, thus keeping it square.
[Answer]
## JavaScript (ES6), ~~42~~ ~~32~~ 30 bytes
```
s=[this.s]+0;  console.log(s);
```
Second iteration:
```
s=[this.s]+0;  s=[this.s]+0;  console.log(s);console.log(s);
```
This works by appending a `0` to `s` each time the first half of the code is run, and printing `s` itself each time the second half is run. Takes advantage of four quirks of JavaScript:
1. The current environment can be referred to with `this`. This allows us to do `this.s` in place of `s`.
2. When accessing a property that has not been defined on an object, instead of throwing an error, JavaScript returns `undefined`.
3. An array plus a number returns a string. `[1,2,3] + 4 === "1,2,34"`
4. When stringifying an array, `undefined` is converted to the empty string, which means that `[undefined] + 0 === "0"`.
Put together, this means that we can express the first half (generating a string of zeroes) in just 13 bytes. If using `alert` instead of `console.log` is allowed, we can save 4 more bytes by shortening the second half. 
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 2 bytes
```
5=
```
[Try it online!](https://tio.run/##MzBNTDJM/f/f1Pb/fwA "05AB1E – Try It Online")
Port of [my Pyth answer](https://codegolf.stackexchange.com/a/154643/59487).
[Answer]
# [Python 2](https://docs.python.org/2/), ~~42~~ ~~38~~ 28 bytes
```
id='%s@'%id  ;print id[22:];
```
[Try it online!](https://tio.run/##K6gsycjPM/r/PzPFVl212EFdNTNFQcG6oCgzr0QhMyXayMgq1vr/fwA "Python 2 – Try It Online"). You can also try the [2nd](https://tio.run/##K6gsycjPM/r/PzPFVl212EFdNTNFQcEalVdQlJlXopCZEm1kZBWLxvv/HwA "Python 2 – Try It Online") and [3rd](https://tio.run/##K6gsycjPM/r/PzPFVl212EFdNTNFQcEaH6@gKDOvRCEzJdrIyCoWL@//fwA "Python 2 – Try It Online") iterations
[Answer]
# [Python 2](https://docs.python.org/2/), 22 bytes
```
i=0;i+=1; i
print'*'*i
```
[Try it online!](https://tio.run/##PY7BDoIwEETP7FdsSEwFGqXVE6R/4B8oMQarbWKWpvSgX4@0gqfNzLzJjvsEM5Cc@uGuVZ7nk1V1ayslWrTgvKXASlbaaY52Y/DWbdmFWAFA6qVpG2vFj0N20vQMhnEkuI2j9gFpI5WqwaBC2ksAiLyYVbznxnTJkKthmg7gMXj02o1oCQWX/MCPDWTpBWRzcI3o0hBlIqskZBILiivJMQ6GTL91/zenLw "Python 2 – Try It Online")
Doubled:
```
i=0;i+=1; ii=0;i+=1; i
print'*'*i
print'*'*i
```
Note that the second half starts with a newline character.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~170~~ ~~168~~ ~~96~~ ~~80~~ ~~72~~ 70 bytes
Much shorter version. Still wish I could find a solution without the preprocessor.
```
i;main(n){for(;i++<n;)printf
#if 0
#endif
(" %*c",n=__LINE__/4, 10);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z/TOjcxM08jT7M6Lb9IwzpTW9smz1qzoCgzrySNSzkzTcGAi0s5NS8lM41LQ0lBVStZSSfPNj7ex9PPNT5e30RHwdBA07r2/38A "C (gcc) – Try It Online")
Old 168 byte version:
```
#ifndef A
#define A p(c){putchar(c);}j,n;main(i){for(
#else
#define A n++,
#endif
A
#ifndef B
#define B i=++n;i--;p(10))for(j=n;j--;)p(64);}
#else
#define B
#endif
B
```
[Try it online!](https://tio.run/##XY1BCgIxDEX3PUWhm5ROQUHchFm0Nxk6raZoLKOuBs9e42JEzCbh8fN@8qeUejdUeM5FB2VkEWcddINk1/Z8pPO0yImvOjBeJ2Igu5bbAsrkyz3/fLBzg0CeqaigZDZt/IaiptE5RvIeG@x31n5MdWSsQmyD40Ga/sxxk8be3w "C (gcc) – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 30 bytes
```
False+=1      ;print'*'*False;
```
[Try it online!](https://tio.run/##K6gsycjPM/r/3y0xpzhV29ZQAQysC4oy80rUtdS1wOLW//8DAA "Python 2 – Try It Online"), [2nd](https://tio.run/##K6gsycjPM/r/3y0xpzhV29ZQAQys0bgFRZl5Jepa6lpgcXTu//8A "Python 2 – Try It Online") and [3rd](https://tio.run/##K6gsycjPM/r/3y0xpzhV29ZQAQys8XMLijLzStS11LXA4gS4//8DAA "Python 2 – Try It Online") iteration
This makes use of the fact that bools in Python are basically ints and the names `False` and `True` were reassignable in Python 2.
# [Python 1](https://www.python.org/download/releases/1.6.1/), 32 bytes
```
exit=exit+'*'  ;print exit[30:];
```
[Try it online!](https://tio.run/##K6gsycjPM/z/P7Uis8QWRGira6krKFgXFGXmlSiABKKNDaxirf//BwA "Python 1 – Try It Online"), [2nd](https://tio.run/##K6gsycjPM/z/P7Uis8QWRGira6krKFij8wuKMvNKFEAC0cYGVrEY/P//AQ "Python 1 – Try It Online") and [3rd](https://tio.run/##K6gsycjPM/z/P7Uis8QWRGira6krKFgT4hcUZeaVKIAEoo0NrGIJ8v//BwA "Python 1 – Try It Online") iteration
In Python 1 the builtin strings `exit` and `quit` existed to inform the user of the interactive shell how to exit it. The default value is `"Use Ctrl-D (i.e. EOF) to exit."`.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 6 bytes
```
⊞υωＬυ⸿
```
[Try it online!](https://tio.run/##ARsA5P9jaGFyY29hbP//4oqez4XPie@8rM@F4ri///8 "Charcoal – Try It Online") Explanation:
```
  ω     Predefined empty string (any variable would do here)
 υ      Predefined initially empty list
⊞       Push
```
`υ` ends up with a length of the number of repetitions.
```
    υ   List
   Ｌ    Length
        Implicitly print as a row of `-`s
     ⸿  Move to start of next line
```
[Answer]
# [Haskell](https://www.haskell.org/), 68 bytes
```
let s@(z:n)="0\n"in case lines<$>[]of(h:t):_->(h:h:t)>>(z:h++n);_->s
```
Try it online [once](https://tio.run/##FctBCoMwEEDRqwziwiBC12kTegeXVSSE2IjjNDhx4@Ed093jw4@O14AoDGYQDBn43ZyalKkeA1ULgXccABcK/KrtZ/zNTdRZ6amzBX9aW4bYtqSeJbJsrlwG0pH7vAPL5Wd0X5bOp3QD "Haskell – Try It Online"), [twice](https://tio.run/##y0gszk7NyflfrGAb8z8ntUSh2EGjyipP01bJICZPKTNPITmxOFUhJzMvtdhGxS6asIrY/DSNDKsSTat4XTsgA8S0swNqyNDWztO0BgoWE1bxPzcRaK6tQkFpSXBJkULx/3/JaTmJ6cX/dZMLCgA) or [thrice](https://tio.run/##y0gszk7NyflfrGAb8z8ntUSh2EGjyipP01bJICZPKTNPITmxOFUhJzMvtdhGxS6aGipi89M0MqxKNK3ide2ADBDTzg6oIUNbO0/TGihYTA0V/3MTgTbbKhSUlgSXFCkU//@XnJaTmF78Xze5oAAA).
Because of Haskell's laziness an expression like the one above counts as a function which takes no arguments, as per [this Meta question](https://codegolf.meta.stackexchange.com/q/12924/56433).
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~44~~ 34 bytes
[crossed out 44 is still regular 44 ;(](https://codegolf.stackexchange.com/a/153011/76162)
```
,>-[<+>---]++++++++++[<]>[.>]<----
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fx0432kbbTldXN1YbDqJtYu2i9exibYDCuv//AwA "brainfuck – Try It Online")
[Try it doubled](https://tio.run/##SypKzMxLK03O/v9fx0432kbbTldXN1YbDDAEQCDaJtYuWs8u1gYorIsh8P8/AA "brainfuck – Try It Online"), [tripled](https://tio.run/##SypKzMxLK03O/v9fx0432kbbTldXN1YbDAgLgEC0TaxdtJ5drA1QWJewwP//AA "brainfuck – Try It Online"). Look, no padding!
Prints squares of `U`. It splits right down the middle of the 10 `+`s.
[Answer]
# Ruby, 18 bytes
```
$/=?x+$/;  puts$/;
```
[Try it online!](https://tio.run/##KypNqvz/X0Xf1r5CW0XfWkGhoLSkGMj4/x8A) [Doubled!](https://tio.run/##KypNqvz/X0Xf1r5CW0XfWkEBiVlQWlIMZECp//8B) [Tripled!](https://tio.run/##KypNqvz/X0Xf1r5CW0XfWkEBO7OgtKQYyECl/v8HAA)
[Answer]
# [Brain-Flak](https://github.com/Flakheads/BrainHack), 74 bytes
```
(((((()()()){}){}){}){})((()()()()()<>){})<>([]){({}[()]<(({})<>)<>>)}{}<>
```
[Try it online!](https://tio.run/##SypKzMzLSEzO/v9fAww0QVCzuhaBYIIgaGMHErGx04iO1azWqK6N1tCMtdHQAIsBkZ1mbXWtjd3///91HQE "Brain-Flak (BrainHack) – Try It Online")
Try it [doubled](https://tio.run/##SypKzMzLSEzO/v9fAww0QVCzuhaBYIIgaEOUIjuQiI2dRnSsZrVGdW20hmYsUCNYDIjsNGura0EUEYr@//@v6wgA "Brain-Flak (BrainHack) – Try It Online") and [tripled](https://tio.run/##SypKzMzLSEzO/v9fAww0QVCzuhaBYIIgaEM9RXYgERs7jehYzWqN6tpoDc1YoEawGBDZadZW14Ioain6//@/riMA "Brain-Flak (BrainHack) – Try It Online").
### Explanation
```
(((((()()()){}){}){}){}) # push 48 ("0") onto first stack
((()()()()()<>){})       # push 10 (\n) onto second stack
<>([]){({}[()]<          # a number of times equal to the height of the first stack:
  (({})<>)<>             #   copy the top of the first stack to the second stack
>)}{}<>                  # cleanup and return to second stack
```
The break point is in the middle of the `<>` in the "push 10" section. Breaking this up will leave a 5 on the third stack until we reach the corresponding second half, at which point pushing 10 will resume right where it left off.
While it is possible to push a printable ASCII value (space) in 22 bytes, this would make the central `<>` be executed after pushing `5`. By adding two more bytes, I was able to move the `<>` so that all of the progress toward pushing `10` was on the third stack. As a bonus, this also made the resulting square more aesthetically pleasing.
[Answer]
# [tinylisp](https://github.com/dloscutoff/Esolangs/tree/master/tinylisp), 112 bytes
```
(load library) (d N((q((x)(i x(inc x)1)))(v(h(t(t(h(t(q())))))))))(join(repeat-val(string(repeat-val 42 N))N)nl)
```
[Try it online!](https://tio.run/##TYgxDoMwEAS/cuVukSIR7/AfDFhw0ekAYyH79U5oosxIU0xRb6bn3jtsi7OYjjnmRsEsATiASqhUqE9S@SSJCyvK17sH@APvTR057SmWxxUNZ8nqy9@R4SWBDHRj7x8 "tinylisp – Try It Online") Also [doubled](https://tio.run/##nYsxDoMwEAS/cuVukQLEO/wHB1C46HQQYyHzegcaRM2utMVoJ6vvputSK2yOg5i@U0w7BYME4AcUQqVAvZfChiQ2TMhHzz0ODz1ewXdWRxqXMebXFg1rTuqfG5GulUAGuvGpV@sf) and [fivefold](https://tio.run/##3YtBDoMwEAO/skf70AOId@QPKaCy1WqhIULh9SlcEG/AlnwYebL6broutcLmOIjpO8W0UzBIAH5AIVQK1HspbEhiw4R89Nzj8HCPV/Cd1ZHGZYz5tUXDmpP650akayWQgW58ulfrHw).
The "build a string in the first half, print it in the second half" approach that a lot of languages are taking won't work in tinylisp, since there are no mutable variables. Instead, we do some serious code nesting.
When a second copy of the code is inserted, it is placed inside the `(q())`, which wraps it in a list. Then `(h(t(t(h(t(...))))))` drills into that list to the part after `(d N`. `(v(...))` evaluates it; then we pass it to the unnamed function `(q((x)(i x(inc x)1)))`, which increments the resulting value if it's a number and returns 1 if it's the empty list. The final result in the outermost nested version of the code is assigned to `N`. In essence, we've set up a weird sort of recursion that counts the number of nesting levels.
The second half of the code then creates a string of `N` asterisks, then a list of `N` such strings, then joins the list on newlines. The result is displayed with a trailing newline.
[Answer]
# [R](https://www.r-project.org/), 44 bytes
```
F=F+1;T=TRUE*TRUE+12;
write(strrep(1,F),"");
```
[Try it online!](https://tio.run/##K/r/383WTdvQOsQ2JCjUVQtEaBsaWXOVF2WWpGoUlxQVpRZoGOq4aeooKWla//8PAA "R – Try It Online")
Prints with a trailing newline. The `T=TRUE*TRUE+12` is just to pad the length.
[Try it doubled](https://tio.run/##K/r/383WTdvQOsQ2JCjUVQtEaBsaWWMV5CovyixJ1SguKSpKLdAw1HHT1FFS0sQl/P8/AA) and [Try it tripled](https://tio.run/##K/r/383WTdvQOsQ2JCjUVQtEaBsaWRMvyFVelFmSqlFcUlSUWqBhqOOmqaOkpEmi8P//AA).
[Answer]
# [Julia 0.6](http://julialang.org/), 29 bytes
All my ideas were longer than adapting xnor's clever python solution.
```
i=0;i+=1;    i
println("0"^i)
```
Becomes
```
i=0;i+=1;    ii=0;i+=1;    i
println("0"^i)
println("0"^i)
```
[Try it online!](https://tio.run/##yyrNyUw0@/8/09bAOlPb1tBaAQgyuQqKMvNKcvI0lAyU4jI1//8HAA "Julia 0.6 – Try It Online")
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/csnobol4/), ~~130~~ 68 bytes
Now with no comments! See the [edit history](https://codegolf.stackexchange.com/posts/154670/revisions) for an explanation of the old algorithm.
```
	X =X + 1
	A =ARRAY(X,DUPL(1,X));
I	I =I + 1
	OUTPUT =A<I>	:S(I)
END
```
[Try it online!](https://tio.run/##K87LT8rPMfn/nzNCwTZCQVvBkIvTUcHWMSjIMVIjQsclNMBHw1AnQlPTmsuT01PB1hOixD80JCA0BKjOxtOO0ypYw1OTy9XP5f9/AA "SNOBOL4 (CSNOBOL4) – Try It Online")
Try it [doubled](https://tio.run/##K87LT8rPMfn/nzNCwTZCQVvBkIvTUcHWMSjIMVIjQsclNMBHw1AnQlPTmqACLk9OTwVbT4gS/9CQgNAQoDobTztOq2ANT00uVz8XIpT8/w8A "SNOBOL4 (CSNOBOL4) – Try It Online") and [tripled](https://tio.run/##K87LT8rPMfn/nzNCwTZCQVvBkIvTUcHWMSjIMVIjQsclNMBHw1AnQlPTmnIFXJ6cngq2nhAl/qEhAaEhQHU2nnacVsEanppcrn4u1FHy/z8A "SNOBOL4 (CSNOBOL4) – Try It Online")
Explanation:
```
	X =X + 1		;* increment X
	A =ARRAY(X,DUPL(1,X));	;* create an x-length array with 1 repeated x times for each element
I	I =I + 1		;* for i < x
	OUTPUT =A<I>	:S(I)	;* output a[i]
END
```
Because an `END` label is required and anything after the first `END` label is ignored, we get two advantages for this challenge:
* operations in the first half of the program are repeated `X` times for the `X` repetitions
* there will (to the interpreter) only exist one copy of the second half, *including labels*.
This suggests that we use the repetition for the first half, and then we can use a more "conventional" labeling approach to repeat the output `X` times.
The first half is
```
	X =X + 1
	A =ARRAY(X,DUPL(1,X));
```
which, when repeated, increments `X` the appropriate number of times, and creates an `ARRAY` `A` with indices from `1` to `X` and where each element of `A` is the string `1` repeated `X` times.
Then no matter how many times the program is repeated, the interpreter only sees:
```
I	I =I + 1
	OUTPUT =A<I>	:S(I)
END
```
which is a typical SNOBOL program that prints out the elements of `A` one at a time until the index goes out of bounds, then terminates the program.
`;` is an optional line terminator usually reserved for one-line `EVAL` or `CODE` statements that quite neatly brings the byte count to 68 and marks the halfway point, allowing the code to be appended there.
[Answer]
# [shortC](//git.io/shortC), ~~56~~ 44 bytes
-12 bytes: wait duh I'm using shortC why not use some shortened C stuff
```
s[];A
strcat(s,"@");//
Js);/*filling space*/
```
I would've used standard C, but that requires a `}` at the end which messes with replication. shortC inserts it at EOF implicitly.
* [Try it online! (1x1)](https://tio.run/##K87ILypJ/v@/ODrW2pGruKQoObFEo1hHyUFJ01pfn8urGEhppWXm5GTmpSsUFyQmp2rp//8PAA)
* [Try it online! (2x2)](https://tio.run/##K87ILypJ/v@/ODrW2pGruKQoObFEo1hHyUFJ01pfH7sol1cxkNJKy8zJycxLVyguSExO1cIh@v8/AA)
* [Try it online! (3x3)](https://tio.run/##K87ILypJ/v@/ODrW2pGruKQoObFEo1hHyUFJ01pfnxRRLq9iIKWVlpmTk5mXrlBckJicqkWS6P//AA)
* ...
* [Try it online! (15x15)](https://tio.run/##K87ILypJ/v@/ODrW2pGruKQoObFEo1hHyUFJ01pff1SUdFEur2IgpZWWmZOTmZeuUFyQmJyqNSpKhuj//wA)
[Answer]
# [Perl 5](https://www.perl.org/), 25 bytes
**24 bytes code + 1 for `-p`.**
Appreciate that you might not want to allow commandline flags, please let me know if this is not valid.
```
$@=0 x++$n;;$_="$@
"x$n;
```
[Try it online!](https://tio.run/##K0gtyjH9/1/FwdZAoUJbWyXP2ppkdrytkooDl1IFkEMq@/9/rn/5BSWZ@XnF/3ULAA "Perl 5 – Try It Online")
[Answer]
# [Zsh](https://www.zsh.org/), 10 bytes
```
s+=0
<<<$s
```
**[Try a full test suite online!](https://tio.run/##TVHLbsIwELz7K0Y8lERVEHBMA7dWqlSpVdsjF0NsYimxI9tAC4Jfp2untPVlH96ZWY@Prr4uIVGWSB5eHpOru1tMWVmWI3elmrEhrGjNXsBbrhqlt9DiQFFAaUjVCObtTm@4F8gd8hlkwLiuUT5e05g3lFnnUfNGIpU8A9cVnNgYCqlcZ6yfzzXmyDmI5IemNgf4msQPJqD3wrHOEqNEMnYrfbm8vz4/fVwuKx3KcvFzliudYDBKS9Ia9Mk6GzDGpLFQYfPTbDKZT8/3qAxjoDNEJEYteCVsbN2U3nYaw/G8KnqVBCOF0SltClUUiyI73wjIh7hsZ83W8jbIiLbzXxB6r6zRrdA@jlKNXOHo6vDMHsyrChwNqQePgz@/hm9M2xlNYIT1tfj0QSriyHdIHuxag75xE5vtnrI/5v5dnshiI/zt/@Uror5@Aw "Zsh – Try It Online")**
...yeah, this is a bit better. Append to string N times, then print N times. Turns out `<<<foo<<<foo` works just fine.
---
### [Zsh](https://www.zsh.org/), 64 bytes
Character used:  (space).
```
f(){printf '%*s\n' $1}
:<<'E'
E
repeat $[i=LINENO/3];f $i
exit
```
**[Try a full test suite online!](https://tio.run/##VVFNT@MwFLz7V4zaoCRIgW25BZdbkZAQrHa5AQe3eSaWEjtyTMtStX@9@5zwIXzx88ubmTeT974@XkFDSqTL@@v0qLN813ljg0Z6cto/2RTJbC9KKdNlKsRSeOpIBSSPZnF7c7e8uz@/eL7USIygNxPEkVmEmMJT6zaE4JVpjH2BpS3fBGOhTUMi@Fe7VoFQ9Chm0BHTd40Jw2ceC44r3wfUqtHItMqhbIWe1o6vTK9yMc4XFnMUCkzyQVO7LULN4lsX0RvqxZcldnQ4/P19e/NwODzZ@JSLj3MVzU6STLLWZCxW@UQIoZ2HiZvvZmdn81/7S1ROCPCZYiBGTaoiP7Q@lf68WkxP5lU5qnCMBskua0pTlosy338ScA7Dsp13L161UYbaLvwD2Y3xzrZkwzDKbxQG730dbY5gVVVQaFg9Zhzz@Qp87drOWQYjrm/pLUSpAce5Q6sY1wr889dDs91w9c08@gpMNjSklD@Wr5j6@B8 "Zsh – Try It Online")**
The midpoint is between the second `E` and the newline following it. A heredoc will end when there is an `E` on a line by itself, which happens right in the middle of the code.
]