[Question]
  [
[Minecraft 1.12](http://minecraft.gamepedia.com/1.12) will be released tomorrow, so let's celebrate!
Write code that takes in a non-negative integer N which represents the number of items of something in [Minecraft](http://minecraft.gamepedia.com/Minecraft). Output it in a way more helpful to players, giving the number of chests, stacks, and items N is equivalent to. Use the format
```
XcYsZi
```
where
* `X` is the number of chests you can completely fill with N items,
* `Y` is the number of stacks you can fill with the items remaining after filling chests,
* `Z` if the number of items remaining after filling chests and stacks.
Note that:
* 64 items fit in a stack. (We'll ignore items that stack to 16 or don't stack.)
* 27 stacks fit in a chest. (These are single chests, not double chests.)
So it would never make sense if `Y` is more than 26 or if `Z` is more than 63.
A caveat with the format is that if there is zero of something, that term is not printed.
* So, for example, if `Y` were zero and `X` and `Z` nonzero, the format would look like `XcZi`.
* Likewise if `Y` and `Z` were zero and `X` nonzero, the format would be `Xc`.
* **The exception here is when N is zero.** Then `0i` is the output rather than an empty string.
You can assume all N items are of the same type, hence all stackable.
You may not output a list or tuple of three numbers. You must give a string with the exact "csi" notation, in that order, with no spaces or commas.
For reference, here's a chest completely filled with stacks of items:
[![Minecraft single chest filled with 27 stacks of diamonds](https://i.stack.imgur.com/zRLuw.png)](https://i.stack.imgur.com/zRLuw.png)
# Testcases
```
in -> out
0 -> 0i
1 -> 1i
2 -> 2i
62 -> 62i
63 -> 63i
64 -> 1s
65 -> 1s1i
66 -> 1s2i
127 -> 1s63i
128 -> 2s
129 -> 2s1i
200 -> 3s8i
512 -> 8s
1337 -> 20s57i
1664 -> 26s
1727 -> 26s63i
1728 -> 1c
1729 -> 1c1i
1791 -> 1c63i
1792 -> 1c1s
1793 -> 1c1s1i
4096 -> 2c10s
5183 -> 2c26s63i
5184 -> 3c
5200 -> 3c16i
9999 -> 5c21s15i
385026 -> 222c22s2i
1000000000 -> 578703c19s
```
**The shortest code in bytes wins.**
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~26~~ 24 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
d64d1¦27Fża¥“csi”Fḟ0ȯ⁾0i
```
A full program taking the number and printing the result.  
It does seem too long to me...
**[Try it online!](https://tio.run/##ATIAzf9qZWxsef//ZDY0ZDHCpjI3RsW8YcKl4oCcY3Np4oCdRuG4nzDIr@KBvjBp////MTcyOQ)** or see the [test suite](https://tio.run/##NYwxDsIwDEWvwgGMZDuJ0yyMvQNCDIgytOrGxFZYuASICSYkVoaKoagS1yAXCc7Al/8f7PfdbNp2l1IltqLhxr4c@9Vwjd1pva1jdy6/zwt@HnH/wjqN/fsYD/dGrcBkOpsoMU9pgUDAIDoGxII4EAFiry7UARgRHDGQMboUZcjns893rwD5QDk4hwGLQbRQmBwWXO4HFZjCIetv/Gv5Aw).
### How?
*updating...*
```
d64d1¦27Fża¥“csi”Fḟ0ȯ⁾0i - Main link: number n
 64                      - literal 64
d                        - divmod (whole divisions and remainder)
      27                 - literal 27
    1¦                   - apply to index 1 (the whole division from above)
   d                     - divmod
        F                - flatten into a single list (of three items i.e. [(n/64)/27, (n/64)%27, n%64]
            “csi”        - literal ['c','s','i']
           ¥             - last two links as a dyad:
         ż               -   zip
          a              -   logical and (any 0s in the divmod result become [0,0], others become [integer, character]
                 F       - flatten (from list of three lists to one list)
                  ḟ0     - filter discard zeros
                     ⁾0i - literal ['0','i']
                    ȯ    - logical or (non-vectorising)
                         - implicit print (smashed together representation, so [578703,'c',19,'i'] prints as 578703c19i)
```
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~49~~ ~~48~~ 41 bytes
```
.+
$*i
i{64}
s
s{27}
c
(.)\1*
$.&$1
^$
0i
```
[Try it online!](https://tio.run/##HUtJDsIwDLzPOwpCIFWxnTjJC/gFAkUceuFAuJW@PbVrzSJ5Zr7v3/J5jdPl/hzzDdMVtGrc0NFXzhsaHtOfLJjPC/rhHe3wNkYAgaEGgUZogiqIs7EYKzgEJGKQiD3VOpQ9zp5nK1Cu5MIughiq2qCIS0TyfbWDlBRYdw "Retina – Try It Online") Includes all test cases except the last, in case it overloaded TIO. Edit: Saved 7 bytes thanks to @MartinEnder. Explanation:
```
.+
$*i
```
Convert the input number to unary using `i`s.
```
i{64}
s
```
64 items fill one stack.
```
s{27}
c
```
27 stacks fill one chest.
```
(.)\1*
$.&$1
```
Convert any chests, stacks or remaining items to decimal, but leaving the type as a suffix.
```
^$
0i
```
If the input was zero, make the result `0i`.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 24 bytes
```
1728‰`64‰)˜…csiøvyJ¬0Êi?
```
[Try it online!](https://tio.run/##MzBNTDJM/f/f0NzI4lHDhgQzEyCpeXrOo4ZlycWZh3eUVXodWmNwuCvT/v9/AwA "05AB1E – Try It Online")
**Explanation**
```
1728‰                      # input divmod 1728 (64*27)
     `                     # split as separate with mod result on top of stack
      64‰                  # divmod 64
         )˜                # wrap stack in flattened list
           …csiø           # zip with the string "csi"
                vy         # for each
                  J        # join amount with storage-type
                   ¬0Êi    # if head != 0
                       ?   # print
```
[Answer]
# C#, 84 86 bytes
```
_=>(_/1728>0?_/1728+"c":"")+((_-=_/1728*1728)/64>0?_/64+"s":"")+(_%64>0?_%64+"i":"")
```
Notice the inline subtraction, didn't realize it was possible but `i--` made sense so why not `i-=10`
# Edit:
```
_=>_>0?(_/1728>0?_/1728+"c":"")+((_%=1728)/64>0?_/64+"s":"")+(_%64>0?_%64+"i":""):"0i"
```
for 0 edge case and suggestion.
[Answer]
# [Python 3](https://docs.python.org/3/), 87 bytes
```
lambda n:g(n//1728,"c")+g(n//64%27,"s")+g(n%64,"i")or"0i"
g=lambda n,s:(str(n)+s)*(n>0)
```
[Try it online!](https://tio.run/##PY7dasMwDIWv56cwBoPdetQ/iWMH0hfZdpG1TWvYnBL7Inv6VHbpBOcDoXMk3f/ybY5mm4bP7Wf8/T6POPZXFg8H1WknyInwfW1tQ3UnSHr21DaCBMLnhchA0HV4ZUXqWcoLi3yf@I7Fo@RbvqR8GtMlDR9SICWQFsgWGVADakEWJnAA4Ao8uCS4WwVGZUyZ2GKGt7pKV@kLvarUlbC0kd6WqDOVkGrrMg8lkHGt1OWcfNUXQtO84BWHiP@f7dHbfQkxM0IDfj9imghlq5jYyjnfHg "Python 3 – Try It Online")
[Answer]
# C, 85 ~~87~~ ~~105~~ ~~110~~ ~~111~~ ~~112~~ bytes
```
#define a(x,y)x?printf("%d%c",x,y+99):0;
f(z){a(z/1728,0)a(z%1728/64,16)!z+a(z%64,6)}
```
Try it [here](https://tio.run/##HYxBDsIgFET3nAIxmP9TTFtjUOzCs5BPMSyKRo2pND07grOYzLzFo/2NKOetG32II7cwqy/O18czxLcHIZ0koQprjMFLNzAPCRcLqe1Ph7PqsExZZ6uPqte4SU0l5Whc8@ceHJ9siIBsYcXI3cBeZOPfLNTOYTXWXrMp@QE).
The code even works properly on negative numbers. You may now owe server OP blocks!
[Answer]
## JavaScript (ES6), ~~77~~ 76 bytes
```
n=>[n+1,1728,64,1].map((v,i,a)=>(v=n%a[--i]/v|0)?v+'csi'[i]:'').join``||'0i'
```
### Test cases
```
let f =
n=>[n+1,1728,64,1].map((v,i,a)=>(v=n%a[--i]/v|0)?v+'csi'[i]:'').join``||'0i'
console.log(f(0)) // -> 0i
console.log(f(1)) // -> 1i
console.log(f(2)) // -> 2i
console.log(f(62)) // -> 62i
console.log(f(63)) // -> 63i
console.log(f(64)) // -> 1s
console.log(f(65)) // -> 1s1i
console.log(f(66)) // -> 1s2i
console.log(f(127)) // -> 1s63i
console.log(f(128)) // -> 2s
console.log(f(129)) // -> 2s1i
console.log(f(200)) // -> 3s8i
console.log(f(512)) // -> 8s
console.log(f(1337)) // -> 20s57i
console.log(f(1664)) // -> 26s
console.log(f(1727)) // -> 26s63i
console.log(f(1728)) // -> 1c
console.log(f(1729)) // -> 1c1i
console.log(f(1791)) // -> 1c63i
console.log(f(1792)) // -> 1c1s
console.log(f(1793)) // -> 1c1s1i
console.log(f(4096)) // -> 2c10s
console.log(f(5183)) // -> 2c26s63i
console.log(f(5184)) // -> 3c
console.log(f(5200)) // -> 3c16i
console.log(f(9999)) // -> 5c21s15i
console.log(f(385026)) // -> 222c22s2i
console.log(f(1000000000)) // -> 578703c19s
```
[Answer]
# Java 8, 86 bytes
```
i->i>0?(i/1728>0?i/1728+"c":"")+((i%=1728)/64>0?i/64+"s":"")+((i%=64)>0?i+"i":""):"0i"
```
[Try it here.](https://tio.run/##hZRfa4MwFMXf9ykugUGC1MZ/UVvafYL1ZY9jD6l1I52NUtPCGP3sLmoHexknRIj3/OAeTy4e9VUv2q62x8PnUDW67@lZG/v9QGSsq8/vuqppN74SvbizsR9Uca@QFWtfvPnH795pZyrakaUNDWaxNVv5xM0yyuPCn@ZDwCq2YkwEnJvHzVgRS5VOskoD1v8RVSrGesDMVFwxadiwnnt1l33je91bXltzoJN3zGd3r2@kxd3uV@/qU9heXNh5yTWW27DiUkzO/9UjoKsYAQkCUgRkCFDoI@IcEgUkSkDEEoWZRSitKEmgVQUT89OUY6TASAmRMsJIjBE0JKksFQy3SDCCosvwLZZ@ASQpMhnDqZS/S9z/HrfhBw)
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 31 bytes
```
ri64md\27md@]"csi"]z{0=},"0i"e|
```
[Try it online!](https://tio.run/##S85KzP3/vyjTzCQ3JcbIPDfFIVYpuThTKbaq2sC2VkfJIFMpteb/f0MDGAAA "CJam – Try It Online")
### Explanation
```
ri                               e# Read an int from input.
  64md                           e# Divmod by 64, gives total #stacks, #items.
      \27md                      e# Divmod total #stacks by 27, gives #chests, #stacks.
           @                     e# Bring #items back to top.
            ]                    e# Wrap in an array: [#chests, #stacks, #items]
             "csi"               e# Push "csi".
                  ]z             e# Zip with the other array.
                    {0=},        e# Filter out subarrays where the first element is 0.
                         "0i"e|  e# Logical or with "0i". An input of 0 gives an empty array
                                 e# from the rest of the program, in that case yield "0i"
                                 e# instead.
```
[Answer]
# [///](https://esolangs.org/wiki////), 179 bytes
```
/|/\/\///b/l0|d/11|x/dddd|sbxxxxxxxx/1sb|cbxxxd1/1cb|bxd/1b|d/2|2222/8|222/6|22/4|21/3|81/9|61/7|41/5|bc/gc|cb/c|bs/gs|sb/s|bi/gi|b|/g/0|mc/m|ms/m|mi/0i|m|/si/s|cs/c|ci/c/mcl0sl0i
```
[Try it online!](https://tio.run/##LYzBDsMwCEM/yaHruu5fdhl0ypCSE5cc/O8ZkfaQjBC2o73j@4k5QbxyAEUrvCDCgSth6PgDCaWt8xKIKXWkUdO9cUtwroUjFTs3wY2n4MlD8OAuuFMN1bICRg3UyHIE1VGdSlQUdkNnjyWO4uxEeJosMmSOfFsr0YrP@QM "/// – Try It Online")
Input is taken in unary `1`s at the end of the program right before the `i`.  
Ex:
```
.../si/s|cs/c|ci/c/mcl0sl0<--input here-->i
```
You can also use an `x` in place of 8 `1`s as a side affect of golfing the program. There is a wrapper for easier testing below.
Testing wrapper:
[Try it online!](https://tio.run/##XVLBcpswED1bX7G32NPUixwncTrtsYfec@xFEjJSA4hqRY1n9O/uCuIkkwXE7ujpvd0H1Cpyli4oEBHK8/0rRNuFf5agt6fW95yovgYalOGUApzDCEb14PthTLzCMYRkI@gwLUg72KiSheQs3PibLTK7EM/OE/D9Z6TENJ2FU1QDQ4HSeDxCCtCpF/tKW4iSpeT7Bqwib6MQvxZBgsS4oj8rvKvfgrbHEN@F4XlJeBJbEwiW0BZUmgGWFcJxThdJPjpXQwxNVF1p6BTiS6m5y/a8FT@nb2IlOcRqeg2xEiv/oTVuauxVPN/CySe3zGmcisTKZZZoh5aNrAswxJobZxkTuiFaoqWRrRAS4AeAhHU9uo2Y5uoAaz36tjjORz41@sbQj522sTCxKb1q2/MGQAi3EFYVrN08qBv7Otp6I9J1h7euHoSR2P@N4IG3YpWSWDnnrjPPDoh56usntX9H1XIbYldovsDdvO4PJWX23d09Hzg5bxw0vvxZ0jzR/pEZyq@R0L0Flw6nD1Hcxgtm/M0Xosa2yjVKmSesOTLpKxIl6WxKWUuURmc9MVAzepd3HHgoL3zgFfd5J/EuHyQ@5QeJj3kv8T5rg41hCjRZEzbE5EhZe2x81hkbrHJnsMsdlcVj5XOXkTyDDPEh45G3TVtRW13YtWLaq2ezZf7yHw "/// – Try It Online")
Ungolfed:
[Try it online!](https://tio.run/##7VM5DsMwDNv1GUZpmqbPKYTCMRBPWvJ7l5Lzhy4hDNOkzsV@fHz/eu8Q8JzQCxR@TOcFKAUtSyvCamEIaIRKIazGzLSZwDYeWJOxBCkepE3xJq2KF2lRPLP4mAzFxhTYaO4oPlaBR1J4FaWOaKxckHs0Q6NqPqhiypyGuL1GNcyR7SupN05hW5Hzxo3/4/p3IrX/AA "/// – Try It Online")
It does 2 divmods, one to separate into chests, stacks, and items, then again to convert to decimal. I could have it convert input from decimal as well, but I would also have to change all of the symbol names and add additional logic to keep it from breaking, so I'm not going to do that. Besides, I think unary is a recognized standard input for ///.
[Answer]
# JavaScript (ES6) 71 bytes
```
n=>[n/1728|0,(n/64|0)%27,n%64].map((a,i)=>a?a+'csi'[i]:'').join``||'0i'
```
**Snippet:**
```
f=
n=>[n/1728|0,(n/64|0)%27,n%64].map((a,i)=>a?a+'csi'[i]:'').join``||'0i'
console.log(f(0)) // 0i
console.log(f(1)) // 1i
console.log(f(2)) // 2i
console.log(f(62)) // 62i
console.log(f(63)) // 63i
console.log(f(64)) // 1s
console.log(f(65)) // 1s1i
console.log(f(66)) // 1s2i
console.log(f(127)) // 1s63i
console.log(f(128)) // 2s
console.log(f(129)) // 2s1i
console.log(f(200)) // 3s8i
console.log(f(512)) // 8s
console.log(f(1337)) // 20s57i
console.log(f(1664)) // 26s
console.log(f(1727)) // 26s63i
console.log(f(1728)) // 1c
console.log(f(1729)) // 1c1i
console.log(f(1791)) // 1c63i
console.log(f(1792)) // 1c1s
console.log(f(1793)) // 1c1s1i
console.log(f(4096)) // 2c10s
console.log(f(5183)) // 2c26s63i
console.log(f(5184)) // 3c
console.log(f(5200)) // 3c16i
console.log(f(9999)) // 5c21s15i
console.log(f(385026)) // 222c22s2i
console.log(f(1000000000)) // 578703c19s
```
[Answer]
# [Python 2](https://docs.python.org/2/), 82 bytes
I converted Gabor Fekete's comment from above into a working example:
```
lambda n:g(n/1728,"c")+g(n/64%27,"s")+g(n%64,"i")or"0i"
g=lambda n,s:(`n`+s)*(n>0)
```
[Try it online!](https://tio.run/##PY7dasMwDIWv56cwBoO9asw/iWMH0hfZBs26pjNsTolzkT19Jnt0gvOB0NGRbj/r55zMPg2v@9f4/f4x0tRfRXrWnfHAzkweSucabjpg@a/lrgEWmZwXpiIj1@G@CbkXp3Q6ZPko0lHJfb3k9TzmSx5eFBANxABxRRbVoFqUwwmmI3xBQJdCd6vRqK0tE1fM@FJX6StDYdCVphJDGxVcWfW2ErfaGhawgFjfKlPOqXu9ETLNC91oTPT/2Z483JaYVsF4pE9HyjPjYoNJbFLK/Rc "Python 2 – Try It Online")
[Answer]
# Batch, ~~347 335 283 246 234 202 199 191~~ 189 bytes
```
@set/al=%1,c=%1/1728,l-=c*1728,s=l/64,l-=s*64
@set c=%c%c
@set s=%s%s
@set i=%l%i
@if %c%==0c set c=
@if %s%==0s set s=
@if %i%==0i set i=
@if %c%%s%%i%.==. set i=0i
@echo(%c%%s%%i%
```
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 76 bytes
```
?dddsf[1728/n99P]sc1728/0<c1728%ddd[64/n115P]si64/0<i[64%n105P]sy64%0<ylf0=y
```
[Try it online!](https://tio.run/##S0n@/98@JSWlOC3a0NzIQj/P0jIgtjgZzDawAdOqQOloMxP9PENDU6BcJpBpYJMJFFHNMzQAiVQCmQY2lTlpBraV//@bGloYAwA "dc – Try It Online")
[Answer]
# [Braingolf](https://github.com/gunnerwolf/braingolf), 71 bytes
```
V"isc"R#@!%>93*!*,>,>!/!*,>,$_-,>,>,/<$_<&,!?_v@R:>|!?_v@R:>|!?_v@R:>|;
```
[Try it online!](https://tio.run/##SypKzMxLz89J@/8/TCmzOFkpSNlBUdXO0lhLUUvHTsdOUR9Mq8Trgng6@jYq8TZqOor28WUOQVZ2NZgM6////1sCAQA "Braingolf – Try It Online")
Not at all golfy, but it works
[Answer]
# Mathematica, 155 bytes
```
A=AppendTo;G={};P=Print;(z=Mod[t=Mod[#,1728],64];If[(x=⌊#/1728⌋)>0,A[G,{x,c}]];If[(y=⌊t/64⌋)>0,A[G,{y,s}]];If[z>0||#==0,A[G,{z,i}]];Row@Flatten@G)&
```
[Answer]
# [PHP](https://php.net/), 84 bytes
```
<?=($c=($a=$argn)/1728^0)?$c.c:"",($s=$a/64%27)?$s.s:"",($i=$a%64)||$c+$s<1?$m.i:"";
```
[Try it online!](https://tio.run/##JcnBCoQgFEDRfZ8hL0gqy5Acpsw/CeQR2aKScdtvz9oetbibc4MPabTBhwzcbz0MU1pKNmR2IjYFIOXM83gjdfeZW24BBX4ZqwqItJpe5Z0mjSK@upHmveLXBVhCHKWFXWz0hpT@x1mjQ7/c "PHP – Try It Online")
# [PHP](https://php.net/), 93 bytes
```
$i-=64*$s=($i-=1728*$c=($i=$argn)/1728^0)/64^0;echo$c?$c.c:"",$s?$s.s:"",$i||$c+$s<1?$i.i:"";
```
[Try it online!](https://tio.run/##HYpBDoMgFAX3PQZ5C7WK2io2RcJNTMyPKWyU@Lde2zUWdzOTCS7E0QYXHpj332rEu1eD0BG@MqorwCZL2A6vTwFKYu4xr1OamrxW3dTohdwGsiBJXyFKsAVLvtEfB@gJHlsLL/2/6RjPdatoJrdc "PHP – Try It Online")
[Answer]
# T-SQL, ~~139 134~~ 139 bytes
Input is stored in column *a* of pre-existing table *t*.
```
SELECT IIF(a=0,'0i',REPLACE(IIF(a<1728,'',STR(a/1728)+'c')
                           +IIF(a%1728<64,'',STR(a%1728/64)+'s')
                           +IIF(a%64=0,'',STR(a%64)+'i'),' ',''))FROM t
```
Line breaks for readability, not counted in byte total.
Tested on MS SQL Server 2012.
**EDIT 1:** Changed multiple `REPLACE` to `IIF` to save 5 bytes. Final `REPLACE` still necessary because `STR` annoyingly pads with spaces to 10 chars.
**EDIT 2:** Fixed to follow the rules by using the approved input type for SQL, [values stored in a named table](https://codegolf.meta.stackexchange.com/a/5341/70172). This cost bytes for the `FROM`, also requires `SELECT` instead of `PRINT`. Recovered 2 bytes by dropping an unnecessary parens.
[Answer]
# PowerShell, 113 Bytes
```
param($i)("$(($c=[math]::floor($i/1728)))c","")[!$c]+("$(($s=[math]::floor(($i%1728)/64)))s","")[!$s]+"$($i%64)i"
```
This hits a bunch of powershell's pain points very precisely.
`[math]::Floor` is required for this as PS does Bankers Rounding by default.
the PS Ternary also takes up a load of bytes compared to other languages, to do a simple null coallescence (`$a="This";$a?$a:"That"` or `"This"?:"That"`) we need to do `(($a="This"),"That")[$a-ne$null]`
then we need to use all of these twice, and also add in another set of brackets in some places due to powershell's default operation order.
[Answer]
# [Python 2](https://docs.python.org/2/), 77 bytes
```
lambda n:''.join(`k`+c for k,c in zip([n/1728,n/64%27,n%64],'csi')if k)or'0i'
```
[Try it online!](https://tio.run/##PY/dbsMgDIWvx1OgSghQ2cpPQqBS9yJdpaZZo9FsJAq5yPbymUHaLJ3vxsfH9vS9fIxRb/3pbftsv27vLY5HSl8eY4jsOlz3He7HGQ@iwyHinzCxczyoRjsRD7YiuhGR2OoiaJcC5aHHAx9nKgPdlntaujbd0@ksBVICaYFslgFVoBpkoQMZAJfhwSXBXSswKmNyx2YzbGwKXaHP9KpQF0JoJb3No84UwlRdwjyUQMbVUud18q8uCOXX1vzY/7FH9DTNIS5sRwJ@fsUk7QhbRc9Wzvn2Cw "Python 2 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 21 bytes
```
d64d1¦27FµTȯ3ịż“csi”$
```
[Try it online!](https://tio.run/##NUwrDgIxEL0M8onOTDttL8AJMGgWAVmHwm0wCK4AFkWyCgVqCQnXoBcpU8HLvCfmfbbrvt/X2qnvaLpynE/3xWeU7@P0fpbhvNptynCZ1dexHG7LWh0IDLUTqIcGqII4GpMxg51DIAaJ2FMtQ7HZsfnRAhQzNeEmAu@yWiFJE4/Q@tkAScGxbbs/fg "Jelly – Try It Online")
Like Jonathan Allan's essentially-the-same answer before it, this does seem too long.
Even more essentially the same:
# [Jelly](https://github.com/DennisMitchell/jelly), 21 bytes
```
d64d1¦27Fż“csi”ẠƇȯ⁾0i
```
[Try it online!](https://tio.run/##NUw5DgIxDPzQFLaTOMkH@AM1S7FoOyq6hWY/ARIVFRI9QhQgEN8gHwlOwcgzhedYLYdhU2unvuPHSeLsdSvjfrHuy3j4Xo/v6XMp2zv19TmV3XleK4EhUDsH9dAAVbBEYzJmCBECC9g5e6plODY7Nj9agGPmJtLEwVNWKyTXxCO0fjbApUBi2/THDw "Jelly – Try It Online")
]