[Question]
  [
# Code Golf
*Totally real* backstory: I'm a contractor working on a website www.**Sky.Net** and one of our tasks it to create some self-aware program or something, I don't know I wasn't really listening to the boss. Anyways in an effort to make our code more self-aware we need *IT* to be able to know what code is on each line-number.
---
# Challenge
Create a program or function that takes an input `n` and returns the code of said program or function on line `n`.
---
# Rules
➊ Your program or function must be at least 4 lines long. Each line must be unique.
➋ You may assume the input will always be a positive integer greater than or equal to 1 and less than or equal to the number of lines in your program/function.
➌ The first line in your program/function is line 1, not line 0.
➍ You can not access the file that your program is on. (If someone has to ask "Isn't this technically breaking rule #4"; it probably is)
➎ Lines can-not be empty *(this includes a space if spaces don't do anything in your language)*
➏ Lines can-not be //comments (/\* of any <!--style)
---
This is a [quine](/questions/tagged/quine "show questions tagged 'quine'")-like challenge  
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the submission with the fewest bytes wins!
  
[Answer]
# Vim, 7 bytes
```
1
2
3
4
```
[Try it online!](https://tio.run/nexus/v#@2/IZcRlzGXy/78xAA "V – TIO Nexus")
As far as I can tell, this complies with all of the rules. In vim by default, the empty program prints out all of the input. Since
```
<N><CR>
```
Is a noop, nothing changes the input text, and since each input matches the desired output, this same approach works with any number of lines.
[Answer]
# Ruby, ~~71~~ ~~70~~ 66 bytes
[Try it online!](https://repl.it/FylY/4)
```
->n{
k=["}", "k[-n]%%k.inspect", "k=%s", "->n{"]
k[-n]%k.inspect
}
```
**"Cheating" Mode: 7+1 = 8 bytes**
Requires the `-p` flag for +1 byte. Literally a copy of [the V answer](https://codegolf.stackexchange.com/a/111446/52194). Prints the number that is inputted; the entire program is effectively just no-ops.
```
1
2
3
4
```
[Answer]
## Haskell, ~~69~~ 59 bytes
```
(lines(s++show
 s)
 !!)
s="\n(lines(s++show\n s)\n !!)\ns="
```
Based on the standard Haskell quine. The first expression (spread over the first three lines) is an unnamed function that picks the nth line from the quinified string `s` (`s++show s`). +2 bytes for making indexing 1-based (imho an unnecessary rule).
For a [Try it online!](https://tio.run/nexus/haskell#@59mq5GTmZdarFGsrV2ckV/OpVCsyaWgqKjJVWyrFJOHLh2TB5QHEkAFMXlAFf9zEzPzFGwVchMLfBU0CkpLgkuKfPL00jQVog319ExiFf4DAA "Haskell – TIO Nexus") version I have to name the function which adds 4 bytes. 
[Answer]
# [PowerShell](https://github.com/PowerShell/PowerShell), ~~184~~ 172 bytes
```
$v=0,
'$v=0,',
"'`$v=0',",(($q='"{0}`$v=0{0},",(($q={0}{1}{0})-f([char]39),$q)')-f([char]39),$q),
(($z='(($z={0}{1}{0})-f([char]39),$z;$v[$args]')-f([char]39),$z);$v[$args]
```
[Try it online!](https://tio.run/nexus/powershell#M9TTM1GoUVBVqObiDC/KLEnV9cgvLlFQ8snMS1VQqY6vtVJS0PXL90stzwGKoKhR0VBQU6j@r1Jma6DDpQ6m1HW4lNQTQEx1HSUdDQ2VQlt1pWqDWrAQkIYJApnVhrVAUlM3TSM6OSOxKNbYUlNHpVBTHUNEhwuopcpWHUzi0lhlrVIWrZJYlF4ci25ClSZC7j9nrYJKvIImV@1/AA "PowerShell – TIO Nexus")
## Explanation
Starts by creating an array `$v` on the first line. On that same line, the first (`0`th) element is set to `0`, and a comma `,` continues its definition.
The next line sets the next element (`1`) of the array to a string representing the content of the first line of the script, so that `$v[1]` returns the first line.
The 3rd line first sets the 3rd element of the array (index `2`) to a string representing the 2nd line of the script, then on the same line sets the 4th element (index `3`) using a quine snippet that uses the format operator (`-f`) to replace certain instances of single quotes (`[char]39`) and the format template string, into itself, to reproduce the entirety of the 3rd line.
Line 4 basically does the same thing, but also ends the creation of the array and then indexes into it using the supplied argument.
[Answer]
# Python 2, 104 73 67 bytes
Thanks to Jonathan Allan for saving 6 bytes!
```
s=\
['print s[input()]or s', 's=\\', 0, 'exec s[', '0]']
exec s[
0]
```
**Edit:** Same byte count, but I like this solution better
[Try it online!](https://tio.run/nexus/python2#@19sG8MVrV5QlJlXolAcnZlXUFqioRmbX6RQrK6joA6UjQHSBkBmakVqMlAFSNQgVj2WC8rnMoj9/98IAA)
Python version of Value Ink's [Ruby answer](https://codegolf.stackexchange.com/questions/111439/input-number-output-line-number/111444#111444).
Older answer (67 bytes):
```
1
s=\
['print s[-input()]or s', 0, 's=\\', 1]
print s[-input()]or s
```
[Answer]
## [CJam](https://sourceforge.net/p/cjam), ~~19~~ ~~18~~ 17 bytes
```
1
{'_'~]ri(=}
_
~
```
[Try it online!](https://tio.run/nexus/cjam#@2/IVa0er14XW5SpYVvLFc9V9/@/EQA "CJam – TIO Nexus")
Based on the standard CJam-quine. The `{...}_~` runs the `...` with the block itself on the stack (and in this case, also `1` below that). Then we do:
```
'_'~  e# Push the third and fourth line.
]     e# Wrap all four lines in a list.
ri    e# Read input and convert to integer.
(=    e# Use as index into the lines.
```
[Answer]
# PHP, 261 bytes
```
<?php function f($l){
$a="aWYoJGw9PTEpJG09Ijw/cGhwIGZ1bmN0aW9uIGYoXCRsKXsiO2lmKCRsPT0yKSRtPSJcJGE9XCIkYVwiOyI7aWYoJGw9PTMpJG09IlwkYj1cIiR";
$b="iXCI7IjtpZigkbD09NCkkbT0iZXZhbChiYXNlNjRfZGVjb2RlKFwkYS5cJGIpKTt9Pz4iO2VjaG8gJG07";
eval(base64_decode($a.$b));}?>
```
[Try it online !!](https://tio.run/#IJOXD) 
The encoded string is:
```
if($l==1)$m="<?php function f(\$l){";
if($l==2)$m="\$a=\"$a\";
if($l==3)$m="\$b=\"$b\";
if($l==4)$m="eval(base64_decode(\$a.\$b));}?>";
echo $m;
```
[Answer]
# Perl, 52 bytes
```
$_=q{print+(split/
/,"\$_=q{$_};
eval")[<>-1]};
eval
```
This is a simple variation on the classic quine
```
$_=q{print"\$_=q{$_};eval"};eval
```
The "payload" is `split` on newlines and the correct line is selected by indexing into the resulting list.
# Perl, ~~49~~ 48 bytes (non-competing)
```
#!/usr/bin/perl -d:A
sub DB'DB{
print${"_<$0"}[<>]}
1
```
38 bytes for the code (excluding the shebang but including `-d:A`) plus 10 bytes for the filename, which must be `Devel/A.pm`. The `Devel` directory must be in `@INC`.
Technically, this violates Rule #4 because `-d:A` causes the file to be parsed twice, so it's a non-competing solution.
It uses a [debugger hook](http://perldoc.perl.org/perldebguts.html#Debugger-Internals) to access the lines of the file, which perl stores in the `@{"_<$filename"}` array at compile time.
]