[Question]
  [
*This is a repost of [Evolution of “Hello World!”](https://codegolf.stackexchange.com/questions/40376/evolution-of-hello-world), originally written by user Helka Homba*
*It should not be closed as a duplicated, due to meta consensus [here](http://meta.codegolf.stackexchange.com/a/11123/60042).*
*The original was asked over two years ago and was last active more than six months ago. I have permission from Helka Homba to post this [here](http://chat.stackexchange.com/transcript/message/35687646#35687646)*
*Since the original, many languages have been invented, and many people have joined the site who have never had an opportunity to answer the original, so I feel that this repost is acceptable.*
---
The challenge is to make a program that prints `2^n` to stdout, where `n` is the number of your program. The catch is that your program must have a [Levenshtein distance](http://en.wikipedia.org/wiki/Levenshtein_distance) of 10 or less from the program in the answer submitted before yours.
# How This Will Work
Below I will submit the first answer using C#, which prints 2^(n=1)=`2`.
The next person to answer must modify the code with up to 10 single character insertions, deletions, or substitutions so that when it is run in the language of the new answer, it prints `2^n` (with `n` being the answer number). For example, the 25th answer (let's say it's in Pyth) would print 2^25, or 33554432.
This will continue on until everyone get stuck because there is no new language the last answer's program can be made to run in by only changing 10 characters. The communal goal is to see how long we can keep this up, so try not to make any obscure or unwarranted character edits (this is not a requirement however).
# Formatting
Please format your post like this:
```
#Answer N - [language]
    [code]
[notes, explanation, observations, whatever]
```
Where N is the answer number (increases incrementally, N = 1, 2, 3,...).
You do not have to tell which exact characters were changed. [Just make sure the Levenshtein distance is from 0 to 10.](http://planetcalc.com/1721/)
If you answer in some language or the resulting code is just a mess, *do please* explain what you did and why it works, though this isn't required.
# Rules
The key thing to understand about this challenge is that **only one person can answer at a time and each answer depends on the one before it**.
There should never be two answers with the same N. If two people happen to simultaneously answer for some N, the one who answered later (even if it's a few seconds difference) should graciously delete their answer.
Furthermore...
* A user may not submit two answers in a row. (e.g. since I submitted answer 1 I can't do answer 2, but I could do 3.)
* Try to avoid posting too many answers in a short time frame.
* Each answer must be in a different programming language.
	+ You may use different major versions of a language, like Python 2/3
	+ Languages count as distinct if they are traditionally called by two different names. (There may be some ambiguities here but don't let that ruin the contest.)
* You do not have to stick to ASCII, you can use any characters you want. Levenshtein distance will be measured in unicode **characters**.
* The output should only be `2^n` and no other characters. (Leading/trailing whitespace is fine, as is unsuppressible output like `>>>` or `ans=`)
* If your language doesn't have stdout use whatever is commonly used for quickly outputting text (e.g. `console.log` or `alert` in JavaScript).
* When the power of two you have to output gets very large, you may assume infinite memory, but not an infinite integer size. Please be wary of integer overflows.
* You may make use of scientific notation or whatever your languages most natural way of representing numbers is. (Except for unary, *DO NOT* output in unary)
**Please make sure your answer is valid.** We don't want to realize there's a break in the chain five answers up. Invalid answers should be fixed quickly or deleted before there are additional answers.
**Don't edit answers unless absolutely necessary.**
# Scoring
Once things settle down, the user who submits the most (valid) answers wins. Ties go to the user with the most cumulative up-votes.
## Edit these when you post an answer:
### Leaderboard
> 
> ### 13 languages
> 
> 
> Okx  
> 
> 
> 
> ### 8 languages
> 
> 
> zeppelin  
> 
> 
> 
> ### 4 languages
> 
> 
> Pavel  
> 
> Jonathan Allan  
> 
> Kritixi Lithos  
> 
> Riker  
> 
> 
> 
> ### 3 languages
> 
> 
> boboquack  
> 
> 
> 
> ### 2 languages
> 
> 
> bmarks  
> 
> Conor O'Brien  
> 
> Destructible Watermelon  
> 
> ovs  
> 
> Tom Carpenter  
> 
> 
> 
> ### 1 language
> 
> 
> ATaco  
> 
> Blocks  
> 
> Dennis  
> 
> dzaima  
> 
> Erik the Outgolfer  
> 
> ETHproductions  
> 
> ghosts\_in\_the\_code  
> 
> Leo  
> 
> Lynn  
> 
> Matheus Avellar  
> 
> Nathaniel  
> 
> Qwerp-Derp  
> 
> R. Kap  
> 
> Taylor Raine  
> 
> nimi  
> 
> Mistah Figgins  
> 
> PidgeyUsedGust  
> 
> steenbergh  
> 
> 
> 
> 
### Languages used so far:
> 
> 1. C# (Pavel)
> 2. /// (boboquack)
> 3. Retina (Dennis)
> 4. Jelly (Jonathon Allan)
> 5. Pyth (boboquack)
> 6. ><> (Destructible Watermelon)
> 7. Minkolang (Kritixi Lithos)
> 8. Perl (Pavel)
> 9. Python (Qwerp-Derp)
> 10. dc (R. Kap)
> 11. Charcoal (Jonathon Allan)
> 12. Self Modifying BrainFuck (Leo)
> 13. SOGL (dzaima)
> 14. ShapeScript (Jonathon Allan)
> 15. Pyke (boboquack)
> 16. Ruby (Nathaniel)
> 17. 05AB1E (ovs)
> 18. STATA (bmarks)
> 19. bc (Kritixi Lithos)
> 20. Japt (Okx)
> 21. 2sable (Kritixi Lithos)
> 22. Cheddar (Jonathon Allan)
> 23. Pylons (Okx)
> 24. Bash (zeppelin)
> 25. Pushy (Okx)
> 26. CJam (Erik the Outgolfer)
> 27. MATL (Okx)
> 28. MATLAB (Tom Carpenter)
> 29. Octave (Kritixi Lithos)
> 30. R (ovs)
> 31. JavaScript ES7 (Tom Carpenter)
> 32. Convex (Okx)
> 33. Mathematica (ghosts\_in\_the\_code)
> 34. Pip (Okx)
> 35. Stacked (Conor O'Brien)
> 36. GolfScript (Okx)
> 37. Actually (Lynn)
> 38. RProgN (Okx)
> 39. Scheme (bmarks)
> 40. Element (Okx)
> 41. J (Blocks)
> 42. Cubix (ETHproductions)
> 43. zsh (zeppelin)
> 44. VBA (Taylor Raine)
> 45. Fish (zeppelin)
> 46. Reticular (Okx)
> 47. Perl 6 (Pavel)
> 48. RProgN2 (ATaco)
> 49. PHP (Matheus Avellar)
> 50. Jolf (Conor O'Brien)
> 51. Haskell (nimi)
> 52. Befunge-98 (Mistah Figgins)
> 53. Gnuplot (zeppelin)
> 54. QBIC (steenbergh)
> 55. FOG (Riker)
> 56. Qwerty-RPN (Okx)
> 57. Korn Shell (ksh) (zeppelin)
> 58. Julia (Riker)
> 59. Python 3 (Pavel)
> 60. Vimscript (Riker)
> 61. Dash (zeppelin)
> 62. Vitsy (Okx)
> 63. csh (zeppelin)
> 64. Ohm (Okx)
> 65. Bosh (zeppelin)
> 66. es-shell (Riker)
> 67. Gol><> (PidgeyUsedGust)
> 
> 
> 
This question works best when you [sort by oldest](https://codegolf.stackexchange.com/questions/111310/evolution-of-powers-of-two?answertab=oldest#tab-top).
  
[Answer]
# Answer 67, [Gol><>](https://github.com/Sp3000/Golfish/wiki), distance 6
We van use the trampoline `#` to just append the code in reverse. By removing `S)1'a` the `;` can be reused, needing only 6 characters to be added.
```
#64º,;n*:"C"
"bc"<<x
2^66
x
#??92a5*2p@^54┘#--2'3k:'2k*.@2(#"#28@P2*Jp;math 2\^45#2^41 NB.`#(expt 2 39); ^ 
quit()
@n.out (*2 32#e#a44******O@) //2 25)
"e
"2ej
:
py 
p
riker
i
n
t
(2**60)
"%d" $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#
```
[Try it online!](https://golfish.herokuapp.com/?code=%2364%C2%BA%2C%3Bn%2a%3A%22C%22%0A%22bc%22%3C%3Cx%0A2%5E66%0Ax%0A%23%3F%3F92a5%2a2p%40%5E54%E2%94%98%23--2'3k%3A'2k%2a.%402%28%23%22%2328%40P2%2aJp%3Bmath%202%5C%5E45%232%5E41%20NB.%60%23%28expt%202%2039%29%3B%20%5E%20%0Aquit%28%29%0A%40n.out%20%28%2a2%2032%23e%23a44%2a%2a%2a%2a%2a%2aO%40%29%20%2F%2F2%2025%29%0A%22e%0A%222ej%0A%3A%0Apy%20%0Ap%0Ariker%0Ai%0An%0At%0A%282%2a%2a60%29%0A%22%25d%22%20%24%5B2%2a%2a43%5Dbye'%24%2F%2a%23%22A%23327%3BN%3C.%22%24%22%2Fclass%20HelloWorld%20%7Bstatic%20void%20Main%28%29%200%7B%3Bn%2a%2a%2a%7e%23&input=)
I think keeping the `#` allows for some other languages to use it as a commented line.
[Answer]
# Answer 64, [Ohm](https://github.com/MiningPotatoes/Ohm), distance 10
```
64º,;S)1'a"bc"<<x
2^63 
x
#??92a5*2p@^54┘#--2'3k:'2k*.@2(#"#28@P2*Jp;math 2\^45#2^41 NB.`#(expt 2 39); ^ 
exit
 @n.out (*2 32#e#a44******O@) //2 25)
"e
"2ej
:py print(2**60)
"%d" $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024print(2**53)--0;#0}}//4|#6904r"$2 #puts 16384 8*di 2^18o8*'*[[[268*^?>
```
Added `64º,;S)1'a`
Only the `64º,` is actual code, the rest is just junk.
This program will print the correct output, but it will also ask for some `STDIN` *after* it has printed 264.
[Answer]
# Answer 17: [05AB1E](https://github.com/Adriandmen/05AB1E), Distance of 3
```
#"Ａ#327;N<."$"/class HelloWorld {static void Main() 0{;n***~
#    System<.Console<.<.
#1024p#rint(512);
#0}}//4|
#β”6904”±r«"$2 
puts 16384 8*
```
[Try it online!](https://tio.run/nexus/05ab1e#@6@s9H7PQmVjI3NrPxs9JRUl/eScxOJiBY/UnJz88PyinBSF6uKSxJLMZIWy/MwUBd/EzDwNTQWDaus8LS2tOi5lBSAIriwuSc210XPOzyvOz0m10bPR41I2NDAyKVAuyswr0TA1NNK05lI2qK3V1zep4VI@t@lRw1wzSwMTIHVoY9Gh1UoqRgpcBaUlxQqGZsYWJgoWWv//AwA "05AB1E – TIO Nexus")
[Answer]
# Answer 24: Bash, distance 8
```
#23#2ej
printf $[2**24]
#'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~
#    System<.Console<.<.
#1024p#rint(512);
#0}}//4|
#ß”6904”±r«"$2 
#puts 16384 8*di 2^18o8*'
```
[Try It Online !](https://tio.run/nexus/bash#@69sZKysZZSaxVVQlJlXkqagEm2kpWVkEsulrK6ir6Ws5KhsbGRu7Wejp6SipJ@ck1hcrOCRmpOTH55flJOiUF1ckliSmaxQlp@ZouCbmJmnoalgUG2dp6WlVcelrAAEwZXFJam5NnrO@XnF@TmpNno2elzKhgZGJgXKIAs1TA2NNK25lA1qa/X1TWq4lA/Pf9Qw18zSwARIHdpYdGi1koqRwv//AA)
[Answer]
## Answer 51, Haskell, distance 10
```
--2@2(#"#28@P2*Jp;math 2\^45#2^41 NB.`(expt 2 39); ^ exit @n.out (*2 32#e#a44******O@)//2 25)#e#2ej#printf("% $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024
print(2^51)--;#0}}//4|#6904r"$2 #puts 16384 8*di 2^18o8*'*[[[268*^?>
```
Remove 2 NL, replace `^` at the beginning with `-`, prepend another `-`, delete `*` within the `print`, replace 2nd `*` with `^`, overwrite `49`with `51`, insert `--` after the print. 
[Answer]
# Answer 4: [Jelly](https://github.com/DennisMitchell/jelly) distance 3
```
/class HelloWorld {static void Main() 0{
    System.Console.Write(2);
0}}//4|
8Ḥ
```
**[Try it online!](https://tio.run/nexus/jelly#@6@fnJNYXKzgkZqTkx@eX5STolBdXJJYkpmsUJafmaLgm5iZp6GpYFDNpQAEwZXFJam5es75ecX5Oal64UWZJakaRprWXAa1tfr6JjVcFg93LPn/HwA "Jelly – TIO Nexus")**
all insertions: `00Ḥ`.
`0{` and `0}` are there to suppress parsing errors (pop from empty list due to the `{` and `}` being quicks that turn monads into dyads using the left and right argument respectively).
`Ḥ` "unhalves" 8 to make 16.
[Answer]
# Answer 5: [Pyth](https://esolangs.org/wiki/Pyth)
```
32 "/class HelloWorld {static void Main() 0{
    System.Console.Write(2);
0}}//4|
8Ḥ
```
Prints the numeric literal `32`, then the space between the `2` and the `"` suppresses printing of the (auto-completed) string literal.
+4 characters - `32 "`
[Try it on herokuapp](https://pyth.herokuapp.com/?code=32+%22%2Fclass+HelloWorld+%7Bstatic+void+Main%28%29+0%7B%0A++++System.Console.Write%282%29%3B%0A0%7D%7D%2F%2F4%7C%0A8%E1%B8%A4&debug=0)
[Answer]
# Answer 6 - ><>
```
32""/class HelloWorld {static void Main() 0{;n***~
    System.Console.Write(2);
0}}//4|
8Ḥ
```
replaced a space with ", the code pushes 3, 2, 4, then reverses, pushes 4,2,3, then pops 3 off the stack, and multiplies 2, 4, 4, 2, for 64, outputs it and halts
[Try it online](https://tio.run/nexus/fish#@29spKSkn5yTWFys4JGak5Mfnl@Uk6JQXVySWJKZrFCWn5mi4JuYmaehqWBQbZ2npaVVx6UABMGVxSWpuXrO@XnF@TmpeuFFmSWpGkaa1lwGtbX6@iY1XBYPdyz5/x8A)
maybe use <https://www.fishlanguage.com/playground>
[Answer]
# Answer 3: [Retina](https://github.com/m-ender/retina), distance 3
```
/class HelloWorld {static void Main() {
    System.Console.Write(2);
}}//4|
8
```
Appended `|\n8` (distance 3).
[Try it online!](https://tio.run/nexus/retina#@6@fnJNYXKzgkZqTkx@eX5STolBdXJJYkpmsUJafmaLgm5iZp6GpUM2lAATBlcUlqbl6zvl5xfk5qXrhRZklqRpGmtZctbX6@iY1XBb//wMA "Retina – TIO Nexus")
[Answer]
# Answer 20: Japt, distance 8
```
2**20$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~
#    System<.Console<.<.
#1024p#rint(512);
#0}}//4|
#ß”6904”±r«"$2 
#puts 16384 8*di 2^18*/
```
[Try it online!](http://ethproductions.github.io/japt/?v=1.4.4&code=MioqMjAkLyojIkEjMzI3O048LiIkIi9jbGFzcyBIZWxsb1dvcmxkIHtzdGF0aWMgdm9pZCBNYWluKCkgMHs7bioqKn4KIyAgICBTeXN0ZW08LkNvbnNvbGU8LjwuCiMxMDI0cCNyaW50KDUxMik7CiMwfX0vLzR8CiPfXHUyMDFkNjkwNFx1MjAxZLFyqyIkMiAKI3B1dHMgMTYzODQgOCpkaSAyXjE4Ki8=&input=)
Modifications:
Changed `2^19` to `2**20` at the start of the program, to calculate the power (4)
Replaced `#` with `$` on the first line so that everything past it is interpreted as JS (1)
On the last line, removed the `/` and added a `*/` at the end of the program, so the comment takes up the whole program (3)
[Answer]
# Answer 27: MATL, distance 4
```
27W%2 25)#e#2ej#printf $[2**24]#'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024p#rint(512);#0}}//4|#ß”6904”±r«"$2 #puts 16384 8*di 2^18o8*'
```
[Try it online!](https://matl.suever.net/?code=27W%252+25%29%23e%232ej%23printf+%24%5B2%2a%2a24%5D%23%27%24%2F%2a%23%22A%23327%3BN%3C.%22%24%22%2Fclass+HelloWorld+%7Bstatic+void+Main%28%29+0%7B%3Bn%2a%2a%2a~%23++++System%3C.Console%3C.%3C.%231024p%23rint%28512%29%3B%230%7D%7D%2F%2F4%7C%23%C3%9F%E2%80%9D6904%E2%80%9D%C2%B1r%C2%AB%22%242+%23puts+16384+8%2adi+2%5E18o8%2a%27&inputs=&version=19.8.0)
Added `27W%`
Explanation:
```
  W   2 to the power of
27    27
   %  Start of single line comment
```
[Answer]
# Answer 50: Jolf, distance 10
```
^2@2(#"#28@P2*Jp;math 2\^45#2^41 NB.`(expt 2 39); ^ exit @n.out (*2 32#e#a44******O@)//2 25)#e#2ej#printf("% $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~
#    System<.Console<.<.#1024
print(2**49);#0}}//4|
#6904r"$2 #puts 16384 8*di 2^18o8*'*[[[268*^?>
```
[Try it here!](http://conorobrien-foxx.github.io/Jolf/#code=XjJAMigjIiMyOEBQMipKcDttYXRoIDJcXjQ1IzJeNDEgTkIuYChleHB0IDIgMzkpOyBeIGV4aXQgQG4ub3V0ICgqMiAzMiNlI2E0NCoqKioqKk9AKS8vMiAyNSkjZSMyZWojcHJpbnRmKCIlICRbMioqNDNdYnllJyQvKiMiQSMzMjc7TjwuIiQiL2NsYXNzIEhlbGxvV29ybGQge3N0YXRpYyB2b2lkIE1haW4oKSAweztuKioqfgojICAgIFN5c3RlbTwuQ29uc29sZTwuPC4jMTAyNApwcmludCgyKio0OSk7IzB9fS8vNHwKIzY5MDRyIiQyICNwdXRzIDE2Mzg0IDgqZGkgMl4xOG84KicqW1tbMjY4Kl4_Pg)
Prepended `^2@2(` (+5)
Removed `±` and `ß` from `#ß6904±r` (+2)
Removed `ó` from `óout` (+1)
Removed `<?` from `<?#"#28@P2*` (+2)
Total: 10. *Remove all the non-ASCII characters!*
## Explanation
`(` stops parsing, so the code looks like:
```
^2@2
^      exponentiate
 2     two
  @2   to the 50 (char code of 2)
```
[Answer]
# Answer 52. [Befunge-98](http://quadium.net/funge/spec98.html), distance 8 + 2
Thanks to [@DestructibleWatermelon](http://chat.stackexchange.com/transcript/message/35705126#35705126) for golfing a byte!
```
--2'3k:'2k*.@2(#"#28@P2*Jp;math 2\^45#2^41 NB.`(expt 2 39); ^ exit @n.out (*2 32#e#a44******O@)//2 25)#e#2ej#printf("%d" $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024
print(2^51)--;#0}}//4|#6904r"$2 #puts 16384 8*di 2^18o8*'*[[[268*^?>
```
[Try it Online!](https://tio.run/nexus/befunge-98#Hc3BToNAFEDRvV/xMg8DTMIAj2mlgSjqxphYTVy4QIlYxoilDIGpaVPrryPpXZ7NHT3PjtZk05qLjBxkSHH2RPy@Szal@QJ6LeQMqZAhLG/Eu6N2nQGCaOEmUIDa1QayVuitAYdPTKiwlJKfesxc3yegmTspqW/s@ro1nw47rxhYOXEuo7ePvbItnyO7xogukmUqmMX8VVMOA9ypptEvum8qOAymNPUKfnRdwUNZt44LwSFpp80fwtTzfjBqk4pb3Q66UalIBYYBybPT1KFiFrqel2BwPPq@/MX5IpA9swiw25oBwnkUS4h5VQMVYaxjbvM8z2ke8@Lqchz/AQ)
Added `'3k` before the `2`, and `'2k*.` between the `2` and `@`.
`--` does nothing,  
`'3k2` puts 52 2s onto the stack, and  
`'2k*.@` multiplies them together, prints the number, and exits
Also, I added a `d"` after `printf("%` to make other people's lives easier, as I had 2 extra characters. It doesn't affect the Befunge-98 program.
[Answer]
# Answer 42: [Cubix](https://github.com/ETHproductions/cubix), distance 8
```
2^41 NB.`(expt 2 39); ^ exit @ⁿ.óout (*2 32#e#a44******O@)//2 25)#e#2ej#printf $[2**24]#'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024p#rint(512);#0}}//4|#ß6904±r"$2 #puts 16384 8*di 2^18o8*'*
```
[Try it online!](https://tio.run/nexus/cubix#HY1BSsNAFIav8sgLNJnFTOZlWlOSRdWNG@vCRRdiMDQjjMRMyEylUit4Es8gHkCwN/EiMe23/D/4v4FKJWF5wR8ive08EKTzOIcS9NZ4WPx9/PDDt914iNioCDVWSrETN4tYCAKaxuNK@gm73rT@EcI7YozUPU5CwTA4x5TO8mXBgzAQ66ZyDq5009iV7Zsads5X3qzhxZoarivTRjEku7wd/98RRm5fndfPBb@0rbONLnjBUSakOjzWoqmkOMdkvxdCveHhczZP1O9XH4QE2G28AzlLMwUZqw1QKTObsQkbhn8)
The `lert(2**31` in the middle was changed to `44******O@`.
[Answer]
# Answer 60, Vimscript, distance 10
```
"bc<<<2^57 #x??92a5*2p@^54┘#--2'3k:'2k*.@2(#"#28@P2*Jp;math 2\^45#2^41 NB.`#(expt 2 39); ^ exit @n.out (*2 32#e#a44******O@) //2 25)
"e
"2ej
:py print(2**60)
"%d" $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024print(2**53)--0;#0}}//4|#6904r"$2 #puts 16384 8*di 2^18o8*'*[[[268*^?>
```
Changed the 2 `#` on the start of the middle two lines to `"`, added a `"` in front of the first line, and `:py<space>` in front of the last line.
For clarification:
`"` is a line comment in vimscript (at least at the start of a line), and doesn't need to be matched.
Vim can run python code, so this is really equivalent to asking python for the answer.
[Answer]
# Answer 8: Perl
```
#327;N.""/class HelloWorld {static void Main() 0{;n***~
#    System.Console.
print(256);
#0}}//4|
#8Ḥ
```
Exactly distance of 10: +4 `#` for comments, +1 newline after `System.Console.`, +3 for transforming `write` into `print`, +2 for turning `2` into `256`.
I wasn't going to participate, but I wanted to make sure some regular langs were added before anything got too insane.
[Try it online!](https://tio.run/nexus/perl#@69sbKSkpJ@ck1hcrOCRmpOTH55flJOiUF1ckliSmaxQlp@ZouCbmJmnoalgUG2dp6WlVcelrAAEwZXFJam5es75ecX5Oal6XAVFmXklGkamZprWXMoGtbX6@iY1XMoWD3cs@f8fAA "Perl – TIO Nexus")
[Answer]
# Answer 49: PHP, distance 6
```
<?#"#28@P2*Jp;math 2\^45#2^41 NB.`(expt 2 39); ^ exit @n.óout (*2 32#e#a44******O@)//2 25)#e#2ej#printf("% $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~
#    System<.Console<.<.#1024
print(2**49);#0}}//4|
#ß6904±r"$2 #puts 16384 8*di 2^18o8*'*[[[268*^?>
```
Added `<?` and `?>` to open and close PHP tags, respectively.
Replaced `48` with `49`.
`#` starts a comment on PHP, so nothing is considered except for
```
<? print(2**49); ?>
```
Here's a screenshot of proper syntax highlihgting and output to help visualize:
[![screenshot](https://i.stack.imgur.com/AyLZE.png)](https://i.stack.imgur.com/AyLZE.png)
[Answer]
# Answer 2: [///](https://esolangs.org/wiki////)
```
/class HelloWorld {static void Main() {
    System.Console.Write(2);
}}//4
```
+4 chars - `///4`
[Try it online!](https://tio.run/nexus/slashes#@6@fnJNYXKzgkZqTkx@eX5STolBdXJJYkpmsUJafmaLgm5iZp6GpUM2lAATBlcUlqbl6zvl5xfk5qXrhRZklqRpGmtZctbX6@ib//wMA)
[Answer]
# Answer 7: [Minkolang](https://github.com/elendiastarman/Minkolang), Distance: 4
```
327;N.""/class HelloWorld {static void Main() 0{;n***~
    System.Console.Write(2);
0}}//4|
8Ḥ
```
[Try it online!](https://tio.run/nexus/minkolang#@29sZG7tp6ekpJ@ck1hcrOCRmpOTH55flJOiUF1ckliSmaxQlp@ZouCbmJmnoalgUG2dp6WlVcelAATBlcUlqbl6zvl5xfk5qXrhRZklqRpGmtZcBrW1@vomNVwWD3cs@f8fAA "Minkolang – TIO Nexus")
I added `7;N.` to the program. Basically `3`, `2` and `7` are pushed to the stack and then 2 is raised to the seventh power using `;`. This is then outputted as a `N`umber and then the program stops on the `.`
[Answer]
# Answer 11: [Charcoal](https://github.com/somebody1234/Charcoal), distance 5
```
Ａ#327;N.""/class HelloWorld {static void Main() 0{;n***~
#    System.Console.
1024p#rint(512);
#0}}//4|
β2048
```
**[Try It Online!](https://tio.run/nexus/charcoal#@/9@z0JlYyNzaz89JSX95JzE4mIFj9ScnPzw/KKcFIXq4pLEksxkhbL8zBQF38TMPA1NBYNq6zwtLa06LmUFIAiuLC5JzdVzzs8rzs9J1eMyNDAyKVAuyswr0TA1NNK05lI2qK3V1zep4Tq3ycjAxOL/fwA)**
The uppercase Greek letters `Ａ` and `β` are variables which are assigned the ASCII characters following. The final value is implicitly printed.
[Answer]
# Answer 10: [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), Distance of 5
```
#327;N.""/class HelloWorld {static void Main() 0{;n***~
#    System.Console.
1024p#rint(512);
#0}}//4|
#8
```
Here is a valid `dc` program which outputs `1024`.
[Try it online!](https://tio.run/nexus/dc#@69sbGRu7aenpKSfnJNYXKzgkZqTkx@eX5STolBdXJJYkpmsUJafmaLgm5iZp6GpYFBtnaelpVXHpawABMGVxSWpuXrO@XnF@TmpelyGBkYmBcpFmXklGqaGRprWXMoGtbX6@iY1XMoW//8DAA "dc – TIO Nexus")
[Answer]
# Answer 12: [Self-modifying Brainfuck](https://soulsphere.org/hacks/smbf/)
```
Ａ#327;N<.""/class HelloWorld {static void Main() 0{;n***~
#    System<.Console<.<.
1024p#rint(512);
#0}}//4|
#β6904
```
[Try it online!](https://tio.run/nexus/smbf#@/9@z0JlYyNzaz8bPSUl/eScxOJiBY/UnJz88PyinBSF6uKSxJLMZIWy/MwUBd/EzDwNTQWDaus8LS2tOi5lBSAIriwuSc210XPOzyvOz0m10bPR4zI0MDIpUC7KzCvRMDU00rTmUjaordXXN6nhUj63yczSwOT/fwA "Self-modifying Brainfuck – TIO Nexus")
SMBF is just like brainfuck, except the source code is available on the tape to the left of the starting position. Here we have the number to print in reverse at the end of the code, and we do `<.` four times to print all four digits. 
I added a `<` before each `.` in the code (there were 3 of them), an extra `<.`, and modified the final number. Distance should be 8.
[Answer]
# Answer 29: [Octave](https://www.gnu.org/software/octave/), Distance: 1
```
disp(2^29)%2 25)#e#2ej#printf $[2**24]#'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024p#rint(512);#0}}//4|#ß”6904”±r«"$2 #puts 16384 8*di 2^18o8*'
```
[Try it online!](https://tio.run/nexus/octave#Fc09isJAGIDhq3zki5hMkZ/PMSYkjdjYuM0WFqIQzAgjYyZkxoXFH7zI4gGs9gp6Ey8S9W2e8u0qaRqPVpT5PQIa@iiQxBabVtZ2A@6CGCO@xL4bMnTGOKBR/lUEjuuEa1UaA1OhlJ7rVlVwMLa0cg0/WlYwK2Xt@RAd8poxdkZ49/1rrNgVwUTXRitRBEWAcUS8wc/NG8bk5xidTmHIj/i4Pi9/SRbxN/f/9n5zXAJs9tZAnAxSDimrJNAqTnXK@l33Ag "Octave – TIO Nexus")
All I had to do was to change the `28` to `29`
[Answer]
# Answer 31: JavaScript ES7, Distance 7
```
alert(2**31)//2 25)#e#2ej#printf $[2**24]#'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024p#rint(512);#0}}//4|#ß”6904”±r«"$2 #puts 16384 8*di 2^18o8*'
```
ES7 supports the `**` operator for power.
You can [try online here](https://babeljs.io/repl/).
[Answer]
# Answer 33: Mathematica, distance 9
```
2^33 (*2 32#e#alert(2**31)//2 25)#e#2ej#printf $[2**24]#'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024p#rint(512);#0}}//4|#ß”6904”±r«"$2 #puts 16384 8*di 2^18o8*'*)
```
Explanation
Puts everything inside comments and outputs 2^33
*Please verify that this answer is valid before putting your own because I am new at this and don't want to end up breaking the chain.*
[Answer]
# Answer 37: [Actually](https://github.com/Mego/Seriously), distance 7
```
2:37@ⁿ.óout (*2 32#e#alert(2**31)//2 25)#e#2ej#printf $[2**24]#'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024p#rint(512);#0}}//4|#ß6904±r"$2 #puts 16384 8*di 2^18o8*'*
```
Replaced `36?#` with `:37@ⁿ.ó`.
[Try it online!](https://tio.run/nexus/actually#FY1BSsQwFECv8ukvTPsXSfOTmam2C8WNG924cDEolGmESmxKkxFkHMGTeAbxAIJzEy9S61u@t3gTn@r12e/7tzh@@V2EjBg0o8XG2TFmTKRVLiUDL/PZsn3EYez6@ADpZo5s7nCRSsLkHDWvq@taJGkit64JAS6tc/7Wj66FfYhN7Lbw7LsWrpquz3Io9lVPRG8IMzcvIdqnWlz4Pnhna1ELVAWbAf9v2VJxXmFxOEhpXvH4sTopzM/nmKQMOOxiALXSpYGS2g74XpW@pAVN0x8 "Actually – TIO Nexus")
[Answer]
# Answer 38: RProgN, distance 10
```
2 38 ^ exit @ⁿ.óout (*2 32#e#alert(2**31)//2 25)#e#2ej#printf $[2**24]#'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024p#rint(512);#0}}//4|#ß6904±r"$2 #puts 16384 8*di 2^18o8*'*
```
[Try it online!](https://tio.run/nexus/rprogn#FY1BSsQwFECv8ukvTPsXSfPbGSPtQnHjRjcuXMgMlGmESGxKkxFlHMGTeAbxAIJzEy9S61u@t3gTQ6lhA@bZRjj7ff8Wxy@/i5DRHBgNts6MMWOiUuVSMvAyny2bBxxG28d7SO/myNUaF6kkTM6x5JP6uhFJmsita0OAS@Ocv/Wj62AfYhvtFp687eCqtX2WQ7GveyJ6Q5i5eQnRPDbiwvfBO9OIRqAquBrw/5YtFec1FoeDlNUrHj9Wp0X18zkmKQMOuxhArUpdgabOAm@U9poWNE1/ "RProgN – TIO Nexus")
Replaced `2:37` with `2 38 ^ exit`  (10) (note the trailing space)
Explanation:
```
2            2
     ^       to the power of
  38         38
       exit  Stop the prgram
```
[Answer]
# Answer 47: [Perl 6](https://perl6.org), distance 10
```
#28@P2*Jp;math 2\^45#2^41 NB.`(expt 2 39); ^ exit @n.óout (*2 32#e#a44******O@)//2 25)#e#2ej#printf("% $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~
#    System<.Console<.<.#1024
print(2**47);#0}}//4|
#ß6904±r"$2 #puts 16384 8*di 2^18o8*'*
```
Perl 6 is considered distinct from Perl. I tried to set up C down the road by adding `"%` after `printf`, hopefully someone uses that.
[Try it online!](https://tio.run/nexus/perl6#Hc1BToNAGIbhPaf4w2AKkzjAz7SlgQXqxphYTVy4UIkjjCmGzhCYmjZtvYpnMN7Ansk1Yt/l9y2enmCc3SK9apKlMAvAx5yPCeY8hPk5e3blujGAEM28BHKQ68pAptjhW68MuHQ4kEgiOKfHbjLP9xFw7A0ryjfStJUyr659As4DUsqjp5eNHDk@JfYZiXCazFNmO7Zf1KLr4FLWtb7XbV3CtjPCVAW866qEa1Ep14Ngm6gB@bAIDN1tOiOXKbvQqtO1TFnKSBggt46m@69NvYQE@73v851FDp@TWcB/vlrbQSDNynQQTqKYQ0zLCjAPYx3TEe37X6VPC1Es5B8 "Perl 6 – TIO Nexus")
[Answer]
# Answer 48: [RProgN2](https://github.com/TehFlaminTaco/RProgN-2), distance 9
```
"#28@P2*Jp;math 2\^45#2^41 NB.`(expt 2 39); ^ exit @n.óout (*2 32#e#a44******O@)//2 25)#e#2ej#printf("% $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~
#    System<.Console<.<.#1024
print(2**47);#0}}//4|
#ß6904±r"$2 #puts 16384 8*di 2^18o8*'*[[[268*^
```
Added a `"` to the start which stopped everything from breaking, the `[[[` at the end clears the memory, and `268*^` calculates the new answer. Implicitly printed.
[Try it online!](https://tio.run/nexus/rprogn-2#Hc1NToNAGMbxPad4w2AKk8jHy5TSwAJ1Y0ysJi5coESEMR1DZwhMTZtar@IZjDewZ3KN2P/yeRa/wSQYZ7dIr9pkVeol4EPBpgQLFsDi3H2y@abVgBDOnQQK4BuhIZPu4VutNdh0PJBwUjJGj91kjuch4NQZV@SvpO2E1C@2eQJWjpSy8PF5yyeWR4l5RkKcJYvUNS3Tq5qy7@GSN426V11Tw67XpRYVvClRw3UppO2Av0vkiHwYBMbutr3mq9S9ULJXDU/d1CWBj8w4mva/NnMS4u/3nsfeDXL4jOY@@/nqTAuBtGvdQxCFMYOY1gKwCGIV0wnN8xyjmBbD8CvVaVVWS/4H "RProgN 2 – TIO Nexus")
[Answer]
# Answer 66, es (shell) + `bc`, distance 8
```
#64º,;S)1'a
"bc"<<x
2^66
x
#??92a5*2p@^54┘#--2'3k:'2k*.@2(#"#28@P2*Jp;math 2\^45#2^41 NB.`#(expt 2 39); ^ 
quit()
@n.out (*2 32#e#a44******O@) //2 25)
"e
"2ej
:
py 
p
riker
i
n
t
(2**60)
"%d" $[2**43]bye'$/*#"A#327;N<."$"/class HelloWorld {static void Main() 0{;n***~#    System<.Console<.<.#1024print(2**53)--0;#0}}//4|#6904r"$2 #puts 16384 8*di 2^18o8*'*[[[268*^?>
```
Changed `exit` to `quit()`, and added `iker` after the first `r`. I couldn't resist and I wanted to add 4 more characters.
]