[Question]
  [
## Input
None
## Output
52 cards. No duplicates. Cards are represented as their unicode characters, e.g. üÇπ.
The [Unicode codepoints](http://unicode.org/charts/PDF/U1F0A0.pdf) follow the following format:
* The first three digits are `1F0`.
* The next digit is `A`, `B`, `C`, or `D` for spades, hearts, diamonds, and clubs respectively.
* The next digit is `1` through `C` and `E` for the various numbers/face cards. `1` is ace, `2`-`A` are the number cards, and `B`, `D`, and `E` are the jack, queen, and king respectively. (`C` is the knight, which isn't in most decks.)
**Example output:** 
üÇ∂üÉÅüÉõüÉéüÇßüÇµüÉóüÇ¶üÇΩüÇπüÇ£üÉäüÉöüÇ≤üÇ°üÇ•üÇ∑üÉÑüÉÉüÉûüÇ∫üÇ≠üÉëüÉôüÇ™üÉñüÇ≥üÉòüÉíüÇªüÉÜüÇÆüÉçüÇ±üÇ¥üÉãüÇ∏üÉàüÉÖüÉÇüÇ®üÉìüÉâüÇæüÉáüÇ©üÇ¢üÇ´üÉîüÉïüÇ§üÉù
## Rules:
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"). Shortest answer wins.
* [Forbidden loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* Your deck must be actually randomized. If run 20 times, 20 random (and most likely unique) outputs must be generated.
## Note
If you only see boxes, install [the DejaVu fonts](https://dejavu-fonts.github.io/).
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~25 23~~ 21 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
62R%‚Å¥g180<11T+‚Äú¬¢¬¨‚Å∑‚Äô·∫ä·ªå
```
A niladic link returning a list of characters, or a full program that prints the shuffled deck.
**[Try it online!](https://tio.run/##ATUAyv9qZWxsef//NjJSJeKBtGcxODA8MTFUK@KAnMKiwqzigbfigJnhuorhu4z///Vuby1jYWNoZQ)**
### How?
```
62R%‚Å¥g180<11T+‚Äú¬¢¬¨‚Å∑‚Äô·∫ä·ªå - Main link: no arguments
62                    - literal 62
  R                   - range(62) -> [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31, 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47, 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62]
    ‚Å¥                 - literal 16
   %                  - modulo    -> [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14]
      180             - literal 180
     g                - G.C.D.    -> [1,2,3,4,5,6,1,4,9,10, 1,12, 1, 2,15,180, 1, 2, 3, 4, 5, 6, 1, 4, 9,10, 1,12, 1, 2,15,180, 1, 2, 3, 4, 5, 6, 1, 4, 9,10, 1,12, 1, 2,15,180, 1, 2, 3, 4, 5, 6, 1, 4, 9,10, 1,12, 1, 2]
          11          - literal 11
         <            - less than?-> [1,1,1,1,1,1,1,1,1, 1, 1, 0, 1, 1, 0,  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0,  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0,  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1]
            T         - truthy    -> [1,2,3,4,5,6,7,8,9,10,11,   13,14,       17,18,19,20,21,22,23,24,25,26,27,   29,30,       33,34,35,36,37,38,39,40,41,42,43,   45,46,       49,50,51,52,53,54,55,56,57,58,59,   61,62]
              ‚Äú¬¢¬¨‚Å∑‚Äô   - base 250 number 127136
             +        - addition (vectorises) -> card character ordinals
                   ·∫ä  - shuffle the list
                    ·ªå - convert to characters
                      - full program has an implicit print
```
[Answer]
# JavaScript (ES6), ~~107~~ ~~106~~ 108 bytes
```
a=[]
for(S of'ABCD')for(N of'123456789ABDE')a.splice(Math.random()*-~a.length,0,eval(`'\\u\{1F0${S+N}}'`))
a
```
```
a=[]
for(S of'ABCD')for(N of'123456789ABDE')a.splice(Math.random()*-~a.length,0,eval(`'\\u\{1F0${S+N}}'`))
a
o.innerHTML = a.join``
```
```
<div id=o style="font-size:80px"></div>
```
-1 byte thanks to [@nderscore](https://codegolf.stackexchange.com/questions/124565/print-a-shuffled-deck-of-cards/124606#comment306395_124606)
---
# JavaScript (ES6), ~~120~~ ~~119~~ 121 bytes
Previous version.
```
a=[],[...'ABCD'].map(S=>[...'123456789ABCE'].map(N=>a.splice(Math.random()*-~a.length|0,0,eval("'\\u\{1F0"+S+N+"}'")))),a
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~106~~ 94 bytes
-5 bytes thanks to musicman523 (1. use `sample(...,52)` as an inline equivalent to `shuffle` [thanks to totallyhuman]; 2. use `~v&2` instead of `v%4<2`; plus a further 1 byte as a consequence as a space may be removed)
```
from random import*
print(*sample([chr(v+127137)for v in range(63)if~v&2or~v%16>4],52),sep='')
```
**[Try it online!](https://tio.run/##FcsxDsIgFADQ3VOw2EKtA2DbSS9iHAiCkAj/55eQdOmtnVGnNz3cSoCsW/MEiZHJzx8xIVAZDkgxFz6sJuHb8bsNxOtJqkXqRXggVlnM//NyfNYi@r12CmivRznfLo9xUmJcHV77XrT2yXC2xgb3BQ)**
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~22~~ 21 bytes
Saved 1 byte thanks to *carusocomputing*.
```
‚Ä¶1F0A4¬£14L13KhJ√¢¬´H√ß.r
```
[Try it online!](https://tio.run/##AS4A0f8wNWFiMWX//@KApjFGMEE0wqMxNEwxM0toSsOiwqtIw6cucv//9W5vLWNhY2hl "05AB1E ‚Äì Try It Online")
**Explanation**
```
‚Ä¶1F0                    # push the string "1F0"
    A4¬£                 # push the string "abcd"
       14L              # push range [1 ... 14]
          13K           # remove 13
             h          # convert to hexadecimal
              J         # join to string "123456789ABCE"
               √¢        # cartesian product
                ¬´       # prepend the string to each char in the list
                 H      # convert to decimal
                  √ß     # get the chars with those code points
                   .r   # randomize
```
[Answer]
# Bash + coreutils, 56 bytes
```
printf %b\\n \\U1F0{A..D}{{1..9},A,B,D,E}|shuf|tr -d \\n
```
We use `printf` to write each card on its own line, shuffle the lines, then concatenate all the lines by removing the newline characters.
Note that although the coreutils `printf` command requires exactly 8 hexadecimal digits after `\U`, the Bash built-in `printf` lets us omit leading zeros.
[Answer]
# [Python 3](https://docs.python.org/3/), 112 bytes
```
from random import*
*a,=map(chr,range(127136,127200))
del a[::16],a[::-15],a[11::14]
shuffle(a)
print(*a,sep='')
```
[Try it online!](https://tio.run/##FczBCoMwEATQe77Cm4mk4GprQfBLioelJo1gkmVND/36dD29YQaGfiXkNNbqOceGMW3CHilz6VSHdolI@h3YyvRxGoYnjJMVhr43Rm3uaPA1zzCt9vIGjysASHVf1Rm@3h9Oo1HEeypaHk9HS9uaWv8 "Python 3 ‚Äì Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 107 bytes
Saved 6 bytes thanks to @totallyhuman and 3 thanks to @CCB60!
```
from random import*
print(*sample([chr(int('1F0'+a+b,16))for a in'ABCD'for b in'123456789ABDE'],52),sep='')
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P60oP1ehKDEvBUhl5hbkF5VocRUUZeaVaGgVJ@YW5KRqRCdnFGmABNQN3QzUtRO1k3QMzTQ10/KLFBIVMvPUHZ2cXdRBvCQQz9DI2MTUzNzC0tHJxVU9VsfUSFOnOLXAVl1d8///r3n5usmJyRmpAAA)
[Answer]
# [PHP](https://php.net/)>=7, 102 bytes
```
for(;$i++<64;)in_array(($c=127136+$i)%16,[0,12,15])?:$q[]=IntlChar::chr($c);shuffle($q);echo join($q);
```
No Online Interpreter available for the [IntlChar::chr](http://php.net/manual/en/intlchar.chr.php) method
# [PHP](https://php.net/), 112 bytes
```
for(;$n++<4;shuffle($r))for($i=0;$i++<14;)$i==12?:$r[]=pack("c*",240,159,131-($n>2),$n*16+112+$i);echo join($r);
```
[Try it online!](https://tio.run/##FYyxCsIwFAB3v0LkDUmTQl@sgqa1g3Rw0cVNpJSQmqgkIerqXzvHdrw7uGBCqppgwkzH6GMXdfDxbd2NfNvueDof9i2VafCRSHCMVaV8mc8wPDWBSOnkwdaFBDs2LCUdqUbRbCFernXo1YMsVLbgoiw4rjYcl5gTcDtBObgM1wxRMLBUamX8/O6tm74ypZ/zueqV0X8 "PHP ‚Äì Try It Online")
# [PHP](https://php.net/), 116 bytes
```
for(;$c=ab89[$n++];shuffle($r))for($i=0;$i++<14;)$i==12?:$r[]=hex2bin(f09f8.(2+($n>2)).$c.dechex($i));echo join($r);
```
[Try it online!](https://tio.run/##FYyxDsIgFEV3v8LhDbwQm5Y4tFLsYDq46OJmmqZFEIwBgpo4@dfOiNu9OefeYEJqu2DCQsXo4xhV8PFp3ZV8@vFwPO13PfKkfSQcpJjmujmDo3TgD/PS@q4IRMQ/BitKDpbStlpzzE1UrNtAPA/CqDebrSO6bHRdEEYJuC1DLEAWFyUzzmtEnqNf3nw28ylP6ev8Sk6Z/wA "PHP ‚Äì Try It Online")
# PHP, 121 Bytes
```
for(;$c=ABCD[$n++];shuffle($r))for($i=0;$i++<14;)$i==12?:$r[]=json_decode('"\ud83c\udc'.$c.dechex($i).'"');echo join($r);
```
[Try it online!](https://tio.run/##FYxbC8IgGIb/SowPVCRp1UXMyejwL9aI8ICOUHEM@uNd27ebF573lH2u/ZBRXSpUglbX2/0xQuR8kotfnftYCoWxLYagDhIC5317lgxJtcehgzJOal5SfBmrk7GUNM/VXE4aVRMBWqDv7RfnTJCGMImYdnMKcXuWtf5i2us3dv4 "PHP ‚Äì Try It Online")
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~40~~ 38 bytes
### [Jonathan Allan's method](https://codegolf.stackexchange.com/a/124569/43319)
```
‚éïUCS((11>180‚à®16|‚ç≥62)/127136+‚ç≥62)[?‚ç®52]
```
`(`‚Ä¶`)` on the following array
‚ÄÉ`‚ç≥62`‚ÄÉthe first 62 integers
‚ÄÉ`127136+`‚ÄÉadd 127136 to that
‚ÄÉ`(`‚Ä¶`)/`‚ÄÉfilter that with the Boolean
‚ÄÉ‚ÄÉ`‚ç≥62`‚ÄÉfirst 62 integers
‚ÄÉ‚ÄÉ`16|`‚ÄÉmodulus 16
‚ÄÉ‚ÄÉ`180‚à®`‚ÄÉGCD of 180 and that
‚ÄÉ‚ÄÉ`11>`‚ÄÉwhether 11 is greater than those
`[`‚Ä¶`]` select the following elements
‚ÄÉ`?‚ç®52`‚ÄÉshuffle the first 52 integers (pick 52 random integers out of a bag of the first 52 integers)
`‚éïUCS`‚ÄÉconvert to corresponding symbols in the **U**nicode **C**haracter **S**et
---
### Version 16.0 (currently in beta) solution (33 characters)
```
‚éïUCS(127136+‚ç∏11>180‚à®16|‚ç≥62)[?‚ç®52]
```
`(`‚Ä¶`)` on the following array
‚ÄÉ`‚ç≥62`‚ÄÉfirst 62 integers
‚ÄÉ`16|`‚ÄÉmodulus 16
‚ÄÉ`180‚à®`‚ÄÉGCD of 180 and that
‚ÄÉ`11>`‚ÄÉwhether 11 is greater than those
‚ÄÉ`‚ç∏`‚ÄÉindices where True
‚ÄÉ`127136+`‚ÄÉadd 127136 to that
`[`‚Ä¶`]` select the following elements
‚ÄÉ`?‚ç®52`‚ÄÉshuffle the first 52 integers (pick 52 random integers out of a bag of the first 52 integers)
`‚éïUCS`‚ÄÉconvert to corresponding symbols in the **U**nicode **C**haracter **S**et
---
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 50 bytes
```
Ôº°¬π¬≤‚Å∑¬π¬≥‚Å∂œáÔº°‚™´Ôº•‚Ä¶œá‚Å∫‚Å∂‚Å¥œá‚ÑÖŒπœâœÉÔº∑œÉ¬´Ôº°‚ÄΩœÉœáÔº°‚™´‚™™œÉœáœâœÉ¬øÔπ™Ôπ™Ôπ™‚ÑÖœá¬π‚Å∂¬¶¬π‚Åµ¬¶¬π¬≥œá
```
[Try it online!](https://tio.run/##XY3BDoIwDIbP4yl27BI4IIoHT8abCZHoEywDoUnZyAZyMD773CKJxkP/pn/b71e9tMpI8v7oHHYa8s0@L8qUK3FIVutsUEMlR7hK3bWgUl7T7KDcxiuR8lNgSDW1FjCOSygXvpceqeXgBH8mbEUFQmOG4H0C2G/CbSScwMXNF8LwzqEyzUzmr11sg1oSxOu8jLKLUgiRMFZb1BPEiJf3Pnv4zNEb "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Creates the string of all the 64 characters in the block but filters invalid cards out as they are randomly selected. (Speaking of which, random selection without replacement from a string is only 11 bytes, compared to 17 for an array.)
Edit: Subtraction from an array and other Charcoal improvements have cut down the size to 41 bytes: [Try it online!](https://tio.run/##XYy9DsIgFIVneIo73pvQoVbr4GScGxt9AqTVkiBYaHUwPjtC1MXlnOQ7P2qQXjlpYtyGoC8WG3nDeilglwKppt5ja@aA5WJdVrUATUQCRtrwx6BNDzgSPDn7jg/Sdu6amIAhVX74OJ@mfIZj5p8502fAxnWzcX@295220mBulnWWVZaKiDPWem0nzOevGGNxj0Uwbw "Charcoal ‚Äì Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 23 bytes
```
kA4·∫ék^·∏¢·π™\Do·∫ä`1F0`vpHC√û‚ÑÖ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJrQTThuo5rXuG4ouG5qlxcRG/huopgMUYwYHZwSEPDnuKEhSIsIiIsIiJd)
Port of 05AB1E.
## How?
```
kA4·∫ék^·∏¢·π™\Do·∫ä`1F0`vpHC√û‚ÑÖ
kA4·∫é                    # Get the first 4 letters of the uppercase alphabet
    k^                  # Push string "0123456789ABCDEF"
      ·∏¢·π™                # Remove head and tail: "123456789ABCDE"
        \Do             # Remove the D: "123456789ABCE"
           ·∫ä            # Cartesian product of strings: ["A1", "A2", "A3", "A4", ..., "DC", "DE"]
            `1F0`       # Push string "1FO"
                 vp     # Prepend to each: ["1FOA1", "1FOA2", ..., "1FODE"]
                   H    # Convert each from hexadecimal: [127137, 127137, ..., 127198]
                    C   # Convert each to their unicode representation: ["üÇ°", "üÇ¢", ... "üÉû"]
                     √û‚ÑÖ # Randomly shuffle
```
Port of Jelly is same byte count:
# [Vyxal](https://github.com/Vyxal/Vyxal), 23 bytes
```
62…æ16%180ƒ°11<T¬ª∆õ«î·∏≠¬ª+C√û‚ÑÖ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCI2Msm+MTYlMTgwxKExMTxUwrvGm8eU4bitwrsrQ8Oe4oSFIiwiIiwiIl0=)
## How?
```
62…æ16%180ƒ°11<T¬ª∆õ«î·∏≠¬ª+C√û‚ÑÖ
62…æ                     # Push range [1, 2, ..., 62]
   16%                  # Modulo each by 16
      180ƒ°              # GCD each with 180: [1, 2, 3, 4, 5, 6, 1, 4, 9, 10, ..., 12, 1, 2]
          11<T          # Indices where item is less than 11: [0, 1, 2, 3, ... 13, 16, 17, ..., 26, ...]
              ¬ª∆õ«î·∏≠¬ª     # Push compressed integer 127137
                   +    # Add to each (vectorizes)
                    C   # Convert each to their unicode representation
                     √û‚ÑÖ # Randomly shuffle
```
For both solutions, add `s` flag if it needs to be a string instead of a list.
[Answer]
# [Alice](https://github.com/m-ender/alice), 34 bytes
```
'?rwd.n$@U,!6?44*%a7+-F$K?'üÇ°+OK
```
[Try it online!](https://tio.run/##S8zJTE79/1/dvqg8RS9PxSFUR9HM3sRESzXRXFvXTcXbXv3D/KaF2v7e//9/zcvXTU5MzkgFAA "Alice ‚Äì Try It Online")
### Explanation
```
'?r                               push numbers 0-63 onto stack
   w                              store return address (start main loop)
    d                             get stack depth
     .n$@                         if zero, terminate
         U                        random number in [0, depth)
          ,                       move corresponding stack element to top
           !                      store on tape
             ?                    copy back from tape
              44*%                mod 16
                  a7+-            subtract 17
            6         F           does the result divide 6?
                       $K         if so, return to start of main loop
                         ?        copy card number from tape again
                          'üÇ°+     add 0x1F0A1
                             O    output
                              K   return to start of main loop
```
[Answer]
## [><>](https://esolangs.org/wiki/Fish), ~~49~~ ~~50~~ 49 bytes
```
"üÇ°"v
=?v>:1+}:88+%:c-:3-**?!~{l4d*
{>x
o^>l?!;
```
[Try it online!](https://tio.run/##S8sszvj/X@nD/KaFSmVctvZldlaG2rVWFhbaqlbJulbGulpa9op11TkmKVpc1XYVXPlxdjn2itb//3/Ny9dNTkzOSAUA "><> ‚Äì Try It Online")
*(+1 byte to make the randomness better)*
I'm interpreting "random" to mean "every possible outcome has a non-zero probability". This isn't a uniform distribution.
There are two stages to this code. First, the fish puts all the cards on the stack, using the first two lines. Starting with the ace of spades, the fish duplicates and increments it, then checks if the previous card's hex code ends in 0, C or F by multiplying together *x*¬†(*x*-12)¬†(*x*-15), where *x* is the charcode mod 16, and checking if that's zero. If it is, it deletes the offending card from the stack. It repeats until the stack has 52 cards, then swims into stage 2:
```
  v
{>x
o^>l?!;
```
This bit of code shuffles and prints the stack. The `x` sets the fish's direction randomly:
* If the fish swims up, it hits the `v` and goes back to the `x` without doing anything. The left direction is similar.
* If the fish swims right, it wraps and hits the `{`, rotating the entire stack to the left, then returns to the `x`.
* If the fish swims down, it prints the card at the front of the stack then returns to the `x`.
It's clear that every possible order of the cards can be produced: at any point in stage 2, every card that hasn't been printed yet can be printed next if the fish swims rightwards enough times. This shuffling technique usually doesn't move cards very far apart if they were already near each other, but then again, [neither does shuffling by hand](https://www.math.upenn.edu/~pemantle/papers/overhand2.pdf).
[Answer]
# R, 61 bytes
```
cat(intToUtf8(sample(c(127137:127198)[-c(12,28,44,47,60)])))
```
Randomly sample the vector of integer representations of the cards unicode values (which can be obtained from `utf8ToInt()` fucntion) and remove the unwanted knight/joker cards.
[Answer]
## C# (146 141 bytes)
```
using System.Linq;()=>Enumerable.Range(0,52).OrderBy(i=>System.Guid.NewGuid()).Aggregate("",(s,i)=>s+"\uD83C"+(char)(56481+i+i/13*3+i%13/12))
```
[Online demo](http://ideone.com/BgEiYG)
This uses extremely bad style in shuffling with `Guid.NewGuid()`, but it's code-golf. It then builds the surrogate pairs manually.
[Answer]
# Perl 5, 75 bytes
```
@c=map{7946+$_%4+$_/64}4..51,56..59;print chr(16*splice@c,@c*rand,1)while@c
```
Note that this uses the code points for queens as given in the question (i.e. last digit `C`). For the actual code points (last digit `D`), replace `51,56` with `47,52`.
[Answer]
# Java 8, 216 bytes
```
import java.util.*;()->{List<Long>l=new ArrayList();for(long i=52;i-->0;l.add(i));Collections.shuffle(l);for(Long x:l)System.out.print((char)(x.parseLong("1F0"+(char)(65+x/12)+((x%=4)>9?(char)(x>2?69:65+x):x),16)));}
```
**Explanation:**
[Try it here.](https://tio.run/##PVDLbsIwELznK1ZIlezSmIcKEqQJqir1RFEljlUPi@MQU2NHtkODEJ/dc3AK7WWlndnZ3ZkdHjA2ldC7/KuV@8pYD7uAsdpLxe4TGAzgHQNoCvClgM3Ri5ibWvso4gqdgzeU@hQBSO2FLZALWHUtwMHIHDihSejOUSjOo5ccVqAhhZbQODstpfNPS6O3mUq1@IZna/HYgUFWGEtUoECmk3Ei4zgbJophnhNJafJilBLcS6Mdc2VdFEoQdRV1@6CZK7o@Oi/2zNSeVTb8Rwgv0VLSsAqtE90c6Y1eh73@jZhO@s1gNKZ9Qpq79JFms8WfJBsvprN5N0DnDX0YTWl44twmnbGq3qhg7Obv1/c@pELWPlzdfnwC0mskmv3ncW5/tIk58lJcAA)
NOTE: Untested because even though I've installed the linked font, I still see boxes. Probably have to restart my PC or something..
```
import java.util.*;               // Required import for List, ArrayList and Collections
()->{                             // Method without parameter nor return-type
  List<Long>l=new ArrayList();    //  List
  for(long i=52;i-->0;l.add(i));  //  Fill the list with 1 through 52
  Collections.shuffle(l);         //  Randomly shuffle the list
  for(Long x:l)                   //  Loop over the shuffled list
    System.out.print(             //   Print the following character:
      (char)(x.parseLong(         //    Convert the following String to a character:
        "1F0"+                    //     The literal String "1F0" +
         (char)(65+x/12)+         //     either A, B, C or D by using x/12, adding 65,
                                  //      and casting it to a char +
         ((x%=4)>9?               //     If the current item mod-4 is 10 or higher:
            (char)(x>2?69:65+x)   //      Convert it to A, B, C or E
           :                      //     Else (1 through 9):
            x)                    //      Simply add this digit
      ,16))
    );
}                                 // End of method
```
[Answer]
# Dyalog APL, 35 bytes
```
‚éïucs(‚àä127150+(16√ó‚ç≥4)-‚äÇ2~‚ç®‚ç≥14)[?‚ç®52]
```
based on [Ad√°m's answer](https://codegolf.stackexchange.com/questions/124565/print-a-shuffled-deck-of-cards#answer-125024)
uses `‚éïio‚Üê0`
[Answer]
# [Japt](https://github.com/ETHproductions/japt/), ~~51~~ ~~41~~ ~~39~~ 22 bytes
With some inspiration from [Jonathan's Jelly solution](https://codegolf.stackexchange.com/a/124569/58974).
```
#?√∂¬¨k@B¬ßXuG y#¬¥√Émd##
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=Iz/2rGtAQqdYdUcgeSO0w21kI38jiA==&input=LVM=) (or [view output with increased `font-size`](https://ethproductions.github.io/japt/?v=1.4.5&code=Iz/2rGtAQqdYdUcgeSO0w21kI38jiA==&input=LVM=))
---
## Explanation
```
#?                         :63
  √∂¬¨                       :Random permutation of range [0,63)
    k                      :Remove elements that return true
     @                     :When passed through this function
      B                    :  11
       ¬ß                   :  Less than or equal to
        X                  :  Current element
         u                 :  Modulo
          G                :  16
            y              :  GCD
             #¬¥            :  180
               √É           :End function
                m          :Map
                  ##       :  Add 127136
                 d         :  Get character at that codepoint
```
]