[Question]
  [
Frequently while I'm code-golfing, I'll want to know what the ASCII value of a certain character is. One of my favorite resources for quickly looking up all of the [printable ASCII characters](https://en.wikipedia.org/wiki/ASCII#Printable_characters) is [ASCIItable.com](http://www.asciitable.com/). This has a really nice image that not only shows the printable ASCII characters and their values, but also the unprintable and extended characters, and the values in hexadecimal, octal, and HTML:
[![enter image description here](https://i.stack.imgur.com/iCOov.gif)](https://i.stack.imgur.com/iCOov.gif)
Today's challenge is to recreate that ASCII table as an ASCII table instead of an image. To keep things simpler, we will not use control-characters (characters below 32) and we'll only show the decimal value and the character. In other words, your challenge is to write either a full-program or a function that prints or returns the following text:
```
Dec  Chr   | Dec  Chr   | Dec  Chr
----------------------------------
32   Space | 64   @     | 96   `
33   !     | 65   A     | 97   a
34   "     | 66   B     | 98   b
35   #     | 67   C     | 99   c
36   $     | 68   D     | 100  d
37   %     | 69   E     | 101  e
38   &     | 70   F     | 102  f
39   '     | 71   G     | 103  g
40   (     | 72   H     | 104  h
41   )     | 73   I     | 105  i
42   *     | 74   J     | 106  j
43   +     | 75   K     | 107  k
44   ,     | 76   L     | 108  l
45   -     | 77   M     | 109  m
46   .     | 78   N     | 110  n
47   /     | 79   O     | 111  o
48   0     | 80   P     | 112  p
49   1     | 81   Q     | 113  q
50   2     | 82   R     | 114  r
51   3     | 83   S     | 115  s
52   4     | 84   T     | 116  t
53   5     | 85   U     | 117  u
54   6     | 86   V     | 118  v
55   7     | 87   W     | 119  w
56   8     | 88   X     | 120  x
57   9     | 89   Y     | 121  y
58   :     | 90   Z     | 122  z
59   ;     | 91   [     | 123  {
60   <     | 92   \     | 124  |
61   =     | 93   ]     | 125  }
62   >     | 94   ^     | 126  ~
63   ?     | 95   _     | 127  DEL
```
Trailing spaces on each line, and a trailing newline are permitted. Since this is a [kolmogorov-complexity](/questions/tagged/kolmogorov-complexity "show questions tagged 'kolmogorov-complexity'") challenge, your submission may not take any input, or access any external resources (such as a file or the web), and your goal is to compress the code to output this text as much as possible.
Standard loopholes apply, and the shortest answer in bytes wins. Happy golfing!
  
[Answer]
## Python ~~2~~ 3.6, ~~185~~ ~~183~~ ~~175~~ ~~159~~ 156 bytes
Saved 8 bytes thanks to FlipTack!
Still quite new to golfing in Python.
```
for a in["Dec  Chr   | "*3,"-"*39]+["".join(f"{l:<5}{('Space',chr(l),'DEL')[(l>32)+(l>126)]:<6}| "for l in(i,32+i,64+i))for i in range(32,64)]:print(a[:-5])
```
Uses a nested list comprehension to generate the table body.
Ungolfed:
```
lines =   \
  ["Dec  Chr   | "*3, "-"*39] +                      # first two lines
    ["".join(                                        # join 3 parts of each line
      f"{l:<5}{('Space',chr(l),'DEL')[(l>32)+(l>126)]:<6}| " 
        for l in (i,32+i,64+i)                       # generate 3 parts of a line
      )
      for i in range(32,64)]
for line in lines: print line[:-5]
```
Update: apparently using f-string here is shorter than the `%` operator.
---
### Old attempt, ~~185~~ ~~183~~ 175 bytes
```
print("Dec  Chr   | "*3)[:-5]+"\n"+"-"*34
a=lambda x:('Space',chr(x),'DEL')[(x>32)+(x>126)]
for l in range(32,64):print("%-5d%-6s| "*3%(l,a(l),l+32,a(l+32),l+64,a(l+64)))[:-5]
```
Ungolfed:
```
print ("Dec  Chr   | "*3)[:-5] + "\n" + "-"*34
def a(x):
    return "Space" if x==32 else "DEL" if x==127 else chr(x)
for line in range(32,64):
    print ("%-5d%-6s| "*3 % (line, a(line), line+32, a(line+32), 
      line+64, a(line+64))) [:-5]
```
[Answer]
# Befunge, ~~176~~ 172 bytes
```
<v"Dec  Chr   "0
^>:#,_$1+:2`#v_" |",,
\:#->#1_55+,v>55+,"!-":>,#:
+2*,:"_"`#@_v>1+:8-#v_$1+:3%!:7g,!29+*5
*84+1%3\/3::<^,gg00:<`"c"p00+5+`"~"\`*84::p62:.:+*
  Space
| DEL
```
[Try it online!](http://befunge.tryitonline.net/#code=PHYiRGVjICBDaHIgICAiMApePjojLF8kMSs6MmAjdl8iIHwiLCwKXDojLT4jMV81NSssdj41NSssIiEtIjo+LCM6CisyKiw6Il8iYCNAX3Y+MSs6OC0jdl8kMSs6MyUhOjdnLCEyOSsqNQoqODQrMSUzXC8zOjo8XixnZzAwOjxgImMicDAwKzUrYCJ+IlxgKjg0OjpwNjI6LjorKgogIFNwYWNlCgp8IERFTA&input=)
[Answer]
# Pyth, ~~89~~ ~~85~~ ~~79~~ 77 bytes
```
PP*"Dec  Chr   | "3*\-34V32PPsm++.[`=+N32;5.[?qN32"Space"?qN127"DEL"CN;6"| "3
```
[Try it online!](http://pyth.herokuapp.com/?code=PP%2a%22Dec++Chr+++%7C+%223%2a%5C-34V32PPsm%2B%2B.%5B%60%3D%2BN32%3B5.%5B%3FqN32%22Space%22%3FqN127%22DEL%22CN%3B6%22%7C+%223&debug=0)
[Answer]
## JavaScript (ES6), ~~179~~ 173 bytes
```
f=n=>n?(n>>6?' | ':`
`)+n+(99<n?'  ':'   ')+(126<n?'DEL':String.fromCharCode(n)+'    '+f(n>95?n-63:n+32)):`${x='Dec  Chr   '}| ${x}| ${x}
${'-'.repeat(34)}
32   Space`+f(64)
console.log(f())
```
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~98, 96~~, 94 bytes
```
i32 | 64 | 9631ñÙl.l.ñÍä«/&   &    
ÎéiD@"
bsDELF 27kdH5lRSpaceÄÒ-Ä3RDec  Chr³ | Î35|D
```
[Try it online!](https://tio.run/nexus/v#@59pbKRQo2BmAiQszaSNDQ9vPDyTMUcvRw/I6D285NBqfTUFBQUxMRCpwHW47/DKTBcHJa6kYhdXH2k3BTEj8@wUD9OcoOCCxORU6cMthyfpHm4xDnJJTVZQcM4oOrQZaLD04T5j0xqX//8B "V – TIO Nexus")
Just *barely* squeaking in under a hundred. I'm gonna see if I can beat Pyth, but I won't make any promises.
Here is a hexdump:
```
00000000: 6933 3220 7c20 3634 207c 2039 361b 3331  i32 | 64 | 96.31
00000010: f1d9 016c 2e6c 2ef1 cde4 ab2f 2620 2020  ...l.l...../&   
00000020: 1616 2620 2020 200a cee9 6944 4022 0a62  ..&    ...iD@".b
00000030: 7344 454c 1b46 2016 3237 6b64 4835 6c52  sDEL.F .27kdH5lR
00000040: 5370 6163 651b c4d2 2dc4 3352 4465 6320  Space...-.3RDec 
00000050: 2043 6872 b320 7c20 1bce 3335 7c44        Chr. | ..35|D
```
And here's how it works:
```
i32 | 64 | 96<esc>      " Insert some starting text
31ñ          ñ          " 31 times:
   Ù                    "   Duplicate this line
    <C-a>               "   Increment the first number on this line
         l.             "   Increment the next number
           l.           "   Increment the next number
```
Here is where it get's interesting. First, let me explain a vim-trick. While in insert mode, certain characters are inserted (all printable ASCII-characters, most unmapped characters above `0x7f`, and a few others), but other characters have a side-effect. For example, `0x1b` (`<esc>`) will escape to normal mode. `0x01` (`<C-a>`) will re-insert the last inserted text, etc. Sometimes, we want to insert these characters literally. So to insert a literal escape character, you must type `<C-v><esc>`. This works for all characters that have a side effect. So essentially, `<C-v>` is the equivalent of a backslash in languages with string literals that allow you to escape certain characters in a string.
The other useful trick with `<C-v>` in insert mode, is that it can be used to [insert characters by code-point](http://vimdoc.sourceforge.net/htmldoc/insert.html#i_CTRL-V_digit), in either Decimal, Hexadecimal, Octal, or Hexadecimal Unicode. Since we already have the numbers that correspond to certain ASCII values, we just need to put a `<C-v>` before those characters, and run the corresponding text as vim-keystrokes. This can be achieved with a regex command, and a "Do 'x' on every line" command. So we:
```
Í                       " Substitute globally:
 ä«                     "   One or more digits
   /                    " With:
    &                   "   The matched number + some spaces
        <C-v><C-v>&     "   A ctrl-v character, then the matched number again
                        "   Since ctrl-v is like a backslash, we need two to enter a literal ctrl-v character
Î                       " On every line:
 éi                     "   Insert an 'i'
   D                    "   Delete this line
    @"                  "   Run it as vim keystrokes
```
At this point, the buffer looks like this
```
32         | 64   @     | 96   `    
33   !     | 65   A     | 97   a    
34   "     | 66   B     | 98   b    
35   #     | 67   C     | 99   c    
36   $     | 68   D     | 100   d    
37   %     | 69   E     | 101   e    
38   &     | 70   F     | 102   f    
39   '     | 71   G     | 103   g    
40   (     | 72   H     | 104   h    
41   )     | 73   I     | 105   i    
42   *     | 74   J     | 106   j    
43   +     | 75   K     | 107   k    
44   ,     | 76   L     | 108   l    
45   -     | 77   M     | 109   m    
46   .     | 78   N     | 110   n    
47   /     | 79   O     | 111   o    
48   0     | 80   P     | 112   p    
49   1     | 81   Q     | 113   q    
50   2     | 82   R     | 114   r    
51   3     | 83   S     | 115   s    
52   4     | 84   T     | 116   t    
53   5     | 85   U     | 117   u    
54   6     | 86   V     | 118   v    
55   7     | 87   W     | 119   w    
56   8     | 88   X     | 120   x    
57   9     | 89   Y     | 121   y    
58   :     | 90   Z     | 122   z    
59   ;     | 91   [     | 123   {    
60   <     | 92   \     | 124   |    
61   =     | 93   ]     | 125   }    
62   >     | 94   ^     | 126   ~    
63   ?     | 95   _     | 127       
```
Now we just need some general clean up, which accounts for most of the bytes in this answer
```
bsDEL<esc>              " Change the literal 0x7f character to "DEL"
          F <C-v>27kd   " Remove a space from the lines that have too many
H5l                     " Move to the first space character
   RSpace<esc>          " And replace it with "Space"
Ä                       " Duplicate this line
 Ò-                     " And replace it with '-'s
   Ä                    " Duplicate this line
    3R                  " And replace it with three copies of the following string:
      Dec  Chr³ | <esc> " 'Dec  Chr   | '
Î35|D                   " Remove all but the first 35 characters of each line
```
[Answer]
## F#, 222 bytes
```
let c,p=String.concat" | ",printfn"%s"
Seq.replicate 3"Dec  Chr  "|>c|>p
p(String.replicate 34"-")
for i=32 to 63 do[for j in[i;i+32;i+64]->sprintf"%-5d%-5s"j (match j with 32->"Space"|127->"DEL"|_->string(char j))]|>c|>p
```
[Try it online!](https://repl.it/@AndreSlupik/ProperDemandingOyster-1)
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 167 bytes
```
[[Space]nq]sp[[DEL]nq]sq[[ ]n]sc[Dec  Chr]dsen[   | ]dsfnlenlfnlen10P34[[-]n1-d0<a]dsax10P0[[32+dndZ2=c[  ]ndd32=pd127=qP[    ]n]dswx[ | ]nlwx[ | ]nlwx10P95-d32>b]dsbx
```
[Try it online!](https://tio.run/nexus/dc#TY2xCsJAEER/ZXsJJHeKCMbG2FkE7By2SG5PLMKSyxWm8N/jJpXN8JidmV2Ax9iFyJo4j0Bzu2@YAGLlHNDEQHR9Tyw5KojoS4YvHaIOm1Zl6/dAwVoVUp47u3azmSXg3U5Unq4OVmQV8a4epXLHOrXr1PpC8mfGOqrDH1j/dCgsf@kt0c/L8gM "dc – TIO Nexus")
How it works:
```
[[Space]nq]sp     # p is a macro that prints "Space" and then quits from the call one level up
[[DEL]nq]sq       # q is a macro that prints "DEL" and then quits from the call one level up
[[ ]n]sc          # c is a macro that prints a space
[Dec  Chr]dsen    # Save the string "Dec  Chr" in register e, and print it.
[   | ]dsfn       # Save the string "   | " in register f, and print it.
len               # Print "Dec  Chr" again.
lfn               # Print "   | " again.
len               # Print "Dec  Chr" again.
10P               # Print a newline.
34                # Push 34 on the stack.
[[-]n1-d0<a]dsa   # a is a macro that repeatedly prints "-" and decrements the top of the stack, while the top of the stack is positive.
x10P              # Execute macro a, followed by a newline. (This prints the line of hyphens.)
0                 # Push 0 on the stack.
[                 # Starting a large macro (which will be stored in register b) for printing the table row by row.
[32+dndZ2=c[  ]ndd32=pd127=qP[    ]n]dsw
                  # w is a macro which:
                        (1) adds 32 to the top of the stack;
                        (2) prints it as a number;
                        (3) uses Z to compute the number of characters the number required to print that number;
                        (4) if it required 2 characters to print the number, calls the macro c to print an extra space
                        (5) prints the string "Space" (for ASCII code 32) or the string "DEL" (for ASCII code 127) or the appropriate character, followed by the right number of spaces
x                 # Execute macro w to print an entry in column 1.
[ | ]n            # Print a column divider.
lwx               # Execute macro w to print an entry in column 2 (ASCII code 32 higher than the previous entry).
[ | ]n            # Print a column divider.
lwx               # Execute macro w to print an entry in column 3 (ASCII code 32 higher than the previous entry).
10P               # Print a newline.
95-               # Subtract 95 to adjust to go to the beginning of the next line.
d32>b             # If the top of stack is <= 32, execute macro b again, effectively looping to print all the rows of the table.
]dsb              # End the definition of the large macro, and store it in register b.
x                 # Execute the macro that's in b (with 0 at the top of the stack initially).
```
[Answer]
## Perl, 120 bytes
```
$,="| ";say+("Dec  Chr   ")x3;say"-"x32;say map{sprintf"%-5s%-6s",$_,$_-32?$_-127?chr:DEL:Space}$_,$_+32,$_+64for 32..63
```
Run with `-E` flag:
```
perl -E '$,="| ";say+("Dec  Chr   ")x3;say"-"x32;say map{sprintf"%-5s%-6s",$_,$_-32?$_-127?chr:DEL:Space}$_,$_+32,$_+64for 32..63'
```
*-2 bytes thanks to [@G B](https://codegolf.stackexchange.com/users/18535/g-b).*
[Answer]
# C, 179 bytes
```
i;f(){for(;i++<37;)printf(i<4?"Dec  Chr%s":"-",i<3?"   | ":"\n");printf("\n32   Space | ");for(i=64;i<127;i+=i>95?-63:32)printf("%-5d%-6c%s",i,i,i>95?"\n":"| ");puts("127  DEL");}
```
[Try it online!](http://ideone.com/aZ6PdJ)
Semi-ungolfed:
```
i;
f() {
  for(;i++<37;) printf(i<4?"Dec  Chr%s":"-",i<3?"   | ":"\n");
  printf("\n32   Space | ");
  for(i=64;i<127;i+=i>95?-63:32) printf("%-5d%-6c%s",i,i,i>95?"\n":"| ");
  puts("127  DEL");
}
```
[Answer]
## Ruby, 124 bytes
```
 puts [["Dec  Chr   "]*3*"| ",?-*34,(0..31).map{|d|(1..3).map{|x|"%-5s%-6s"%[y=x*32+d,y<33?"Space":y>126?"DEL":y.chr]}*"| "}]
```
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~151~~ ~~150~~ ~~148~~ ~~136~~ ~~135~~ ~~130~~ ~~129~~ 125 bytes
*12 bytes saved thanks to @nmjcman101 for using `<C-v>g<C-a>` for the numbers instead of `line('.')`*
*2 byte saved thanks to @DJMcMayhem for removing lines with leading spaces using `ÇÓ/d` and by using `dê` to remove extra spaces and rearranging stuff*
This answer is in competition with @nmjcman101's V [answer](https://codegolf.stackexchange.com/a/106286/41805) (which uses `:set ve=all`). ~~But now, I found a way to remove those `A ^[`s and saved some bytes and we are at an even bytecount~~ 
```
iSpace 
¬!~Ó./&ò
iDELí^/31   
HlgGo| 63ÙkGld/Sp
$p/`
G$d/@
$p/64
G$d/S
$pÇÓ/d
/d
hdê/32
O34é-O!| !| !Ó!/Dec  Chr   
```
[Try it online!](https://tio.run/nexus/v#@58ZXJCYnKrAJX1ojWLd4cl6@mqHN3Flurj6SB9eG6dvbKigoMAl5pGTzuieX6MgbWZ8eGa2mHtOin5wAZdKgX4Cl5i7Soq@A4htZgLhBAM5h9sPT9ZP4QKijJTDq/SNjbj8pY1NDq/U9VesUQAh6cOTFfVdUpMVFJwzioB2/P8PAA "V – TIO Nexus")
Hexdump:
```
00000000: 6953 7061 6365 200a 1bac 217e d32e 2f26  iSpace ...!~../&
00000010: f20a 6944 454c 1bed 5e2f 3331 2020 200a  ..iDEL..^/31   .
00000020: 1648 6c67 0147 6f7c 201b 3633 d96b 1647  .Hlg.Go| .63.k.G
00000030: 6c64 2f53 700a 2470 2f60 0a16 4724 642f  ld/Sp.$p/`..G$d/
00000040: 400a 2470 2f36 340a 1647 2464 2f53 0a24  @.$p/64..G$d/S.$
00000050: 70c7 d32f 640a 2f64 0a68 64ea 2f33 320a  p../d./d.hd./32.
00000060: 4f1b 3334 e92d 4f21 7c20 217c 2021 1bd3  O.34.-O!| !| !..
00000070: 212f 4465 6320 2043 6872 2020 20         !/Dec  Chr 
```
### Explanation (uncomplete and outdated)
The strategy here is that I'm using the line numbers to generate the ASCII code points.
Note: `^[` is `0x1b`, `^V` is `C-v`
First we generate all the characters.
```
iSpace             " insert Space
^[¬!~              " insert every character between ! and ~
```
The current buffer looks like
```
Space
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
```
Now we insert a newline between these characters
```
     Ó./&ò         " insert a newline before every character (:s/./&\r/g)
```
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~130~~ ~~120~~ 99 bytes
Sub 100 club. I'm no longer convinced that `:se ve=all` is the best way of doing this. It's an extra... 11 bytes just for writing the `|`'s! But that's what I have.
I'm posting this almost in competition with @KritixiLuthos answer using `:se ve=all` to avoid some `A <esc>`'s. I'm not convinced that either method is better yet, so hopefully this can inspire some golfing on both parties and see which method takes the cake.
I'm also half expecting @DJMcMayhem to kick both our pants
```
iSpace
¬!~Ó./&ò
iDELí^/31   
Hlg:se ve=all
12|êr|2ñ031j$x)PñHd)ÄÒ-Ä3RDec  Chr³ | /d
hdêÎ35|D
```
[Try it online!](https://tio.run/nexus/v#AXMAjP//aVNwYWNlChvCrCF@w5MuLybDsgppREVMG8OtXi8zMSAgIAoWSGxnATpzZSB2ZT1hbGwKMTJ8FsOqcnwyw7EwFjMxaiR4KVDDsUhkKcOEw5Itw4QzUkRlYyAgQ2hywrMgfCAbL2QKaGTDqsOOMzV8RP// "V – TIO Nexus")
Hexdump for the curious (if there's interest I'll just change this to a vim-style hidden character block)
```
00000000: 6953 7061 6365 0a1b ac21 7ed3 2e2f 26f2  iSpace...!~../&.
00000010: 0a69 4445 4c1b ed5e 2f33 3120 2020 0a16  .iDEL..^/31   ..
00000020: 486c 6701 3a73 6520 7665 3d61 6c6c 0a31  Hlg.:se ve=all.1
00000030: 327c 16ea 727c 32f1 3016 3331 6a24 7829  2|..r|2.0.31j$x)
00000040: 50f1 4864 29c4 d22d c433 5244 6563 2020  P.Hd)..-.3RDec  
00000050: 4368 72b3 207c 201b 2f64 0a68 64ea ce33  Chr. | ./d.hd..3
00000060: 357c 44                                  5|D
```
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 200 bytes
```
BEGIN{b="-----------";a="Dec  Chr   ";print a"|",a"|",a"\n-"b b b;for(a=31;a++<63;){printf"%-5d%-6s| %-5d%-6c| %-5d%-5s\n",a,a<33?"Space":sprintf("%c",a),a+32,a+32,a+64,a<63?sprintf("%c",a+64):"DEL"}}
```
Formatted:
```
BEGIN {
  b="-----------"
  a="Dec  Chr   "
  print a"|",a"|",a"\n-"b b b
  for(a=31;a++<63;) {
    printf "%-5d%-6s| %-5d%-6c| %-5d%-5s\n",
      a,    a<33 ? "Space" : sprintf("%c", a),
      a+32, a+32,
      a+64, a<63 ? sprintf("%c", a+64) : "DEL"
  }
}
```
[Try it online!](https://tio.run/##VYxBC4JAEIX/yjAgKO4eanMPriKUEkF06epl3JQiMHGDDupv35ZSonnweMx8b@h1t3Zb7A@noUqR/wYVpZjXGmB37QEAVdff2icQjshmK1uOFTip5tH7lIqVojBMpFDB8KEb9Hh08bg0I8xJLykyZeueMEqEyPDcka4xNt@aj552t4BRKNaLyY1jpcj@GbcOYsyLI06TtW8 "AWK – Try It Online")
[Answer]
## C 188 Bytes
```
f(){i=31;printf("Dec Chr | Dec Chr | Dec Chr");printf("\n--------------------------");for(;i<63;i++)printf("\n%d%4c  | %d%4c  | %d%4c",(i+1),(i+1),(i+33),(i+33),(i+65),(i+65));puts("DEL");
```
Normally looks like this:
```
f()
{
    int  i=31;
    printf("Dec Chr | Dec Chr | Dec Chr");
    printf("\n--------------------------"); 
    for(;i<63;i++)  
      printf("\n%d%4c  | %d%4c  | %d%4c", (i+1),(i+1),(i+33),(i+33),  (i+65),(i+65));
    puts("DEL");
}
```
[Answer]
## C (249 bytes)
Newlines added for clarity.
```
#define L(s,e)for(i=s;i<e;++i)
#define P printf
main(i){L(0,3)P("Dec  Chr  %s",i<2?" | ":"\n");
L(0,34)P("-");P("\n");L(32,64){P("%-5d", i);
i==32?P("Space"):P("%-5c",i);
P(" | %-5d%-5c | %-5d ",i+32,i+32,i+64);
i==63?P("DEL"):P("%-5c",i+64);P("\n");}}
```
[Answer]
# Java, 434 422 321 bytes
```
class A{public static void main(String[]a){
    int k=1,r,s=32;
    for(;k<4;k++)
        o("Dec   Chr  ",k);
    for(;k<37;k++)                                                                              
        o("-",k==36?3:4);
    for(k=r=s;!(k==64&&r==-63);r=k>95?-63:s,k+=r)
        o(k+"   "+((k>99)?"":" ")+(k==s?"Space":k==127?"DEL  ":((char)k+"    ")),k/s);
    }
    static void o(String s,int j){
        System.out.print(s+(j==4?"":j==3?"\n":"|"));
    }
}
```
Java is probably not the best language for this as there is the overhead of classes and main method...
You can eliminate main method using a static declaration, reducing the byte count down further:
```
class A{
    static{...}
```
but this results in an error (after otherwise successfully running):
```
Exception in thread "main" java.lang.NoSuchMethodException: A.main([Ljava.lang.String;)
    at java.lang.Class.getMethod(Class.java:1786)
    ...
```
The byte count does int include newlines or indentation.
[Answer]
# [Tcl](http://tcl.tk/), 233 bytes
```
lassign {"Dec  Chr" "   | " 31} h S i
set H $h$S$h$S$h\n[string repe - 34]
proc p x {format %-5d%c $x $x}
time {set H "$H
[p [incr i]]  $S[p [expr $i+32]]  $S[p [expr $i+64]]"} 32
puts [regsub {\ {8}} [regsub \177 $H DEL] "   Space"]
```
[Try it online!](https://tio.run/##ZY@9CsIwAIT3PMUR4iQObf3brdDBLWObocbYBrQNSQqFmGePf@Ai3B18Nxycl7eUbq1zuhsQaKkkcOgtBQXweGWRRfTg0MQpjwqsZ/zrZqidt3roYJVRWKFYC2LsKGEwI1xHe289FqvNZSHB5pci8fquEL5LlFWkNqj1IC20EADjb1azsWB6WeT/3XYtBI0ocmIm71Bb1bnpjNAg7GP8cZPtdmAVyuNJfJ5w00pFRUpP "Tcl – Try It Online")
[Answer]
# PHP, ~~163 149~~ 147 bytes
```
<?=($p=str_pad)(D,31,"ec Chr   | D"),$p("
",32,"-");whhile($i<96)printf("%s%-4d%-6s",$i%3?"| ":"
",$o=$i%3*32+32+$i/3,$i++?$i<96?chr($o):DEL:Space);
```
**breakdown**
```
                        # print header
<?=($p=str_pad)(D,31,"ec Chr   | D"),$p("\n",32,"-");
while($i<96)            # loop $i from 0 to 96
    printf("%s%-4d%-6s",    # print formatted:
                            # string, 4 space decimal leftbound, 6 space string leftbound
        $i%3?"| ":"\n",                 # linebreak for 1st column, pipe+space else
        $o=$i%3*32+32+$i/3,             # ($i mapped to) ASCII value
        $i++?$i<96?chr($o):DEL:Space    # character
    );
```
Using `%-N` is worth the byte that rightbound numbers and character would save.
[Answer]
# [R](https://www.r-project.org/), ~~235 228 221~~ 212 bytes
```
y=apply(rbind(rep("Dec  Chr  ",3),1,matrix(sapply(1:96,function(i)paste(i+31,rep(" ",i<69),"if"(i<2,"Space","if"(i>95,"DEL",intToUtf8(c(i+31,rep(32,4))))))),nrow=32)),1,paste,collapse=" | ")
y[2]=strrep("-",34)
y
```
[Try it online!](https://tio.run/##RY4xT8MwFIT3/grrsTyLx5CkVKSqWShbh0rABAzGOKql4FjPr4JI/e@pSZG48XTf3fE0jcam1I/IHyF@IvuEsPVOqYcDKwXUaKroywqHH8yXZLVuV9Qdo5MwRAw62Swew3VT0YwXKmxWrSYIHWDY1ARPyToPf8Z9e0uwfdyVWJTn4UW6O3T/fFPTUl9EkYdv09T698Q8Q27oe5uyN6BOCvRifK3fTRael2/K32Xxpqs9l24lB6/Y52Mv64WzgiNlnwy8RdDTGQ "R – Try It Online")
I tried really hard to get under 200 bytes but these `paste` and `collapse` are killing me.
Returns a list of lines.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 53 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
éV ►Γ┐º╬¼1N_◄╒0└♀α→┴♂┐Y♣╟n»┤3°k⌡{═╥I⌂╜<─W}íè7Y♠Σ▲ÿb#√
```
[Run and debug it](https://staxlang.xyz/#p=82562010e2bfa7ceac314e5f11d530c00ce01ac10bbf5905c76eafb433f86bf57bcdd2497fbd3cc4577da18a375906e41e986223fb&i=&a=1)
[Answer]
# JavaScript (ES6), 258 bytes
```
a="Dec  Chr   | ".repeat(2)+"Dec  Chr\n"+"-".repeat(34);for(b=32;64>b;b++)a+="\n"+b+"   "+(32==b?"Space  ":String.fromCharCode(b)+"      ")+"| "+(b+32)+"   "+String.fromCharCode(b+32)+"     | "+(b+64)+(35<b?"  ":"   ")+(63==b?"DEL":String.fromCharCode(b+64))
console.log(a)
```
[Answer]
# [PowerShell](https://github.com/PowerShell/PowerShell), 159 bytes
```
,'Dec  Chr'*3-join'   | '
'-'*34
32..63|%{($_,($_+32),($_+64)|%{"$_".PadRight(5)+"$(([char]$_,('Space','DEL')[$_-ne32])[$_-in32,127])".padRight(5)})-join' | '}
```
[Try it online!](https://tio.run/nexus/powershell#@6@j7pKarKDgnFGkrmWsm5WfmaeuoKBQo6DOpa4LFDHhMjbS0zMzrlGt1lCJ1wFibWMjTTBtZqIJFFVSiVfSC0hMCcpMzyjRMNXUVlLR0IhOzkgsigWpVw8uSExOVQfa4uqjrhmtEq@bl2psFAtmZeYZG@kYGpnHairpFSBMqNWEOgPoiNr//wE "PowerShell – TIO Nexus")
The first two lines are just creating literal strings and leaving them on the pipeline. The first uses the comma operator `,` to create an array, and then `-join`s that array together to create the headers. The second is just a straight string multiplication.
The third line loops over `32..63` and each iteration sends three values `$_`, `($_+32)`, and `($_+64)` into an inner loop. The inner loop does a `PadRight` on the value (adds the appropriate spaces to pad to `5` characters). That is then string concatenated `+` with the result of a nested pseudo-ternary `( )[ ]`. The pseudo-ternary selects either the `char` representation of that number, or else `Space` or `DEL` if it's the appropriate value. Again, we `PadRight` the appropriate characters.
Those three strings (for example, `32 Space`, `64 @`, `96 ``) are encapsulated in parens and `-join`ed with the column markers into a single string. Each of those 32 strings are then left on the pipeline. At the end of execution, an implicit `Write-Output` inserts a newline between elements on the pipeline, so we get that for free. 
[Answer]
# Perl, ~~165~~ 155 bytes
```
$s='Dec  Chr   ';$_=join"\n",("$s| $s| $s","-"x34,map{join"| ",map{sprintf'%1$-5d%1$-6c',$_}($_,$_+32,$_+64)}32..63);s/ {8}/   Space/;s/\x7f.*/DEL\n/;print
```
[Answer]
# Python 2, ~~1564~~ 218 bytes
My first golf, sorry for obvious mistakes
```
print("Dec  Chr   | "*3)[:-2]+"\n"+"-"*34+"\n32   Space | 64   @     | 96   `"
for n in range(33,63):print"| ".join([str(n+x).ljust(5)+chr(n+x).ljust(6)for x in [0,32,64]])
print"63   ?     | 95   _     | 127  DEL"
```
[Try it online!](https://tio.run/nexus/python2#VY0xD4IwEIV3fsXlptYC0RZqZNFE3NwckSghKBBTSMGEwf@OB@rg9O69u/ve2NrK9AzjIgfYlxYAXoALxZPIk6nAs0GBHgXBNCtJ@1Ob5QVd6YDMDmB@2WiSKzq3xoKByoDNzL1gSrla8WguQQL7dVMZlnS9ZUYM3H/Uz65nIRd5@ZdoDhNpmEjJ0lXS1UGacucD0orKtr/mkOTyNSu5BogPRxzHNw "Python 2 – TIO Nexus")
Incase you're wondering, the first version was a base64 encoded string.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~82~~ 76 bytes
```
žQSDÇƵQ¸«.Bsð”‡²”:"DEL"¸«.B)øvyð2×ý})3äøvy… | ©ý}®”†…  Chr  ÿ”3×¨¨'-34×.Á.Á»
```
[Try it online!](https://tio.run/##MzBNTDJM/f//6L7AYJfD7ce2Bh7acWi1nlPx4Q2PGuY@alh4aBOQtlJycfVRgshoHt5RVnl4g9Hh6Yf31moaH14C4j9qWKZQo3BoJVDo0DqwxgUgIQXnjCIFhcP7gSLGh6cfWnFohbquscnh6XqHG4Ho0O7//wE "05AB1E – Try It Online")
Still golfing, this can be improved a lot.
---
`žQSDÇƵQ¸«.Bsð”‡²”:"DEL"¸«.B)ø` pushes padded numbers with text equivalent:
```
[['32 ', 'Space'], ['33 ', '!    '], ['34 ', '"    '], ['35 ', '#    '], ['36 ', '$    '], ['37 ', '%    '], ['38 ', '&    '], ['39 ', "'    "], ['40 ', '(    '], ['41 ', ')    '], ['42 ', '*    '], ['43 ', '+    '], ['44 ', ',    '], ['45 ', '-    '], ['46 ', '.    '], ['47 ', '/    '], ['48 ', '0    '], ['49 ', '1    '], ['50 ', '2    '], ['51 ', '3    '], ['52 ', '4    '], ['53 ', '5    '], ['54 ', '6    '], ['55 ', '7    '], ['56 ', '8    '], ['57 ', '9    '], ['58 ', ':    '], ['59 ', ';    '], ['60 ', '<    '], ['61 ', '=    '], ['62 ', '>    '], ['63 ', '?    '], ['64 ', '@    '], ['65 ', 'A    '], ['66 ', 'B    '], ['67 ', 'C    '], ['68 ', 'D    '], ['69 ', 'E    '], ['70 ', 'F    '], ['71 ', 'G    '], ['72 ', 'H    '], ['73 ', 'I    '], ['74 ', 'J    '], ['75 ', 'K    '], ['76 ', 'L    '], ['77 ', 'M    '], ['78 ', 'N    '], ['79 ', 'O    '], ['80 ', 'P    '], ['81 ', 'Q    '], ['82 ', 'R    '], ['83 ', 'S    '], ['84 ', 'T    '], ['85 ', 'U    '], ['86 ', 'V    '], ['87 ', 'W    '], ['88 ', 'X    '], ['89 ', 'Y    '], ['90 ', 'Z    '], ['91 ', '[    '], ['92 ', '\\    '], ['93 ', ']    '], ['94 ', '^    '], ['95 ', '_    '], ['96 ', '`    '], ['97 ', 'a    '], ['98 ', 'b    '], ['99 ', 'c    '], ['100', 'd    '], ['101', 'e    '], ['102', 'f    '], ['103', 'g    '], ['104', 'h    '], ['105', 'i    '], ['106', 'j    '], ['107', 'k    '], ['108', 'l    '], ['109', 'm    '], ['110', 'n    '], ['111', 'o    '], ['112', 'p    '], ['113', 'q    '], ['114', 'r    '], ['115', 's    '], ['116', 't    '], ['117', 'u    '], ['118', 'v    '], ['119', 'w    '], ['120', 'x    '], ['121', 'y    '], ['122', 'z    '], ['123', '{    '], ['124', '|    '], ['125', '}    '], ['126', '~    '], ['127', 'DEL  ']]
```
---
`vyð2×ý})3äøvy… | ©ý}` joins 'em together into the table:
```
['32   Space | 64   @     | 96   `    ', '33   !     | 65   A     | 97   a    ', '34   "     | 66   B     | 98   b    ', '35   #     | 67   C     | 99   c    ', '36   $     | 68   D     | 100  d    ', '37   %     | 69   E     | 101  e    ', '38   &     | 70   F     | 102  f    ', "39   '     | 71   G     | 103  g    ", '40   (     | 72   H     | 104  h    ', '41   )     | 73   I     | 105  i    ', '42   *     | 74   J     | 106  j    ', '43   +     | 75   K     | 107  k    ', '44   ,     | 76   L     | 108  l    ', '45   -     | 77   M     | 109  m    ', '46   .     | 78   N     | 110  n    ', '47   /     | 79   O     | 111  o    ', '48   0     | 80   P     | 112  p    ', '49   1     | 81   Q     | 113  q    ', '50   2     | 82   R     | 114  r    ', '51   3     | 83   S     | 115  s    ', '52   4     | 84   T     | 116  t    ', '53   5     | 85   U     | 117  u    ', '54   6     | 86   V     | 118  v    ', '55   7     | 87   W     | 119  w    ', '56   8     | 88   X     | 120  x    ', '57   9     | 89   Y     | 121  y    ', '58   :     | 90   Z     | 122  z    ', '59   ;     | 91   [     | 123  {    ', '60   <     | 92   \\     | 124  |    ', '61   =     | 93   ]     | 125  }    ', '62   >     | 94   ^     | 126  ~    ', '63   ?     | 95   _     | 127  DEL  ']
```
---
`®”†… Chr ÿ”3×¨¨'-34×.Á.Á»` takes care of the header portion of the table:
```
Dec  Chr   | Dec  Chr   | Dec  Chr   
----------------------------------
32   Space | 64   @     | 96   `    
33   !     | 65   A     | 97   a    
34   "     | 66   B     | 98   b    
35   #     | 67   C     | 99   c    
36   $     | 68   D     | 100  d    
37   %     | 69   E     | 101  e    
38   &     | 70   F     | 102  f    
39   '     | 71   G     | 103  g    
40   (     | 72   H     | 104  h    
41   )     | 73   I     | 105  i    
42   *     | 74   J     | 106  j    
43   +     | 75   K     | 107  k    
44   ,     | 76   L     | 108  l    
45   -     | 77   M     | 109  m    
46   .     | 78   N     | 110  n    
47   /     | 79   O     | 111  o    
48   0     | 80   P     | 112  p    
49   1     | 81   Q     | 113  q    
50   2     | 82   R     | 114  r    
51   3     | 83   S     | 115  s    
52   4     | 84   T     | 116  t    
53   5     | 85   U     | 117  u    
54   6     | 86   V     | 118  v    
55   7     | 87   W     | 119  w    
56   8     | 88   X     | 120  x    
57   9     | 89   Y     | 121  y    
58   :     | 90   Z     | 122  z    
59   ;     | 91   [     | 123  {    
60   <     | 92   \     | 124  |    
61   =     | 93   ]     | 125  }    
62   >     | 94   ^     | 126  ~    
63   ?     | 95   _     | 127  DEL  
```
[Answer]
# T-SQL, 242 bytes
```
DECLARE @ INT=32PRINT'Dec  Chr   | Dec  Chr   | Dec  Chr
'+REPLICATE('-',34)L:PRINT CONCAT(@,'   ',IIF(@=32,'Space | ',CHAR(@)+'     | '),@+32,'   ',CHAR(@+32),'     | ',@+64,SPACE(5-LEN(@+64)),IIF(@=63,'DEL',CHAR(@+64)))SET @+=1IF @<64GOTO L
```
Formatted:
```
DECLARE @ INT=32
PRINT'Dec  Chr   | Dec  Chr   | Dec  Chr
' + REPLICATE('-',34)
L:
    PRINT CONCAT(@,'   ',IIF(@=32,'Space | ',CHAR(@)+'     | ')
                ,@+32,'   ',CHAR(@+32),'     | ',
                 @+64,SPACE(5-LEN(@+64)),IIF(@=63,'DEL',CHAR(@+64)))
    SET @+=1
IF @<64 GOTO L
```
Tried a few variations, including replacing various common strings with other variables, but this was the shortest version I found.
[Answer]
# [Python 3](https://docs.python.org/3/), 154 bytes
```
for l in[['Dec  Chr  ']*3,['-'*35]]+[[f"{x:<5}{['Space',chr(x),'DEL'][(x>32)+(x>126)]:5}"for x in(c,c+32,c+64)]for c in range(32,64)]:print(' | '.join(l))
```
[Try it online!](https://tio.run/##FcwxC4MwFATgv/JweYmmhSbVQUqX2q1bx0cGCVoViRIcUqy/PU2WO/jgbv1uw2JVCP3iYIbREmHTGYDH4ABQ50oQnjBXpdYFUZ/tvr6Vx074XlvToTCDY54LbJ4v1MT8XUlexLrIiuu6PLJ07OMxM8IUSsaorlwnNVHBtfbTsehJ69WNdmMIP8DztMTRzHkIfw "Python 3 – Try It Online")
[Answer]
# [Attache](https://github.com/ConorOBrien-Foxx/Attache), 144 bytes
```
(p:=PadRight)["",37,"Dec  Chr   | "]'(34*"-")'(Join&"| "=>Tr@ChopInto&3<|{p&11<|p&5@Repr@_+(<~32->$Space,127->$DEL~>@_or Char!_)}=>32:127)|Print
```
[Try it online!](https://tio.run/##DYzBCoMgAEB/xckw3epQbgRRItQOGztE7TZGSJPZJUW8zfXrztvjPXjCOTErGQI2VdOL97B8lCNPCFNaprCTMwCtsgAAD@ArwfR0gBkkCb7pZUUwyoY9LG@VNtfVaURr/zUoz2tv0JkP0lg@HXG90SJj@9GIWaZ5UUbuLveN8UnbuBd2N5Ffw2hRxUh8b5fVhfAH "Attache – Try It Online")
]