[Question]
  [
# Setting the Scene:
It is an average afternoon, as you unwind after a long day by engaging in your favorite pastime: answering the plethora of captivating questions on PPCG. It hasn't been a good day for you; those damned Pyth programmers keep getting best answer and it's killing your vibe. Suddenly, you notice a new question has been posted! You make up your mind; not this time CJammers. Furiously, you begin to type, birthing a stream of characters; a fetus of the glorious BrainFuck loop that your end product will be. You type and type. Faster! Faster still! You're so focused you don't even notice the lights on your screen start to flicker on and off. Suddenly, the monitor glows green, an alien like symbol branded upon the desktop. Using your impeccable skills you `cat ~/Desktop/aliensymbol` and get presented with a bunch of numbers, a message! Being the shrewd PPCG programmer that you are, you notice that it looks like ASCII. No matter for you, you `print(chr(i) for i in file)` and decipher the message. Your first thought: "I need to share this with the community!".
...
Who would've thought it? That the first people to make contact with aliens would be the humble programmers of PPCG. Why us? Maybe it is because we are the epitome of human intelligence. Or maybe because BrainFuck is about as close as we have to an alien language. Nevertheless, the aliens - being the ultra-intelligent life forms that they are - want to test whether they should classify the human race as intelligent or not. As a test of our mental prowess, the aliens have asked us to send them a few computer programs to demonstrate that we are technologically cultured. The issue is, the only human language they understand is numerical ASCII! 
Help humankind show those creatures who the real intellectual alpha is. We need to send them a script that will convert our text based source codes into their numerical ASCII versions. Unfortunately, due to our underdeveloped technology (thanks Obama), we must send as small a translating program as possible. Good thing they chose to contact PPCG!
# The Challenge:
The premise of this challenge is simple: you are to write a program that will take any program's source code (or any general text file for that matter), and output a space separated version of it with an ASCII translation below each line. That is, given an input of a text file, you need to output each line of that file followed by a line containing the ASCII representation of each character in the line above it (with each number lining up with the character it represents).
An example will greatly clarify this. Taking the source code of the infamous `hello world` as the input:
```
#include <stdio.h>
int main() {
    printf("hello, world\n");
    return 0;
}
```
your program should output:
```
#   i   n   c   l   u   d   e       <   s   t   d   i   o   .   h   >
35  105 110 99  108 117 100 101 32  60  115 116 100 105 111 46  104 62  10
10
i   n   t       m   a   i   n   (   )       {
105 110 116 32  109 97  105 110 40  41  32  123 10
                p   r   i   n   t   f   (   "   h   e   l   l   o   ,       w   o   r   l   d   \   n   "   )   ;
32  32  32  32  112 114 105 110 116 102 40  34  104 101 108 108 111 44  32  119 111 114 108 100 92  110 34  41  59  10
                r   e   t   u   r   n       0   ;
32  32  32  32  114 101 116 117 114 110 32  48  59  10
}
125 10
```
# Implementation Details:
You may choose to take the input in whatever form you wish (opening file, command line pipe, function parameter etc.) and you should output to stdout or return the output from a function.
Things to note
* Each character in the output is separated by a '\t' to allow for the space of 3 digits in the line below to line up (we are going to assume your tab is set to 4 spaces or more).
* The newlines are displayed on the line that the return key was pressed (notice the 10's in the example)
* The '\t' and '\n' printing requirements are lax. Your output must, in the general sense, look pleasing to the eye (need to show those aliens we have aesthetic sense as well), and if you can bend the previous two points while maintaining visual integrity, you will be forgiven.
* You can choose to assume whether or not there is a newline at the end of the last line.
# Scoring
This is code-golf so shortest program wins. Note, even if your program isn't the shortest, but uses really neat tricks relative to the language you are using, many +1's to you!
Good luck. The intergalactic intelligence ranking of humanity rests on your shoulders.
Note: Please forgive the plot holes. [I'm not a writer](https://www.youtube.com/watch?v=MeB3eYk1Ze0&feature=youtu.be&t=1m55s) :D
  
[Answer]
# Pyth, ~~17~~ 13 bytes
Another one of those Pyth programmers. *Sorry.*
The new code requires each line to be wrapped in quotes and escaped (including newlines if you desire them to be printed), but puts an extra newline between the line and the ASCII.
```
jjLC9smCMBd.Q
```
[Try it online!](http://pyth.herokuapp.com/?code=jjLC9smCMBd.Q&input=%22hello%5Cn%22%0A%22world%5Cn%22%0A%22%5Cn%22%0A%22Testing%5Cn%22&debug=0)
Explanation:
```
           .Q  Evaluate all input lines
      m        For each of those lines:
         Bd     Return the line and
       CM       the line mapped to ASCII characters
     s         Sum all these together to begin alternating between line and mapped line
 jLC9          Join all the characters and numbers in the lines and mapped lines on tabs
j              And join all of those on newlines
```
I'm keeping the old code and its' explanation below.
```
#Jw
jKC9J
jK+CMJT
```
[Try it online!](http://pyth.herokuapp.com/?code=%23Jw%0AjKC9J%0AjK%2BCMJT&input=%23include+%3Cstdio.h%3E%0A%0Aint+maint%28%29+%7B%0A++++printf%28%22hello%2C+world%5Cn%22%29%3B%0A++++return+0%3B%0A%7D&debug=0) or use an [easier-to-read test case](http://pyth.herokuapp.com/?code=%23Jw%0AjKC9J%0AjK%2BCMJT&input=%5C%2F%5C%2F%0ATesting+123%0A%0A%0ATest&debug=0).
Explanation:
```
#                  Until we run into an error:
 Jw                 Read in the next line of input and call it J.
                     (When there is no line of input, error is thrown that ends program.) 
j                  Join: 
    J               all characters in input line
 KC9                and insert tab characters (C9), which we can refer to later as K.
                        (Setting it to a variable doesn't save or lose bytes.)
                   Implicit print that join with trailing newline.
j                  Join:
   CMJ              the mapping of ASCII numbers to characters in the input,
 K                  inserting tab characters in between every number
  +   T             And with a trailing 10 for the newline at the end.
```
[Answer]
# Python 2, 105 bytes
This uses a slightly different approach than the OP's answer. Note that SO messes up my literal tabs with spaces.
```
def f(s):
 o=x=''
 for c in s:
    o+=c+"  ";x+="%s    "%ord(c)
    if"\n"==c:print o[:-1],x;o=x=''
 print o+"\n"+x
```
[**Try it online**](https://repl.it/DLjw)
[Answer]
# Vim, ~~86,~~ 77 keystrokes
```
:g/^/norm A<C-v><C-v>10<C-v><esc>Yp:s/./\=char2nr(submatch(0))."\t"/g<C-v><cr>k:s/./&\t/g<C-v><cr>
:%s/<C-v><cr>0<cr>
```
This is way too long, but that's what you get when you use vim's `eval` feature (`\=`).
[Answer]
# Perl, ~~>33~~ 31 bytes
Includes +3 for `-F` (cannot be combined with `-e` and the code has `'` too, so space and `-` are counted too).
Run with the input on STDIN or give one or more filenames as argument
```
perl -M5.010 asciidump.pl <<< "Hoi"
```
`asciidump.pl`
```
#!/usr/bin/perl -F
$"=v9;say"@F@{[unpack'W*']}"
```
Output is not aesthetic if the text contains a tab or there is no final newline
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), 14 [bytes](http://meta.codegolf.stackexchange.com/a/9429/43319)
Takes list of strings that include newline sequences (10 or 13 10 etc.)
```
↑(⊢,[.5]⎕UCS)¨
```
`↑` matrify the list of lists consisting of
`(`...`)¨` for each line return...
 `⊢` the text itself
 `,[.5]` followed in a new dimension before the first dimension by
 `⎕UCS` the **U**nicode **C**haracter **S**et code points
[TryAPL online!](http://tryapl.org/?a=f%u2190%u2191%28%u22A2%2C%5B.5%5D%u2395UCS%29%A8%20%u22C4%20f%20%28%27include%20%3Cstdio.h%3E%27%2C%u2395ucs%2010%29%28%2C%u2395UCS%2010%29%28%27int%20main%28%29%20%7B%27%2C%u2395ucs%2010%29%28%27%20%20%20%20printf%28%22hello%2C%20world%5Cn%22%29%3B%27%2C%u2395ucs%2010%29%28%27%20%20%20%20return%200%3B%27%2C%u2395ucs%2010%29%28%27%7D%27%2C%u2395ucs%2010%29&run)
[Answer]
# Pyth, 21 bytes
```
j.imjC9d.zmjC9+CMdT.z
```
Here's an entry from one of *"those damned Pyth programmers"* ;)
A program that takes input of an unquoted multiline string on STDIN and prints the result. This assumes that all input has a trailing newline. If you want it to deal with no trailing newline, add `<` at the beginning of the program and `)_3` at the end.
[Try it online](https://pyth.herokuapp.com/?code=j.imjC9d.zmjC9%2BCMdT.z&input=%23include+%3Cstdio.h%3E%0A%0Aint+maint%28%29+%7B%0A++++printf%28%22hello%2C+world%5Cn%22%29%3B%0A++++return+0%3B%0A%7D&debug=0)
The output for the test case is difficult to see in the online interpreter, so I've included it here:
```
#   i   n   c   l   u   d   e       <   s   t   d   i   o   .   h   >
35  105 110 99  108 117 100 101 32  60  115 116 100 105 111 46  104 62  10
10
i   n   t       m   a   i   n   t   (   )       {
105 110 116 32  109 97  105 110 116 40  41  32  123 10
                p   r   i   n   t   f   (   "   h   e   l   l   o   ,       w   o   r   l   d   \   n   "   )   ;
32  32  32  32  112 114 105 110 116 102 40  34  104 101 108 108 111 44  32  119 111 114 108 100 92  110 34  41  59  10
                r   e   t   u   r   n       0   ;
32  32  32  32  114 101 116 117 114 110 32  48  59  10
}
125 10
```
**How it works**
```
j.imjC9d.zmjC9+CMdT.z  Program. Input: .z (All of STDIN split on newlines)
     C9                 Yield tab character by taking chr(9)
    j                   Join on tab
   m   d.z             Map that over .z
               CM       Map ord()
              +   T     Append 10
           jC9          Join on tab
          m      d .z  Map that over .z
 .i                    Interleave the results of the two mappings
j                      Join on newlines
                       Implicitly print
```
[Answer]
## C, ~~136~~ ~~117~~ 114 Bytes
```
#define p(s)while(l[i])printf(s,l[i++]);i=0;puts("")
char l[99];i;f(f){while(fgets(l,99,f)){p("%c\t");p("%d\t");}}
```
~~`char l[99];i;f(f){while(fgets(l,256,f)){i=0;while(l[i])printf("%c\t",l[i++]);i=0;puts("");while(l[i])printf("%d\t",l[i++]);puts("");}}`~~
Can be tested like this
```
infile;
main(c,v)char**v;
{
    infile=fopen(v[1],"r");
    f(infile);    
}
```
[Answer]
## PowerShell v2+, 85 bytes
```
gc $args|%{$a=$b='';$_-split'(.)'-ne''|%{$a+="$_`t";$b+="$(+[char]$_)`t"};$a;$b+"10"}
```
Input is via a path to a file. We then `Get-Content` (alias `gc`) on that file, which automatically splits on newlines. We loop over each of those `|%{...}`. Start by setting `$a` and `$b` to an empty string -- these are our ASCII characters and code points respectively. We then `-split` the input line on every character, keeping it `(.)`, and removing the empty values `-ne''` (it's due to how .NET regex parses), then send those into another loop.
Each inner loop, we string concatenate the current character with a tab ``t` and add that onto `$a`. Similarly for `$b`, excepting we're explicitly casting as a `char` and then as an int `+`.
Outside the inner loop, we place the resulting `$a` and `$b` (with a linefeed designator, since that'll never come up in our looping) on the pipeline. Those are gathered up with an implicit `Write-Output` at program completion.
### Example
(with the understanding that I've got a trailing linefeed and Markdown mangles the tab character)
```
PS C:\Tools\Scripts\golfing> .\aliens-only-understand-ascii.ps1 '.\aliens-only-understand-ascii.txt'
#   i   n   c   l   u   d   e       <   s   t   d   i   o   .   h   >   
35  105 110 99  108 117 100 101 32  60  115 116 100 105 111 46  104 62  10
10
i   n   t       m   a   i   n   t   (   )       {   
105 110 116 32  109 97  105 110 116 40  41  32  123 10
                p   r   i   n   t   f   (   "   h   e   l   l   o   w   ,       w   o   r   l   d   \   n   "   )   ;   
32  32  32  32  112 114 105 110 116 102 40  34  104 101 108 108 111 119 44  32  119 111 114 108 100 92  110 34  41  59  10
                r   e   t   u   r   n       0   ;   
32  32  32  32  114 101 116 117 114 110 32  48  59  10
}   
125 10
```
[Answer]
# ><> (Fish), 48 Bytes
```
>i:0(?v::oa=?v9o
2';'oa<.20r  <~p3
o9nv?=0l
voa<
```
A task the language shines at! I'm sure I could probably have golfed out a little bit more, but it's been a long week. Might take a look at it later though.
[Try it online!](http://fish.tryitonline.net/#code=Pmk6MCg_djo6b2E9P3Y5bwoyJzsnb2E8LjIwciAgPH5wMwpvOW52Pz0wbAp2b2E8&input=I2luY2x1ZGUgPHN0ZGlvLmg-CgppbnQgbWFpbnQoKSB7CiAgICBwcmludGYoImhlbGxvLCB3b3JsZFxuIik7CiAgICByZXR1cm4gMDsKfQ)
[Alternate](https://fishlanguage.com/playground/Ft8ZT6j34fPzpYA4S) try it online that looks nicer in my opinion, but the text wrapping messes up a bit for input with long lines like the test case.
[Answer]
# PHP, ~~131~~ 115 bytes
Just a FGITW, maybe I can improve upon it more. Turns out, I can!
First version at 131 bytes:
```
<?$s=file($argv[1]);foreach($s as$l){$a=str_split(trim($l));echo join(' ',$a).'
';$i=0;while($c=ord($l{$i++}))echo$c.'  ';echo'
';};
```
The filename is supplied as the first argument after the script name: `php aliens.php helloworld.c`
Second version at 115 bytes:
```
function($s){foreach($s as$l){$a=str_split($l);echo join('  ',$a);$i=0;while($c=ord($a[$i++]))echo$c.'  ';echo'
';}};
```
The first version accounts for missing newlines at the end of the line, but after the additional clarification, we can leave that code out and put everything in a function to save 16 bytes.
The whitespace characters in `join(' ',$a)` as well as in `echo$c.' '` are tab characters = `\t`. The newlines in the code are on purpose.
[Answer]
# Python 3, ~~89~~ 77 bytes
more golfed version based on the same idea:
```
def f(s):
 for a in s:print(*map('{:>4}'.format,[*a,*a.encode()]),end='\n\n')
```
If there are '\t's in the input, then change the `4` to a `9`.
### Prior version:
```
def f(s):
 for l in s:
  print(*l,sep='\t',end='');print(*l.encode(),sep='\t',end='\n\n')
```
Takes a list of strings, each ending with a '\n'.
[Answer]
# Powershell, 56 Bytes
```
gc $args|%{($a=[char[]]$_)-join"    ";[int[]]$a+10-join"    "}
```
Script accepts a filepath as input. Get-Content automatically splits input into an array of strings split on newlines in the source.
From there I enter a foreach, cast to an array of characters and set that to $a, join that with tabs and print it. Next but still within the foreach I cast the character array to an integer array, append a linefeed and join again with a tab.
Call looks like this:
```
PS C:\PretendFolder> .\aoua.ps1 ".\aoua.txt"
```
and here is an output sample
```
#   i   n   c   l   u   d   e       <   s   t   d   i   o   .   h   >
35  105 110 99  108 117 100 101 32  60  115 116 100 105 111 46  104 62  10
10
i   n   t       m   a   i   n   (   )       {
105 110 116 32  109 97  105 110 40  41  32  123 10
                p   r   i   n   t   f   (   "   h   e   l   l   o   ,       w   o   r   l   d   \   n   "   )   ;
32  32  32  32  112 114 105 110 116 102 40  34  104 101 108 108 111 44  32  119 111 114 108 100 92  110 34  41  59  10
                r   e   t   u   r   n       0   ;
32  32  32  32  114 101 116 117 114 110 32  48  59  10
}
125 10
```
[Answer]
## JavaScript (ES6), 94 bytes
```
s=>s.replace(/(.*)\n?/g,(s,n)=>n&&[...s].join`␉`+`
${[...n].map(c=>c.charCodeAt()).join`␉`}
`)
```
Where ␉ represents the literal tab character. Works as long as the input doesn't contain tab characters. 81-byte version that also requires the input to have a trailing newline:
```
s=>s.replace(/.*\n/g,s=>[...s].join`␉`+[...s].map(c=>c.charCodeAt()).join`␉`+`
`)
```
[Answer]
# C#, ~~64~~ 63 bytes
```
s=>{foreach(int c in s+(s=""))s+=c+(10==c?"\n":"    ");return s;};
```
*-1 byte by using actual tab character instead of `\t`. Note: renders as 4 spaces above and 2 spaces in the ungolfed version below.*
Ungolfed:
```
/*Func<string, string> Lambda =*/ s =>
{
    // Enumerate the ascii (int) values of the chars in s, 
    // but at the same time set input s to "" to use at the output var.
    // +(s="")   is 2 bytes less than   var o="";
    foreach (int c in s + (s=""))
        // Append the string representation of the ascii value,
        // Append new line if c was new line, otherwise append tab. 
        s += c + (10==c ? "\n" : "  ");
    return s;
};
```
Results:
(Note: Visual Studio has used `\r\n` for the new lines when I pasted the input in, hence the `13 10` line endings in output)
```
Input:
#include <stdio.h>
int maint() {
    printf("hello, world\n");
    return 0;
}
Output:
35  105 110 99  108 117 100 101 32  60  115 116 100 105 111 46  104 62  13  10
13  10
105 110 116 32  109 97  105 110 116 40  41  32  123 13  10
32  32  32  32  112 114 105 110 116 102 40  34  104 101 108 108 111 44  32  119 111 114 108 100 92  110 34  41  59  13  10
32  32  32  32  114 101 116 117 114 110 32  48  59  13  10
125 
```
[Answer]
# CJam, 27 bytes
```
qN/{_1/9c*N+\{is9c}%+}%AN+*
```
[Try it online!](http://cjam.tryitonline.net/#code=cU4ve18xLzljKk4rXHtpczljfSUrfSVBTisq&input=aGVsbG8Kd29ybGQ)
**Explanation**
```
q       e# Take the whole input
N/      e# Split on newlines
{       e# Map this block to every line:
_        e# Duplicate
1/       e# Split into characters
9c*      e# Join with tabs (ASCII code 9)
N+       e# Append a newline
\        e# Swap top elements
{is9c}%  e# Map each character to its ASCII code plus a tab character
+        e# Concatenate the two lines
}%      e# (end of block)
AN+*    e# Join with "10" plus a newline
```
[Answer]
# PowerShell, ~~61~~ 59 bytes
```
gc m|%{$b="$_
"[0..$_.Length]
$b-join'    '
[int[]]$b-join' '}
```
Things to note:
* Reads the input from a file named `m` in the current directory.
* All line breaks, (including the one embedded in the string after the first `$_`) are literal linefeeds only (0xA), so one byte each.
* The contents of the strings directly after the `-join` operators are each a single tab character (regardless of how it's rendered here).
### Ungolfed
```
Get-Content m | ForEach-Object -Process { # Read the file line by line
    $b = "$_`n"[0..$_.Length]   # Line by line processing strips line endings, so add a newline
                                # Index operator on a [string] returns a [char], or given a [range], a [char[]]
                                # Using $_.Length automatically accounts for the extra linebreak (0 based index)
    $b -join "`t"               # PowerShell displays [char] as the printable character by default, so join the array with a tab
    [int[]]$b -join "`t"        # We need to convert the [char]s to an [int]s so we can display it as a number
                                # So cast the [char[]] as [int[]], then join with tab again
}
```
[Answer]
# Java, 202 bytes
```
s->{for(String g : s.split("\n")){g.chars().forEach(c->System.out.print((char)c+"   "));System.out.println();g.chars().forEach(c->System.out.print(c+(c<10?"  ":c<100?"  ":" ")));System.out.println();}};
```
I can't even be bothered making this shorter..
[Answer]
# Haskell - 71 bytes
```
f q=unlines[(x>>=(++"\t").show.ord)++'\n':intersperse '\t'x|x<-lines q]
```
[Answer]
# **Python 3, ~~92 97~~ 107 bytes**
~~for i in list(open(input()).read().split("\n")):
 for j in i: print(i+"\n"+ord(j))~~
```
p=print
for i in list(open(input()).read().split("\n"))
    s=t=''
    for j in i:
        r=str(ord(j))
        s+=j+' '*len(r)
        t+=r+' '
    p(s)
    p(t)
```
This is untested, but should work.
Thanks @gowrath for pointing out that the code isn't doing as the question specifies.
]