tidal-autotechno/test.tidal

some seeds I've liked:
1493546251137461290
1781197463452869364
14959707246264745
1411204103099713935
1157315305561367902
2275918688827233254
2209526836267835322 -- electro-ish
644793890351458335
803051260356546356
1061676950143263647
1726268759940563490
1035561506162950173 -- groovy
231920015948102138 -- funky
7138151558308434562 -- funky
2154183685935315319 -- vaguely arabic
1880041842519425526
1014891741240181557 -- pretty funky
850750894594826640 -- great if the kick is t(3,8) instead of t(3,4)
2195224328517994763 -- funnnnkkky
0x508DFAD3954D1C9 -- cooool
seed: -2138151558308434562
82408580741001929 -- cool bassline

setcps = (18/60/4)

bpm (100/60/4)

setcps (130/60/4)

hush

p "techno"
$ whenmod 8 7 (scramble 4)
$ stack [
      -- four to the floor
      (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
      -- kick -----------------
      degradeBy 0
      $ every 3 (("1/4" ~>))
      $ every 4 (rev)
      $ struct "{1011000101001100}%16"
      $ n 0 # midichan 0,
      -- hh -----------------
      degradeBy 0
      $ every 10 (bite 8 "{4*4 7*1 2*2 4*4 0*4 7*1 4*2 8*1 3*1 3*1 1*1 8*1 1*4 4*2 }%8")
      $ struct "[t(15,16)]"
      $ n 0 # midichan 1,
      -- sd -----------------
      degradeBy 0
      $ struct "[~ t]*2"
      $ n 0 # midichan 2,
      -- cp -----------------
      degradeBy 0
      $ struct "[t(6,16)]"
      $ n 0 # midichan 3,
      -- ? -----------------
      degradeBy 0
      $ every 6 (("1/4" ~>))
      $ struct "{0100000000000001}%16"
      $ n 0 # midichan 4,
      -----------------------
      degradeBy 0
      $ struct "{0111111110111011}%16"
      $ n "{28 15 3 6 21 21 22 16 2 34 9 6 0 35 23 28 }%16"
      # midichan 7 + n (-36)
] # sunvox

hush


-- seed: -1128205447549990176
cps = (98/60/4)

p "techno"
$ whenmod 8 7 (scramble 4)
$ stack [
      -- four to the floor
      (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
      -- kick -----------------
      $ every 5 (stut 3 1 "1/4")
      $ every 2 (rev)
      $ every 2 (rev)
      $ struct "[t t t t*2]"
      $ n 0 # midichan 0,
] # sunvox

d1 $ s "bd"

hush

-- seed: 319200159481021387
setcps  (94/60/4)

p "techno"
$ whenmod 8 7 (scramble 4)
$ stack [
      -- four to the floor
      (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
      -- kick -----------------
      degradeBy 0
      $ every 8 (rev)
      $ every 9 (rev)
      $ every 5 (stut 2 1 "1/4")
      $ struct "{0000000011100100}%16"
      $ n 0 # midichan 0,
      -- hh -----------------
      degradeBy 0
      $ struct "[t(3,4)]"
      $ n 0 # midichan 1,
      -- sd -----------------
      degradeBy 0
      $ every 12 (rev)
      $ every 13 (rev)
      $ struct "{0000101001001011}%16"
      $ n 0 # midichan 2,
      -- cp -----------------
      degradeBy 0
      $ every 13 (stut 2 1 "1/4")
      $ struct "{0101101100111111}%16"
      $ n 0 # midichan 3,
      -- ? -----------------
      degradeBy 0
      $ every 13 (scramble 16)
      $ every 14 (("1/8" ~>))
      $ every 9 (bite 4 "{1*1 4*1 4*4 3*1 0*1 1*2 4*4 4*1 3*1 3*4 3*4 1*1 }%4")
      $ struct "[<t~~~>~~~]"
      $ n 0 # midichan 4,
      -----------------------
      degradeBy 0
      $ struct "{1100101001010010}%16"
      $ n "{0 7 3 2 3 1 20 11 6 17 5 6 20 16 20 6 }%16"
      # midichan 7 + n (-36)
] # sunvox

hush


-- seed: -1054995728480467182
cps = (123/60/4)

p "techno"
$ whenmod 8 7 (scramble 4)
$ stack [
      -- four to the floor
      (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
      -- kick -----------------
      degradeBy 0
      $ (0.125 ~>)
      $ struct "[t~~~ ~~<~t~~>~ ~~t~ ~<~t>~~]"
      $ n 0 # midichan 0,
      -- hh -----------------
      degradeBy 0
      $ struct "[t*16]"
      $ n 0 # midichan 1,
      -- sd -----------------
      degradeBy 0
      $ (0.1875 ~>)
      $ struct "[[~~~t][~t]]*2"
      $ n 0 # midichan 2,
      -- cp -----------------
      degradeBy 0
      $ struct "[t(3,8)]"
      $ n 0 # midichan 3,
      -- ? -----------------
      degradeBy 0
      $ struct "[t*8]"
      $ n 0 # midichan 4,
      -----------------------
      degradeBy 0
      $ struct "{0111111111101100}%16"
      $ n "{33 14 2 25 10 23 4 11 11 1 25 7 10 6 8 33 }%16"
      # midichan 7 + n (-36)

] # sunvox

hush


do
setcps (120)
let something = "hello"
d1 $ s "bd"


-- seed: 2104142091522455394
-- generated at 1633463772.53

hush
-- seed: 197507295067074279
-- generated at 1633463837.81

-- seed: 485348289655373702
-- generated at 1633463949.6
-- seed: -1703565451078464692
-- generated at 1633464313.44

do
p "techno"
$ whenmod 2 1 (bite 4 "0 0 0 4")
$ stack [
      -- four to the floor
      (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
      -- kick -----------------
      degradeBy 0
      $ every 8 (scramble 16)
      $ every 10 ((0.1875 ~>))
      $ every 14 (rev)
      $ struct "[t*4]"
      $ n 0 # midichan 0,
      -- hh -----------------
      degradeBy 0
      $ struct "[t(4,8)]"
      $ n 0 # midichan 1,
      -- sd -----------------
      degradeBy 0
      $ struct "[t(4,8)]"
      $ n 0 # midichan 2,
      -- cp -----------------
      degradeBy 0
      $ struct "{0010000000000000}%16"
      $ n 0 # midichan 3,
      -- ? -----------------
      degradeBy 0
      $ struct "{0000100010000000}%16"
      $ n 0 # midichan 4,
      -----------------------
      degradeBy 0
      $ struct "{1111101101111110}%16"
      $ n "{20 20 1 0 10 8 5 8 25 0 9 23 21 30 8 9 }%8"
      # midichan 7 + n (-36)
] # sunvox
-- seed: 563969774834715115
-- generated at 1633465467.85



-- seed: 456859454801594881
-- generated at 1633467293.87
hush






do
        let hello = "[t*8]"
        p "techno" $ stack [
        struct hello $ s "bd"
                        ]

-- seed: 315014084723179620
-- generated at 1633467476.05


hush
-- seed: 412835948404765370
-- generated at 1633467827.68

do
let kickM = "[1]"
let hhM = "[0111]"
let sdM = "[1100]"
let cpM = "[1110]"
let fiveM = "[1011]"
let sixM = "[1100]"
let basslineM = "[1011]"
let eightM = "[1000]"
let nineM = "[1000]"
p "techno"
$ whenmod 32 31 (bite 4 "{2*2 2*1 1*4 3*4 2*4 2*1 1*1 3*2 }%4")
$ whenmod 16 15 (stut 3 1 "1/16")
$ whenmod 8 7 (scramble 16)
$ whenmod 16 15 (stut 1 1 "1/16")
$ whenmod 32 31 (scramble 16)
$ whenmod 16 15 (scramble 4)
$ stack [
        -- four to the floor
        (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
        -- kick -----------------
        mask "[0]"
        $ (0.1875 ~>)
        $ struct "{1011000100100100}%16"
        $ n 0 # midichan 0,
        -- hh -----------------
        mask hhM
        $ (0.1875 ~>)
        $ struct "t*16"
        $ n 0 # midichan 1,
        -- sd -----------------
        mask sdM
        $ every 12 (rev)
        $ every 2 (bite 4 "{2*1 0*2 4*2 1*1 }%4")
        $ every 7 (rev)
        $ (0.125 ~>)
        $ struct "t*16"
        $ n 0 # midichan 2,
        -- cp -----------------
        mask cpM
        $ (0.1875 ~>)
        $ struct "[t(2,4)]"
        $ n 0 # midichan 3,
        -- five -----------------
        mask fiveM
        $ struct "{1010010001001000}%16"
        $ n 0 # midichan 4,
        -- six -----------------
        mask sixM
        $ struct "t*16"
        $ n 0 # midichan 5,
        -- bassline -----------------
        mask basslineM
        $ struct "t*16"
        $ n 0 # midichan 6,
        -- eight -----------------
        mask eightM
        $ (0.1875 ~>)
        $ struct "[t(11,16)]"
        $ n 0 # midichan 7,
        -- nine -----------------
        mask nineM
        $ (0.125 ~>)
        $ struct "{0010001011101101}%16"
        $ n 0 # midichan 8,
        -----------------------
        degradeBy 0
        $ struct "{1110100111101110}%16"
        $ n "{8 18 18 34 8 34 0 17 13 3 4 7 4 17 1 0 }%16"
        # midichan 7 + n (-36)
] # sunvox



-- seed: -944805744933000927
-- generated at 1633468178.51

-- seed: -639917386321814739
-- generated at 1633468248.95

do
let kickM = "[0001]"
let hhM = "[0001]"
let sdM = "[1110]"
let cpM = "[0010]"
let fiveM = "[0111]"
let sixM = "[0011]"
let basslineM = "[0011]"
let eightM = "[1110]"
let nineM = "[1001]"
  p "techno"
  $ whenmod 16 15 (scramble 8)
  $ whenmod 16 15 (bite 4 "{1*2 1*4 1*2 2*4 0*2 4*2 0*1 2*1 2*2 3*4 3*2 1*4 }%4")
  $ whenmod 8 7 (stut 4 1 "1/16")
  $ whenmod 4 3 (scramble 8)
  $ stack [
    -- four to the floor
    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
    -- kick -----------------
    mask kickM
    $ struct "t*16"
    $ n 0 # midichan 0,
    -- hh -----------------
    mask hhM
    $ (0.1875 ~>)
    $ struct "[t(7,8)]"
    $ n 0 # midichan 1,
    -- sd -----------------
    mask sdM
    $ (0.125 ~>)
    $ struct "{1011011100011100}%16"
    $ n 0 # midichan 2,
    -- cp -----------------
    mask cpM
    $ (0.125 ~>)
    $ struct "[t(15,16)]"
    $ n 0 # midichan 3,
    -- five -----------------
    mask fiveM
    $ struct "t*16"
    $ n 0 # midichan 4,
    -- six -----------------
    mask sixM
    $ every 13 (stut 2 1 "1/16")
    $ every 5 (rev)
    $ every 9 ((0.1875 ~>))
    $ (0.1875 ~>)
    $ struct "{0111100111000101}%16"
    $ n 0 # midichan 5,
    -- bassline -----------------
    mask basslineM
    $ (0.125 ~>)
    $ struct "t*16"
    $ n 0 # midichan 6,
    -- eight -----------------
    mask eightM
    $ every 10 (stut 2 1 "1/16")
    $ every 15 ((0.1875 ~>))
    $ struct "t*16"
    $ n 0 # midichan 7,
    -- nine -----------------
    mask nineM
    $ struct "[t(3,4)]"
    $ n 0 # midichan 8,
    -----------------------
    degradeBy 0
    $ struct "{0001100111101001}%16"
    $ n "{4 21 12 15 2 16 5 22 8 20 4 8 1 23 14 27 }%8"
    # midichan 7 + n (-36)
  ] # sunvox


-- seed: -1022362753540599887
-- generated at 1633468290.41

do
let kickM = "[1101]"
let hhM = "[1001]"
let sdM = "[1110]"
let cpM = "[0111]"
let fiveM = "[1010]"
let sixM = "[1100]"
let basslineM = "[1110]"
let eightM = "[1100]"
let nineM = "[1000]"
Traceback (most recent call last):
  File "/home/chris/tidal-auto-techno/auto-techno.py", line 313, in <module>
    print(+"p \""+stackName+"\" ")
TypeError: bad operand type for unary +: 'str'


-- seed: -1667571548371307357
-- generated at 1633468363.94

hush
-- seed: -1728339397765061981
-- generated at 1633468433.83

do
let kickM = "[1111]"
let hhM = "[1111]"
let sdM = "[1111]"
let cpM = "[1111]"
let fiveM = "[1111]"
let sixM = "[1111]"
let basslineM = "[1111]"
let eightM = "[1111]"
let nineM = "[1111]"
p "techno"
  $ whenmod 16 14 (scramble 4)
  $ whenmod 16 15 (bite 4 "{2*1 4*4 1*1 1*4 3*2 0*2 4*2 2*1 }%4")
  $ stack [
    -- four to the floor
    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
    -- kick -----------------
    mask kickM
    $ (0.1875 ~>)
    $ struct "[t(4,8)]"
    $ n 0 # midichan 0,
    -- hh -----------------
    mask hhM
    $ every 14 (rev)
    $ every 15 (bite 4 "{0*4 2*4 4*2 2*4 2*2 1*1 4*2 0*2 1*2 4*4 3*1 2*1 2*1 0*1 0*2 0*4 }%4")
    $ every 6 (stut 1 1 "1/16")
    $ (0.1875 ~>)
    $ struct "{0001000000000000}%16"
    $ n 0 # midichan 1,
    -- sd -----------------
    mask sdM
    $ (0.125 ~>)
    $ struct "t*16"
    $ n 0 # midichan 2,
    -- cp -----------------
    mask cpM
    $ (0.1875 ~>)
    $ struct "[t(5,16)]"
    $ n 0 # midichan 3,
    -- five -----------------
    mask fiveM
    $ struct "{0101010100000101}%16"
    $ n 0 # midichan 4,
    -- six -----------------
    mask sixM
    $ struct "{1101001011110010}%16"
    $ n 0 # midichan 5,
    -- bassline -----------------
    mask basslineM
    $ struct "[t(2,4)]"
    $ n 0 # midichan 6,
    -- eight -----------------
    mask eightM
    $ every 14 (scramble 8)
    $ struct "[t(7,8)]"
    $ n 0 # midichan 7,
    -- nine -----------------
    mask nineM
    $ struct "{0010000000000000}%16"
    $ n 0 # midichan 8,
    -----------------------
    degradeBy 0
    $ struct "{0110110101100110}%16"
    $ n "{19 0 15 19 15 19 14 34 23 0 5 10 13 23 17 16 }%16"
    # midichan 7 + n (-36)
  ] # sunvox


-- seed: -925754403333800332
-- generated at 1633468492.63

do
let kickM = "[1111]"
let hhM = "[1111]"
let sdM = "[1111]"
let cpM = "[1111]"
let fiveM = "[1111]"
let sixM = "[1111]"
let basslineM = "[1111]"
let eightM = "[1111]"
let nineM = "[1111]"
p "techno"
$ whenmod 8 7 (scramble 16)
$ whenmod 16 15 (rev)
$ whenmod 16 15 (stut 3 1 "1/16")
$ whenmod 16 15 (bite 4 "{4*1 3*4 0*4 4*1 3*1 1*1 2*2 0*4 3*4 }%4")
$ whenmod 32 31 (scramble 8)
  $ stack [
    -- four to the floor
    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
    -- kick -----------------
    mask kickM
    $ struct "[t(3,4)]"
    $ n 0 # midichan 0,
    -- hh -----------------
    mask hhM
  $ every 13 (stut 1 1 "1/8")
  $ every 5 (bite 8 "{2*4 7*4 6*2 5*2 2*4 2*2 8*1 2*1 0*1 6*1 1*2 5*1 0*2 6*2 7*2 6*2 }%8")
    $ struct "[t(2,4)]"
    $ n 0 # midichan 1,
    -- sd -----------------
    mask sdM
    $ (0.125 ~>)
    $ struct "[t(6,8)]"
    $ n 0 # midichan 2,
    -- cp -----------------
    mask cpM
    $ struct "t*16"
    $ n 0 # midichan 3,
    -- five -----------------
    mask fiveM
    $ (0.1875 ~>)
    $ struct "[t(4,8)]"
    $ n 0 # midichan 4,
    -- six -----------------
    mask sixM
    $ struct "t*16"
    $ n 0 # midichan 5,
    -- bassline -----------------
    mask basslineM
    $ struct "[t(9,16)]"
    $ n 0 # midichan 6,
    -- eight -----------------
    mask eightM
    $ (0.1875 ~>)
    $ struct "[t(2,16)]"
    $ n 0 # midichan 7,
    -- nine -----------------
    mask nineM
    $ (0.125 ~>)
    $ struct "t*16"
    $ n 0 # midichan 8,
    -----------------------
    degradeBy 0
    $ struct "{0011101101100110}%16"
    $ n "{8 34 9 4 9 0 10 15 30 7 29 18 18 20 19 27 }%8"
    # midichan 7 + n (-36)
  ] # sunvox


-- seed: -296151779328239296
-- generated at 1633468506.28

do
let kickM = "[1111]"
let hhM = "[1111]"
let sdM = "[1111]"
let cpM = "[1111]"
let fiveM = "[1111]"
let sixM = "[1111]"
let basslineM = "[1111]"
let eightM = "[1111]"
let nineM = "[1111]"
p "techno"
$ whenmod 8 7 (scramble 8)
$ whenmod 32 31 (scramble 4)
$ whenmod 4 3 (scramble 8)
$ whenmod 8 7 (bite 8 "{0*2 6*1 8*2 2*1 8*2 7*1 6*1 2*1 3*4 }%8")
$ whenmod 16 15 (stut 2 1 "1/16")
$ whenmod 8 7 (rev)
  $ stack [
    -- four to the floor
    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
    -- kick -----------------
    mask kickM
    $ (0.1875 ~>)
    $ struct "t*16"
    $ n 0 # midichan 0,
    -- hh -----------------
    mask hhM
  $ every 9 (bite 8 "{1*4 3*4 3*1 5*2 5*1 3*4 8*2 3*2 7*2 4*4 6*4 6*2 7*2 0*2 0*4 }%8")
    $ (0.1875 ~>)
    $ struct "{1111001000001110}%16"
    $ n 0 # midichan 1,
    -- sd -----------------
    mask sdM
    $ struct "[t(12,16)]"
    $ n 0 # midichan 2,
    -- cp -----------------
    mask cpM
    $ (0.125 ~>)
    $ struct "[t(15,16)]"
    $ n 0 # midichan 3,
    -- five -----------------
    mask fiveM
    $ (0.125 ~>)
    $ struct "t*16"
    $ n 0 # midichan 4,
    -- six -----------------
    mask sixM
    $ (0.125 ~>)
    $ struct "[t(2,8)]"
    $ n 0 # midichan 5,
    -- bassline -----------------
    mask basslineM
    $ struct "[t(7,16)]"
    $ n 0 # midichan 6,
    -- eight -----------------
    mask eightM
    $ struct "t*16"
    $ n 0 # midichan 7,
    -- nine -----------------
    mask nineM
    $ struct "t*16"
    $ n 0 # midichan 8,
    -----------------------
    degradeBy 0
    $ struct "{0101010011101010}%16"
    $ n "{0 8 0 6 10 8 6 9 4 18 6 4 1 6 35 30 }%8"
    # midichan 7 + n (-36)
  ] # sunvox


-- seed: -863274151192537696

-- generated at 1633468522.75jjjjjjjjjjjjjjjjjjjjjjjG

do
let kickM = "[0000]"
let hhM = "[0000]"
let sdM = "[0000]"
let cpM = "[0000]"
let fiveM = "[0000]"
let sixM = "[0000]"
let basslineM = "[0000]"
let eightM = "[0000]"
let nineM = "[0000]"
p "techno"
$ whenmod 4 3 (scramble 4)
$ whenmod 16 14 (bite 8 "{7*4 1*2 7*4 8*2 4*2 5*2 2*4 0*2 7*1 8*4 4*4 1*1 7*2 5*1 2*2 }%8")
$ whenmod 32 31 (stut 3 1 "1/16")
$ whenmod 16 15 (stut 1 1 "1/16")
$ whenmod 8 7 (rev)
$ whenmod 32 31 (stut 1 1 "1/16")
  $ stack [
    -- four to the floor
    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
    -- kick -----------------
    mask kickM
    $ struct "t*16"
    $ n 0 # midichan 0,
    -- hh -----------------
    mask hhM
    $ struct "{0001100001001011}%16"
    $ n 0 # midichan 1,
    -- sd -----------------
    mask sdM
    $ (0.125 ~>)
    $ struct "{0000000010000000}%16"
    $ n 0 # midichan 2,
    -- cp -----------------
    mask cpM
    $ (0.1875 ~>)
    $ struct "[t(3,4)]"
    $ n 0 # midichan 3,
    -- five -----------------
    mask fiveM
    $ struct "[t(14,16)]"
    $ n 0 # midichan 4,
    -- six -----------------
    mask sixM
  $ every 4 (scramble 8)
  $ every 12 (rev)
    $ struct "{1011110000111001}%16"
    $ n 0 # midichan 5,
    -- bassline -----------------
    mask basslineM
    $ (0.125 ~>)
    $ struct "[t(2,4)]"
    $ n 0 # midichan 6,
    -- eight -----------------
    mask eightM
    $ struct "[t(7,8)]"
    $ n 0 # midichan 7,
    -- nine -----------------
    mask nineM
    $ struct "{0010000000000100}%16"
    $ n 0 # midichan 8,
    -----------------------
    degradeBy 0
    $ struct "{0111001111011110}%16"
    $ n "{1 5 26 24 6 4 35 21 5 8 30 11 6 1 15 5 }%16"
    # midichan 7 + n (-36)
  ] # sunvox

-- seed: -1900899368135846569
-- generated at 1633468554.75

do
let kickM = "[0]"
let hhM = "[1111]"
let sdM = "[1111]"
let cpM = "[1111]"
let fiveM = "[1111]"
let sixM = "[1111]"
let basslineM = "[1111]"
let eightM = "[1111]"
let nineM = "[1111]"
p "techno"
$ whenmod 16 15 (stut 1 1 "1/16")
$ whenmod 8 7 (scramble 16)
$ whenmod 4 3 (scramble 8)
$ whenmod 4 3 (scramble 8)
$ whenmod 32 31 (rev)
  $ stack [
    -- four to the floor
    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
    -- kick -----------------
    mask kickM
  $ every 9 (stut 3 1 "1/8")
    $ struct "{1000101110111001}%16"
    $ n 0 # midichan 0,
    -- hh -----------------
    mask hhM
    $ struct "{0000000000000000}%16"
    $ n 0 # midichan 1,
    -- sd -----------------
    mask sdM
  $ every 8 (bite 4 "{2*1 4*2 0*1 3*2 3*4 0*4 0*4 }%4")
  $ every 4 (bite 4 "{2*1 4*2 0*1 3*2 3*4 0*4 0*4 }%4")
    $ (0.125 ~>)
    $ struct "[t(3,4)]"
    $ n 0 # midichan 2,
    -- cp -----------------
    mask cpM
  $ every 5 ((0.125 ~>))
  $ every 16 ((0.125 ~>))
    $ struct "{0000010000000101}%16"
    $ n 0 # midichan 3,
    -- five -----------------
    mask fiveM
    $ struct "{0000000000000100}%16"
    $ n 0 # midichan 4,
    -- six -----------------
    mask sixM
  $ every 5 (scramble 4)
    $ struct "t*4"
    $ n 0 # midichan 5,
    -- bassline -----------------
    mask basslineM
    $ struct "[t(5,8)]"
    $ n 0 # midichan 6,
    -- eight -----------------
    mask eightM
    $ struct "t*4"
    $ n 0 # midichan 7,
    -- nine -----------------
    mask nineM
    $ struct "t*4"
    $ n 0 # midichan 8,
    -----------------------
    degradeBy 0
    $ struct "{0111111111111111}%16"
    $ n "{5 9 6 7 6 22 22 22 13 2 3 7 10 16 24 8 }%16"
    # midichan 7 + n (-36)
  ] # sunvox


-- seed: 221325860405508199
-- generated at 1633468703.57

do
let kickM = "[0]"
let hhM = "[1111]"
let sdM = "[1111]"
let cpM = "[1111]"
let fiveM = "[1111]"
let sixM = "[1111]"
let basslineM = "[1111]"
let eightM = "[1111]"
let nineM = "[1111]"
p "techno"
$ whenmod 4 3 (bite 8 "{8*2 4*4 1*2 3*4 5*4 5*4 4*2 5*1 6*1 7*4 }%8")
$ whenmod 16 14 (bite 8 "{2*2 3*2 0*1 5*2 }%8")
$ whenmod 8 7 (stut 4 1 "1/16")
$ whenmod 16 14 (scramble 8)
$ whenmod 4 3 (bite 4 "{1*2 1*1 1*1 1*4 3*2 3*2 1*2 4*4 3*2 3*4 2*4 }%4")
$ stack [
    -- four to the floor
    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
    -- kick -----------------
    mask kickM
    $ struct "[t(14,16)]"
    $ n 0 # midichan 0,
    -- hh -----------------
    mask hhM
  $ every 3 (scramble 4)
    $ struct "{1000100000001010}%16"
    $ n 0 # midichan 1,
    -- sd -----------------
    mask sdM
  $ every 12 (bite 4 "{2*4 1*1 3*1 3*2 0*2 4*2 }%4")
  $ every 10 (scramble 4)
    $ struct "{0000101000000010}%16"
    $ n 0 # midichan 2,
    -- cp -----------------
    mask cpM
    $ struct "[t(3,4)]"
    $ n 0 # midichan 3,
    -- five -----------------
    mask fiveM
    $ (0.1875 ~>)
    $ struct "{0000000000000100}%16"
    $ n 0 # midichan 4,
    -- six -----------------
    mask sixM
    $ struct "{0000000001000110}%16"
    $ n 0 # midichan 5,
    -- bassline -----------------
    mask basslineM
    $ struct "{0101011011010001}%16"
    $ n 0 # midichan 6,
    -- eight -----------------
    mask eightM
    $ struct "{0011111011101100}%16"
    $ n 0 # midichan 7,
    -- nine -----------------
    mask nineM
  $ every 11 (stut 1 1 "1/16")
    $ (0.125 ~>)
    $ struct "{0110010001110101}%16"
    $ n 0 # midichan 8,
    -----------------------
    degradeBy 0
    $ struct "{0011101011110111}%16"
    $ n "{8 19 11 33 8 8 10 18 2 8 3 2 17 8 8 1 }%8"
    # midichan 7 + n (-36)
  ] # sunvox


hush


do
  let masky = "[0]"
  p "techno"
    $ whenmod 8 7 (fast 2)
    $ stack [
    mask masky
    $ s "bd*16"
                     ]
-- seed: -844672810981675420
-- generated at 1633469145.73

do
  let kickM = "[1111]"
  let hhM = "[1111]"
  let sdM = "[1111]"
  let cpM = "[1111]"
  let fiveM = "[1111]"
  let sixM = "[1111]"
  let basslineM = "[1111]"
  let eightM = "[1111]"
  let nineM = "[1111]"
  p "techno"
    $ whenmod 32 31 (scramble 4)
    $ whenmod 32 31 (scramble 4)
    $ whenmod 16 14 (bite 4 "{3*4 2*1 0*1 0*1 1*2 3*2 2*4 2*1 3*4 2*1 4*1 0*1 0*2 4*4 4*2 3*1 }%4")
    $ stack [
    -- four to the floor
    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
    -- kick -----------------
    mask kickM
    $ (0.125 ~>)
    $ struct "t*4"
    $ n 0 # midichan 0,
    -- hh -----------------
    mask hhM
    $ every 9 (stut 2 1 "1/4")
    $ every 4 (bite 4 "{4*2 4*2 2*2 4*4 1*1 2*1 2*4 0*4 3*2 0*4 3*1 0*1 3*2 1*2 }%4")
    $ struct "t*4"
    $ n 0 # midichan 1,
    -- sd -----------------
    mask sdM
    $ (0.1875 ~>)
    $ struct "{0011010110101101}%16"
    $ n 0 # midichan 2,
    -- cp -----------------
    mask cpM
    $ struct "[t(7,8)]"
    $ n 0 # midichan 3,
    -- five -----------------
    mask fiveM
    $ (0.125 ~>)
    $ struct "{0000000000000001}%16"
    $ n 0 # midichan 4,
    -- six -----------------
    mask sixM
    $ struct "t*4"
    $ n 0 # midichan 5,
    -- bassline -----------------
    mask basslineM
    $ (0.125 ~>)
    $ struct "t*4"
    $ n 0 # midichan 6,
    -- eight -----------------
    mask eightM
    $ struct "t*4"
    $ n 0 # midichan 7,
    -- nine -----------------
    mask nineM
    $ struct "[t(4,8)]"
    $ n 0 # midichan 8,
    -----------------------
    degradeBy 0
    $ struct "{0111101111101011}%16"
    $ n "{17 2 23 15 29 35 8 20 5 19 2 9 34 2 1 5 }%8"
    # midichan 7 + n (-36)



    ] # sunvox



-- seed: 2235447325725207626
-- generated at 1633469239.66

do
  let kickM = "[1111]"
  let hhM = "[1111]"
  let sdM = "[1111]"
  let cpM = "[1111]"
  let fiveM = "[1111]"
  let sixM = "[1111]"
  let basslineM = "[1111]"
  let eightM = "[1111]"
  let nineM = "[1111]"
  p "techno"
    $ whenmod 16 15 (scramble 16)
    $ whenmod 4 3 (stut 4 1 "1/16")
    $ whenmod 32 31 (rev)
    $ whenmod 16 14 (stut 3 1 "1/4")
    $ whenmod 16 15 (scramble 16)
    $ stack [
    -- four to the floor
    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
    -- kick -----------------
    mask kickM
    $ (0.125 ~>)
    $ struct "[t(2,16)]"
    $ n 0 # midichan 0,
    -- hh -----------------
    mask hhM
    $ struct "[t(2,4)]"
    $ n 0 # midichan 1,
    -- sd -----------------
    mask sdM
    $ struct "[t(9,16)]"
    $ n 0 # midichan 2,
    -- cp -----------------
    mask cpM
    $ struct "[t(2,4)]"
    $ n 0 # midichan 3,
    -- five -----------------
    mask fiveM
    $ (0.125 ~>)
    $ struct "[t(2,4)]"
    $ n 0 # midichan 4,
    -- six -----------------
    mask sixM
    $ every 9 (scramble 8)
    $ struct "{1100101000001100}%16"
    $ n 0 # midichan 5,
    -- bassline -----------------
    mask basslineM
    $ struct "[t(11,16)]"
    $ n 0 # midichan 6,
    -- eight -----------------
    mask eightM
    $ every 4 ((0.1875 ~>))
    $ every 4 ((0.1875 ~>))
    $ every 13 ((0.1875 ~>))
    $ (0.1875 ~>)
    $ struct "[t(3,4)]"
    $ n 0 # midichan 7,
    -- nine -----------------
    mask nineM
    $ every 2 (scramble 8)
    $ struct "t*4"
    $ n 0 # midichan 8,
    -----------------------
    degradeBy 0
    $ struct "{0010100101000001}%16"
    $ n "{9 4 9 4 18 18 8 13 11 8 0 5 5 12 1 21 }%16"
    # midichan 7 + n (-36)
    ] # sunvox

-- seed: 590111300892224819
-- generated at 1633469475.43

do
  let kickM = "[1111]"
  let hhM = "[1111]"
  let sdM = "[1111]"
  let cpM = "[100]"
  let fiveM = "[1111]"
  p "techno"
    $ whenmod 32 31 (rev)
    $ whenmod 16 14 (stut 4 1 "1/16")
    $ whenmod 8 7 (scramble 16)
    $ stack [
    -- four to the floor
    (#gain 1) $ struct "[t*4]" $ n "0" # midichan 0,
    -- kick -----------------
    mask kickM
    $ (0.1875 ~>)
    $ struct "[t(3,4)]"
    $ n 0 # midichan 0,
    -- hh -----------------
    mask hhM
    $ struct "[t(3,4)]"
    $ n 0 # midichan 1,
    -- sd -----------------
    mask sdM
    $ struct "{0000000010000000}%16"
    $ n 0 # midichan 2,
    -- cp -----------------
    mask cpM
    $ struct "[t(10,16)]"
    $ n 0 # midichan 3,
    -- five -----------------
    mask fiveM
    $ struct "[t(7,8)]"
    $ n 0 # midichan 4,
    -----------------------
    degradeBy 0
    $ struct "{0100101101100010}%16"
    $ n "{15 3 21 25 5 7 3 2 15 7 13 3 0 3 13 10 }%16"
    # midichan 7 + n (-36)
    ] # sunvox
utouto


-- seed: 493703295080029503
-- generated at 1633469804.11

do
  let kickM = "[1111]"
  let hhM = "[1111]"
  let sdM = "[1111]"
  let cpM = "[1111]"
  let fiveM = "[1111]"
  p "techno"
    $ whenmod 8 7 (rev)
    $ whenmod 4 3 (stut 4  1 0.125)
    $ whenmod 32 31 (scramble 16)
    $ stack [
    -- four to the floor
    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
    -- kick -----------------
    mask kickM
    $ (0.125 ~>)
    $ struct "t*4"
    $ n 0 # midichan 0,
    -- hh -----------------
    mask hhM
    $ struct "{1000011101010000}%16"
    $ n 0 # midichan 1,
    -- sd -----------------
    mask sdM
    $ (0.1875 ~>)
    $ struct "t*4"
    $ n 0 # midichan 2,
    -- cp -----------------
    mask cpM
    $ every 13 (scramble 4)
    $ struct "[t(7,8)]"
    $ n 0 # midichan 3,
    -- five -----------------
    mask fiveM
    $ (0.1875 ~>)
    $ struct "t*4"
    $ n 0 # midichan 4,
    -----------------------
    degradeBy 0
    $ struct "{1111100110011111}%16"
    $ n "{11 7 5 10 15 7 0 24 5 14 11 11 0 20 22 24 }%16"
    # midichan 7 + n (-36)
    ] # sunvox

hush


hush