[Question]
  [
This is the logo for [LAPACK, a widely used software library for numerical linear algebra](http://www.netlib.org/lapack/).
[![enter image description here](https://i.stack.imgur.com/zpKoi.png)](https://i.stack.imgur.com/zpKoi.png)
Your task is to print the logo (color and matrix brackets not required) as this exact string. Trailing newline is allowed.
```
L  A  P  A  C  K
L -A  P -A  C -K
L  A  P  A -C -K
L -A  P -A -C  K
L  A -P -A  C  K
L -A -P  A  C -K
```
  
[Answer]
# [Python 2](https://docs.python.org/2/), 69 bytes
```
print"L %sA %sP %sA %sC %sK\n"*6%tuple('     - - -   --- -'+'-  -'*3)
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM69EyUdBtdgRiAOgtDMQe8fkKWmZqZaUFuSkaqgrgIAuGAJpXSCtrq0OZOuqaxlr/v8PAA "Python 2 – Try It Online")
Kind-of a boring solution. Makes a string template for the output with slots to put in minuses, then inserts in hardcoded string of minuses and spaces for those slots. I didn't find a way to compress or generate this length-30 binary sequence shorter than hardcoding it. The only optimization the code uses is that the sequence ends in 3 copies of `'- -'`. The output includes a trailing newline which the challenge allows.
The template could also use `%2s` in place of  `%s` which would allow also putting in empty string for the spaces, but I don't see how to use this.
[Answer]
# Python 2, 91 bytes
```
i=0
for c in'LAPACK'*6:print' -'[chr(i+33)in'(*,12467;<@AD']*(c!='L')+c+'\n'*(c=='K'),;i+=1
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9PWgCstv0ghWSEzT93HMcDR2Vtdy8yqoCgzr0RdQVc9OjmjSCNT29hYEyivoaVjaGRiZm5t4@Dooh6rpZGsaKvuo66pnaytHpOnDuTb2qp7q2vqWGdq2xr@/w8A "Python 2 – Try It Online")
I know most previous answers already beat this, but it's my first golf and I quite enjoyed the result :-)!
Edit: Thanks very much to [@xnor](https://codegolf.stackexchange.com/users/20260/xnor) for ~~the tip with `'\n'*(c=='K')`~~ all the tips!
[Answer]
# x86-16 machine code, IBM PC DOS, ~~54~~ ~~48~~ 49 bytes
**Binary:**
```
00000000: b106 be25 01ad cd29 84e4 740e b020 cd29  ...%...)..t.. .)
00000010: d2ec 7302 b02d cd29 ebeb b00d cd29 b00a  ..s..-.).....)..
00000020: cd29 e2de c34c 1541 0350 1641 0c43 194b  .)...L.A.P.A.C.K
00000030: 00                                       .
```
Build and test using `xxd -r` on your favorite DOS VM.
**Listing:**
```
B1 06       MOV  CL, 6              ; loop 6 rows
        ROWLOOP: 
BE 0121     MOV  SI, OFFSET LS      ; letter string into SI
        COLLOOP:
AD          LODSW                   ; letter into AL, dash pattern into AH
CD 29       INT  29H                ; write to screen
84 E4       TEST AH, AH             ; is AH = 0?
74 0E       JZ   END_NL             ; if so break loop, write NL
B0 20       MOV  AL, ' '            ; space char into AL
CD 29       INT  29H                ; write to screen
D2 EC       SHR  AH, CL             ; shift dash bit into CF
73 02       JNC  NO_DASH            ; is a dash?
B0 2D       MOV  AL, '-'            ; dash char in AL
        NO_DASH:
CD 29       INT  29H                ; write to screen
EB EB       JMP  COLLOOP            ; loop until end of string
        END_NL:
B0 0D       MOV  AL, 0DH            ; CR char
CD 29       INT  29H                ; write to screen
B0 0A       MOV  AL, 0AH            ; LF char
CD 29       INT  29H                ; write to screen
E2 DE       LOOP ROWLOOP            ; loop until end of rows
C3          RET                     ; return to DOS
        LS  DB  'L',15H,'A',3H,'P',16H,'A',0CH,'C',19H,'K',0
```
**How?**
The "letter string" data contains two bytes for each letter - the high byte is the letter and the low byte is a bitmap describing if that letter should be followed by a dash for each row. The rows are indexed 6 to 1 starting from the top, where the bit in the corresponding order represents whether or not there's a dash.
*Examples:*
Row 5, Col 0: Data `'L'`, `0x15` (0**1**0101)
The fifth bit is a `1` indicating that for the fifth row after the `L` there is a dash after.
Row 2, Col 3: Data `'A'`, `0xC` (0011**0**0)
The second bit is a `0` indicating that for the fifth row after the `A` there is not a dash after.
Or looking at it a different way, the odd bytes `[ 0x15, 0x3, 0x16, 0xC, 0x19, 0x0 ]` form the bitmap of the dashes (only rotated and flipped):
```
0x15    010101
0x3     000011
0x16    010110
0xC     001100
0x19    011001
0x0     000000
```
**Runtime:**
A standalone IBM PC DOS COM executable. Output to console.
[![enter image description here](https://i.stack.imgur.com/rR0mY.png)](https://i.stack.imgur.com/rR0mY.png)
[Answer]
# JavaScript (ES6), ~~74 72~~ 71 bytes
```
_=>`L A P A C K
`.repeat(i=6).replace(/ /g,c=>c+' -'[863064083>>++i&1])
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/e1i7BR8FRIQCInRW8uRL0ilILUhNLNDJtzTRB7JzE5FQNfQX9dJ1kW7tkbXUFXfVoCzNjAzMTAwtjOztt7Uw1w1jN/8n5ecX5Oal6OfnpGmkampr/AQ "JavaScript (Node.js) – Try It Online")
### How?
We build a string consisting of the pattern `"L A P A C K\n"` repeated 6 times and match all spaces. We replace each of them with either `" "` or `" -"` depending on the result of a test on a bit mask.
In binary, the constant **863064083** is:
```
  bit 31                  bit 7  bit 0
    v                       v      v
    00110011011100010101000000010011
    \___/\___/\___/\___/\___/  \___/
row:  4    3    2    1    0      5
```
Because we start with `i=6` and pre-increment `i` at each iteration, the first row is encoded by the bits 7 to 11 (0-indexed).
As stated in the [ECMAScript specification](https://www.ecma-international.org/ecma-262/9.0/index.html#sec-signed-right-shift-operator), bitwise shifts are processed modulo 32. So there's a wrap-around when `i` exceeds 31 and the last row can safely be encoded by the bits 0 to 4.
---
### Alternate version
For **69 bytes**, we could do:
```
_=>`LAPACK
`.repeat(i=6).replace(/\B/g,c=>' '+' -'[863064083>>++i&1])
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/e1i7BxzHA0dmbK0GvKLUgNbFEI9PWTBPEzklMTtXQj3HST9dJtrVTV1DXVlfQVY@2MDM2MDMxsDC2s9PWzlQzjNX8n5yfV5yfk6qXk5@ukaahqfkfAA "JavaScript (Node.js) – Try It Online")
But the corresponding output includes 2 trailing spaces on the last row1. Because the challenge looks very strict about leading and trailing whitespace, this is probably invalid. ¯\\_(ツ)\_/¯
*1: Now, would you have noticed them if I didn't tell ya?! :-p*
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~29~~ 27 bytes
```
Ｅ?*<)3&✂⭆⍘℅ι- ⁺ ⁺λ§LAPACKμ²
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM3sUBDyV7LRtNYTUlHITgnMzlVI7gEKJUOknFKLE6F8DT8i1Iy8xJzNDI1dRSUdBWUgFRATmmxhpKCEpSVo6PgWOKZl5JaoaHk4xjg6OwNlMnVBAIdBSMgaf3//3/dshwA "Charcoal – Try It Online") Link is to verbose version of code. Edit: Saved 2 bytes by appropriating @KevinCruijssen's custom base conversion idea. Explanation:
```
 ?*<)3&                     Literal string of code points
Ｅ                           Map over characters
           ι                Current character
          ℅                 Take the ordinal
         ⍘  -               Convert to custom base `- `
        ⭆                   Map over characters and join
                 λ          Current character
                ⁺           Concatenated with
                   LAPACK   Literal string `LAPACK`
                  §         Indexed by
                         μ  Inner index
              ⁺             Prefixed with a space
       ✂                   ² Slice off the leading spaces
```
[Answer]
# APL+WIN, 58 bytes
```
n←96⍴¯2↓∊'LAPACK',¨⊂'  '⋄n[⎕av⍳'ì↑⍋+.28;EHRU^']←'-'⋄6 16⍴n
```
Explanation:
```
'LAPACK',¨⊂'  ' concatenate 2 spaces to each letter in LAPACK
96⍴¯2↓∊ convert to a vector, drop last 2 spaces and replicate to form a 96 element vector
⎕av⍳'ì↑⍋+.28;EHRU^' convert characters to ascii code point integers
n[.....]←'-' use integers as index positions to assign - character
6 16⍴n reshape vector as a 6 16 matrix
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 63 bytes
```
puts"L%sA%sP%sA%sC%sK
"*6%(0..29).map{|i|'  -'[644276896[i],2]}
```
[Try it online!](https://tio.run/##KypNqvz/v6C0pFjJR7XYUbU4AEw6qxZ7cylpmalqGOjpGVlq6uUmFlTXZNaoKyjoqkebmZgYmZtZWJpFZ8bqGMXW/v8PAA "Ruby – Try It Online")
Builds the output string by successive substitution from an array of prefixes. For each letter other than `L`, the appropriate two-character prefix (either  or  `-`) is selected by using the binary digits of `644276896` (`100110011001101110001010100000` in binary) to index into the three-character string  `-`.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 31 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
•x—o—Õ•₃вε„ -Åв’la•Î’u.ι2ôJðý¦,
```
[Try it online.](https://tio.run/##yy9OTMpM/f//UcOiikcNU/KB@PBUIOdRU/OFTee2PmqYp6B7uPXCpkcNM3MSgeKH@4CsUr1zO40Ob/E6vOHw3kPLdP7//6@rm5evm5NYVQkA)
**Explanation:**
```
•x—o—Õ•     # Push compressed integer 251957282837
       ₃в   # Convert it to base-95 as list: [32,53,35,54,44,57]
ε           # Foreach over the integers:
 „ -Åв      #  Convert it to custom base-" -",
            #  which basically means to convert it to base-2 and index it into " -"
 ’la•Î’     #  Push dictionary string "lapack"
       u    #  Uppercase it: "LAPACK"
 .ι         #  Interleave the characters in the two strings
   2ô       #  Split it into pairs of characters
     J      #  Join each pair together
      ðý    #  Join the list by spaces
        ¦   #  Remove the first character in front of the "L"
         ,  #  And output it with trailing newline
```
[See this 05AB1E tip of mine (sections *How to use the dictionary?*, *How to compress large integers?*, and *How to compress integer lists?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `’la•Î’` is `"lapack"`; `•x—o—Õ•` is `251957282837`; and `•x—o—Õ•₃в` is `[32,53,35,54,44,57]`.
(`[32,53,35,54,44,57]` is `[100000,110101,100011,110110,101100,111001]` in binary.)
[Answer]
# [Perl 5](https://www.perl.org/), 57 bytes
```
$"=" { ,-}";say+(<"@{[L,A,P,A,C,K]}\n">)[0,21,3,22,12,25]
```
[Try it online!](https://tio.run/##K0gtyjH9/19FyVZJoVpBR7dWybo4sVJbw0bJoTraR8dRJwCInXW8Y2tj8pTsNKMNdIwMdYx1jIx0DI10jExj////l19QkpmfV/xf19dUz9BAzwAA "Perl 5 – Try It Online")
## Explanation
First `$"` (which is a magic variable that is used as a field separator when lists are interpolated into strings - default is `" "`) is set to  `{ ,-}`. Then `say` is called which is a newline-terminated `print` function, passing in the listed indexes (0, 21, 3, 22, 12, 25) from the result of the `glob` (`<...>` is shorthand for calling `glob`) `<"@{[L,A,P,A,C,K]}\n">`. This glob expands to:
```
L { ,-}A { ,-}P { ,-}A { ,-}C { ,-}K
```
Which, due to the `{ ,-}`s, will generate a list containing all permutations of the string with either  or `-` before every letter (except the leading `L`). The chosen indices are the ones we need for the logo.
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 62 bytes
This is way too long.
~~The markdown parser breaks terribly if I use the TIO's post snippet generator, so there's an extra leading newline in the snippet below: there is actually only 1 leading newline!~~
```
bbcccbc-cc-b--b-- c
b
   
c
 -
L`.{6}
.
$0X 
Y`X`\LAPACK
.L
L
```
The first 2 lines replace the empty string with `bbccc... c`, the next 4 lines decode it into spaces and dashes by simple substitutions (`b` -> 3 spaces, `c` ->  `-`), the next line splits it into 6 lines of length 6 (producing a 6x6 sign matrix), the next two lines replace each character `c` by `cX` , the next line cyclically transliterates all `X`s into `LAPACK`s, and the last 2 lines remove leading whitespace.
[Try it online!](https://tio.run/##K0otycxLNPz/nyspKTk5OSlZNzlZN0kXhBSSuZK4FBQUuJK5FHS5fBL0qs1qufS4VAwiFLgiEyISYnwcAxydvbn0fLh8/v8HAA "Retina – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~92~~ ~~91~~ ~~84~~ 83 bytes
Saved 7 bytes thanks to the man himself [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)!!!
Saved a byte thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!!
```
f(i){for(i=30;i--;i%5||puts("K"))printf("%c %c","CAPAL"[i%5]," -"[22141337>>i&1]);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NI1OzOi2/SCPT1tjAOlNX1zpT1bSmpqC0pFhDyVtJU7OgKDOvJE1DSTVZQTVZSUfJ2THA0UcpGqgqVkdJQVcp2sjI0MTQ2Njczi5TzTBW07r2f25iZp4G0FQNEOdfclpOYnrxf91yAA "C (gcc) – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 107 bytes
```
s='LAPACK';e=enumerate
for i,_ in e(s):print(*[' -'[(j%2+i%2==2)^(i//2+j//2==3)]*(j!=0)+k for j,k in e(s)])
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v9hW3ccxwNHZW9061TY1rzQ3tSixJJUrLb9IIVMnXiEzTyFVo1jTqqAoM69EQytaXUFXPVojS9VIO1PVyNbWSDNOI1Nf30g7C0jY2hprxmppZCnaGmhqZyuAjMjSyYYZEav5/z8A "Python 3 – Try It Online")
How it works: blue squares are in the form
\$\begin{pmatrix}1&1\\1&-1\end{pmatrix}\$ hence `j%2+i%2==2` and red squares (when `i//2+j//2==3`) are in the opposite form
\$\begin{pmatrix}-1&-1\\-1&1\end{pmatrix}\$ thus we simply xor the expressions with `^`.
\$\$
\begin{array}{rr|rr|rr}
\color{blue}{\mathrm{L}}&
\color{blue}{\mathrm{A}}&
\color{blue}{\mathrm{P}}&
\color{blue}{\mathrm{A}}&
\color{blue}{\mathrm{C}}&
\color{blue}{\mathrm{K}}\\
\color{blue}{\mathrm{L}}&
\color{blue}{\mathrm{-A}}&
\color{blue}{\mathrm{P}}&
\color{blue}{\mathrm{-A}}&
\color{blue}{\mathrm{C}}&
\color{blue}{\mathrm{-K}}\\
\hline
\color{blue}{\mathrm{L}}&
\color{blue}{\mathrm{A}}&
\color{blue}{\mathrm{P}}&
\color{blue}{\mathrm{A}}&
\color{red}{\mathrm{-C}}&
\color{red}{\mathrm{-K}}\\
\color{blue}{\mathrm{L}}&
\color{blue}{\mathrm{-A}}&
\color{blue}{\mathrm{P}}&
\color{blue}{\mathrm{-A}}&
\color{red}{\mathrm{-C}}&
\color{red}{\mathrm{K}}\\
\hline
\color{blue}{\mathrm{L}}&
\color{blue}{\mathrm{A}}&
\color{red}{\mathrm{-P}}&
\color{red}{\mathrm{-A}}&
\color{blue}{\mathrm{C}}&
\color{blue}{\mathrm{K}}\\
\color{blue}{\mathrm{L}}&
\color{blue}{\mathrm{-A}}&
\color{red}{\mathrm{-P}}&
\color{red}{\mathrm{A}}&
\color{blue}{\mathrm{C}}&
\color{blue}{\mathrm{-K}}
\end{array}
\$\$
Other techniques used:  
`print(*[x])` instead of `print(' '.join(x))`,  
`s*(j==0)` instead of `s if j else ''`,  
`[falsy,truthy][expr]` instead of `truthy if expr else falsy`, where the former list is just a string `' -'`,  
the rest is pretty straightforward.
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 37 bytes
```
' -'[(6⍴2)⊤⎕A⍳'AVDWMZ'],¨6 6⍴'LAPACK'
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkGIBaQVlfQVY/WMHvUu8VI81HXEqCg46PezeqOYS7hvlHqsTqHVpgpgGTVfRwDHJ291f//BwA "APL (Dyalog Unicode) – Try It Online")
* `⎕IO←0`.
We encode the dashes matrix by
* encoding dashes as `1`s (and spaces as `0`s)
* converting each column from binary to a decimal number (`0 21 3 22 12 25`)
* indexing into the alphabet (`AVDWMZ`).
We decode it the same way:
* `⎕A⍳` - retrieves index into alphabet
* `(6⍴2)⊤` converts to binary columns
* `' -'[...]` - `1` becomes dash.
Then we generate the `LAPACK` matrix with `6 6⍴'LAPACK'`, and concatenate each pair with `,¨`.
[Answer]
# [///](https://esolangs.org/wiki////), 83 bytes
```
/$/ -//#/A@//!/
L //@/  /L@#P@#C@K!-#P$#C$K! #P@A$C$K!-#P$A$C@K! A$P$#C@K!-A$P@#C$K
```
[Try it online!](https://tio.run/##FYqxDcAwCAT7TAGC1voVQC7twiukiJQiHfuLQHe6u/jueJ/IhIIGIHADGNcmwECEbXJMpi0eclSmLqYyrk2tiiqSa9feiqy/zB8 "/// – Try It Online")
[Answer]
# [R](https://www.r-project.org/) + magrittr, 312 bytes
```
library(magrittr)        
A <- matrix(c(1,1,1,-1),nrow = 2)
B <- matrix(c(1,1,1,1,1,-1,1,-1,1),nrow = 3)
kronecker(B,A) %>% 
  apply(1, function(x) {paste0(x,strsplit("LAPACK","")[[1]]) %>%
  gsub("-1","-",.) %>%  gsub("1"," ",.)})  %>% 
  apply(2,function(x){paste0(x, collapse = " ")})  %>% 
  cat(sep = "\n")
```
[Try it online!](https://tio.run/##bU9Ni8IwEL3nVwwBYQLpsnWvKtQ9ugfv6iGGKMGYhkmKLbK/vZtqWRWcgTm8eR8z1PfO7klRh2d1JJsSCRiLsQpmBZxVItuixlIOXZRCeqovMIepYMs3jDtrHP/kL8FOVHujT4ZwKSsBk8UEGIAKwXVZCofG62Rrj62Aa1AxmU9sZUwUg7MJ@U@1rr5XXHIuNptyt7s5ZINjbPbIizJvCi4/7sYjOoAwgL/5rZfAqXzKe8SBrp1TIZp8clY@67RKGE0YFlvPRd//AQ "R – Try It Online")
This gives on my console:
```
 L  A  P  A  C  K
 L -A  P -A  C -K
 L  A  P  A -C -K
 L -A  P -A -C  K
 L  A -P -A  C  K
 L -A -P  A  C -K
```
With the function kronecker() we construct a block matrix by replicating A by B coefficients.
A is a 2x2:
```
> A
     [,1] [,2]
[1,]    1    1
[2,]    1   -1
```
which are the signs that we want to replicate in 3x3 blocks multiplied by the coefficients in B:
```
> B
     [,1] [,2] [,3]
[1,]    1    1    1
[2,]    1    1   -1
[3,]    1   -1    1
```
Then we explode LAPACK with strsplit() and prepend 1 or -1. With gsub() we substitute 1 and -1. Then, we collapse the strings and print out to the console.
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), 30 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Happy to be beating 05AB1E after quite a bit of work on this but still feel I could do much better. Originally based on Neil's Charcoal solution.
```
"?*<)3&"¬®csSi-)í"LAPACK")ò ¸x
```
[Test it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&code=Ij8qPCkzJiKsrmNzU2ktKe0iTEFQQUNLIinyILh4)
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~62~~ 57 bytes
Port of the [Arnauld's](https://codegolf.stackexchange.com/a/206683/80745) alternative answer. Very nice! Delicious! Thanks.
We avoid the problem with `2 trailing spaces on the last row` because we use the array of strings, not the string with repeated `LAPACK\n`.
```
,'LAPACK'*6-replace'\B',{' '+' -'[(214811968-shr++$i)%2]}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X0fdxzHA0dlbXctMtyi1ICcxOVU9xkldp1pdQV1bXUFXPVrDyNDEwtDQ0sxCtzijSFtbJVNT1Si29v9/AA "PowerShell – Try It Online")
---
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 71 bytes
port of [C (gcc)](https://codegolf.stackexchange.com/a/206688/80745) answer. Thanks @[Noodle9](https://codegolf.stackexchange.com/users/9481/noodle9) and @[Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld).
```
-join(29..0|%{'CAPAL'[$_%5];' ';' -'[(22141337-shr$_)%2];'K
'*!($_%5)})
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/XzcrPzNPw8hST8@gRrVa3dkxwNFHPVolXtU01lpdQR2IddWjNYyMDE0MjY3NdYszilTiNVWNgJLeXOpaihoglZq1mv//AwA "PowerShell – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~94~~ 77 bytes
-17 bytes thanks to mazzy
```
-join("L  A  P  A  C  K
"*6|% t*y|%{"$_-"[++$i+12-in' &,:=BHKYVdgp'[0..12]]})
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/XzcrPzNPQ8lHQcFRQSEATDorKHhzKWmZ1agqlGhV1qhWK6nE6ypFa2urZGobGulm5qkrqOlY2Tp5eEeGpaQXqEcb6OkZGsXG1mr@/w8A "PowerShell – Try It Online")
Just checking for the indexes we need saves 9 bytes over just writing out the block. However, if we represent the indexes using their char values, we save loads more. We add 12 to the current iteration to get everything into the printable ASCII range. `' &,:=BHKYVdgp'[0..12]` converts our index string into an index array so we can use `-in`.
[Answer]
# [Io](http://iolanguage.org/), 125 bytes
```
"      - - -    -- - --   --   --  - "foreach(x,i,("LAPACK"exSlice(x%6,x%6+1).." ".. i asCharacter .. if(x%6>4,"
",""))print)
```
[Try it online!](https://tio.run/##y8z//19JAQx0wRDEALN0ISwIoauglJZflJqYnKFRoZOpo6Hk4xjg6OytlFoRnJOZnKpRoWqmA8Tahpp6ekoKSnp6CpkKicXOGYlFicklqUUKIIE0kCo7Ex0lLiUdJSVNzYKizLwSzf//AQ "Io – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 132 bytes
```
s,a,i="0"*19+bin(0x208200090824009002402)[2:],list("L  A  P  A  C  K\n"*6),0
for c in s:
	if(int(c)):a[i]="-"
	i+=1
print "".join(a)
```
[Try it online!](https://tio.run/##XY09D4IwEIZn@ysut9BCa47GGCFhMI44uCMDkhBrTCHAoL@@FgLGuNybPO/Hde/x3lrt3CAraTIkDOMkuhnL6aXpoIko8bKbhLxoUei0lE8zjBzPAEeAy3xPAPnVYrgXkljT9lCDsTCkbGMabuzIayHSqjBlhgo9jLKYdb03AHH7aP3DSrggCNj/qAdqBmoGKv9NqAV8E2qpTN5aWTfUOuor/pP7AA "Python 2 – Try It Online")
Yes, I realise this is longer than a simple print statement, but I spent too long trying to get this to work and I liked the approach (for larger matrices, this method would become much more efficient). There must be at least a few ways to shave a couple bytes off this answer
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 356 bytes
```
++++++++[>+++++>++++++++>++++>+++++++++>+<<<<<-]>+++++>+>>++++>++<.<..<.>..>++++.<..<.>..<++.>..>-----.>.<+.<.<<.>--.>..>++++.<.<<.>.>..<++.>.<<.>>>-----.>.<+.<..<--.>..>++++.<..<.>.<<.>++.>.<<.>>>-----.>.<+.<.<<.>--.>..>++++.<.<<.>.>.<<.>++.>..>-----.>.<+.<..<--.>.<<.>>>++++.<.<<.>.>..<++.>..>-----.>.<+.<.<<.>--.>.<<.>>>++++.<..<.>..<++.>.<<.>>>-----.>.
```
[Try it online!](https://tio.run/##dU9bCoAwDDuQrCcIvYj4oYIggh@C56/LdHOFrRTWZEkfyzXv53avh9nwxajp0YzVoViBEaYs0yyAQGKqSGIKQqxJBkaswC@ARC0m88uJ1FsE3pC6U9czdGcUkzQnvK2aa/WucJb6bL@W2QM "brainfuck – Try It Online")
There is the version, line by line (The 1st one is used to store the different chars)
```
++++++++[>+++++>++++++++>++++>+++++++++>+<<<<<-]>+++++>+>>++++>++
<.<..<.>..>++++.<..<.>..<++.>..>-----.>.
<+.<.<<.>--.>..>++++.<.<<.>.>..<++.>.<<.>>>-----.>.
<+.<..<--.>..>++++.<..<.>.<<.>++.>.<<.>>>-----.>.
<+.<.<<.>--.>..>++++.<.<<.>.>.<<.>++.>..>-----.>.
<+.<..<--.>.<<.>>>++++.<.<<.>.>..<++.>..>-----.>.
<+.<.<<.>--.>.<<.>>>++++.<..<.>..<++.>.<<.>>>-----.>.
```
]