diff --git a/compact_sets_extended_simplified.ipynb b/compact_sets_extended_simplified.ipynb
index 1fceb12..2077fab 100644
--- a/compact_sets_extended_simplified.ipynb
+++ b/compact_sets_extended_simplified.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 89,
    "id": "806f6f69-1e0b-4d34-aac9-695c8531cdb1",
    "metadata": {},
    "outputs": [],
@@ -79,7 +79,7 @@
     "def edges(chords, min_symdiff, max_symdiff, max_chord_size):  \n",
     "\n",
     "    def reverse_movements(movements):\n",
-    "        return {value['destination']:{'destination':key, 'cent_difference':value['cent_difference']} for key, value in movements.items()}\n",
+    "        return {value['destination']:{'destination':key, 'cent_difference':value['cent_difference'] * -1} for key, value in movements.items()}\n",
     "\n",
     "    def is_directly_tunable(intersection, diff):\n",
     "        # this only works for now when intersection if one element - need to fix that\n",
@@ -166,7 +166,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 214,
    "id": "4e3ef738-7f64-47c3-9129-0450fd031375",
    "metadata": {},
    "outputs": [],
@@ -180,17 +180,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 215,
    "id": "aea5215c-8551-4685-b761-11c2dc74cf22",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "144"
+       "260"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 215,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -198,6 +198,7 @@
    "source": [
     "from random import choice, choices\n",
     "\n",
+    "# This is for the static version\n",
     "def stochastic_hamiltonian(graph):\n",
     "        \n",
     "    def movement_size_weights(edges):\n",
@@ -245,10 +246,12 @@
     "\n",
     "        for e in edges:\n",
     "            yield 10 if not has_voice_crossing(e) else 0\n",
+    "\n",
+    "    def is_bass_rooted(chord):\n",
+    "        return max([sum(abs(p) for p in collapse_pitch(pitch_difference(chord[0], p))) for p in chord[1:]]) == 1\n",
     "        \n",
     "    check_graph = graph.copy()\n",
-    "    #next_node = choice(list(graph.nodes()))\n",
-    "    next_node = list(graph.nodes())[0]\n",
+    "    next_node = choice([node for node in graph.nodes() if is_bass_rooted(node)])\n",
     "    check_graph.remove_node(next_node)\n",
     "    for node in graph.nodes(data=True):\n",
     "        node[1]['count'] = 1\n",
@@ -280,6 +283,30 @@
     "len(path)"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "ac9e15be-5495-405c-9ce4-ae40d97c7814",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[]"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def is_super_compact(chord):\n",
+    "    return max([sum(abs(p) for p in collapse_pitch(pitch_difference(c[0], c[1]))) for c in combinations(chord, 2)]) == 1\n",
+    "        \n",
+    "[node for node in graph.nodes() if is_super_compact(node)]"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 11,
@@ -372,6 +399,189 @@
    "source": [
     "lprun -f edge_data edges(chord_set, 3, 3, 4)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 180,
+   "id": "a76dc0f3-02e2-4739-9014-b53d3a590e3d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dims = (2, 3, 5, 7, 11)\n",
+    "root = (0, 0, 0, 0, 0)\n",
+    "chord = (root,)\n",
+    "chord_set = chords(chord, root, 3, 3)\n",
+    "graph = generate_graph(chord_set, 2, 2, 3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 213,
+   "id": "6e4ecb10-344b-4721-b2f4-68de91d712db",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "((4, 0, 0, 0, -1), (3, 0, -1, 0, 0), (0, 0, 0, 0, 0))\n",
+      "0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "144"
+      ]
+     },
+     "execution_count": 213,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from random import choice, choices\n",
+    "\n",
+    "# This is for the rising version / yitgadal\n",
+    "def stochastic_hamiltonian(graph):\n",
+    "        \n",
+    "    def movement_size_weights(edges):\n",
+    "        \n",
+    "        def max_cent_diff(edge):\n",
+    "            res = max([v for val in edge[2]['movements'].values() if (v:=val['cent_difference']) is not None])\n",
+    "            return res\n",
+    "            \n",
+    "        def min_cent_diff(edge):\n",
+    "            res = [v for val in edge[2]['movements'].values() if (v:=val['cent_difference']) is not None]\n",
+    "            res.remove(0)\n",
+    "            return min(res)\n",
+    "            \n",
+    "        for e in edges:\n",
+    "            yield 1000 if ((max_cent_diff(e) < 175) and (min_cent_diff(e)) >= 0) else 1\n",
+    "\n",
+    "    def hamiltonian_weights(edges):\n",
+    "        for e in edges:\n",
+    "            yield 10 if e[1] not in [path_edge[0] for path_edge in path] else 1 / graph.nodes[e[1]]['count']\n",
+    "    \n",
+    "    def contrary_motion_weights(edges):\n",
+    "\n",
+    "        def is_contrary(edge):\n",
+    "            cent_diffs = [v for val in edge[2]['movements'].values() if (v:=val['cent_difference']) is not None]\n",
+    "            cent_diffs.sort()\n",
+    "            return (cent_diffs[0] < 0) and (cent_diffs[1] == 0) and (cent_diffs[2] > 0)\n",
+    "\n",
+    "        for e in edges:\n",
+    "            yield 2 if is_contrary(e) else 1\n",
+    "    \n",
+    "    def is_directly_tunable_weights(edges):\n",
+    "        for e in edges:\n",
+    "            yield 10 if e[2]['is_directly_tunable'] else 0\n",
+    "\n",
+    "    def transposition_weight(edges):\n",
+    "        for e in edges:\n",
+    "            yield 1000 if 0 <= hs_array_to_cents(e[2]['transposition']) < 100 else 0\n",
+    "\n",
+    "    def is_sustained_voice(edges, voice):\n",
+    "        \n",
+    "        def is_sustained(edge):\n",
+    "            source = list(edge[0])\n",
+    "            ordered_source = sorted(source, key=hs_array_to_fr)    \n",
+    "            destination = [transpose_pitch(edge[2]['movements'][p]['destination'], edge[2]['transposition']) for p in source]\n",
+    "            ordered_destination = sorted(destination, key=hs_array_to_fr)\n",
+    "            return ordered_source[voice] == ordered_destination[voice]\n",
+    "\n",
+    "        for e in edges:\n",
+    "            yield 10 if is_sustained(e) else 0\n",
+    "\n",
+    "    def voice_crossing_weights(edges):\n",
+    "        \n",
+    "        def has_voice_crossing(edge):\n",
+    "            source = list(edge[0])\n",
+    "            ordered_source = sorted(source, key=hs_array_to_fr)    \n",
+    "            source_order = [ordered_source.index(p) for p in source]\n",
+    "            destination = [transpose_pitch(edge[2]['movements'][p]['destination'], edge[2]['transposition']) for p in source]\n",
+    "            ordered_destination = sorted(destination, key=hs_array_to_fr)\n",
+    "            destination_order = [ordered_destination.index(p) for p in destination]\n",
+    "            return source_order != destination_order\n",
+    "\n",
+    "        for e in edges:\n",
+    "            yield 10 if not has_voice_crossing(e) else 0\n",
+    "\n",
+    "    def is_bass_rooted(chord):\n",
+    "        return max([sum(abs(p) for p in collapse_pitch(pitch_difference(chord[0], p))) for p in chord[1:]]) == 1\n",
+    "        \n",
+    "    check_graph = graph.copy()\n",
+    "    #next_node = choice([node for node in graph.nodes() if is_bass_rooted(node)])\n",
+    "    next_node = choice(list(graph.nodes()))\n",
+    "    print(next_node)\n",
+    "    check_graph.remove_node(next_node)\n",
+    "    for node in graph.nodes(data=True):\n",
+    "        node[1]['count'] = 1\n",
+    "    path = []\n",
+    "    while (nx.number_of_nodes(check_graph) > 0) and (len(path) < 500):\n",
+    "        out_edges = list(graph.out_edges(next_node, data=True))\n",
+    "        #print([l for l in zip(movement_size_weights(out_edges), hamiltonian_weights(out_edges))])\n",
+    "        factors = [\n",
+    "            movement_size_weights(out_edges), \n",
+    "            hamiltonian_weights(out_edges), \n",
+    "            #contrary_motion_weights(out_edges), \n",
+    "            #is_directly_tunable_weights(out_edges),\n",
+    "            voice_crossing_weights(out_edges),\n",
+    "            #transposition_weight(out_edges)\n",
+    "            #is_sustained_voice(out_edges, 0)\n",
+    "        ]\n",
+    "        weights = [prod(a) for a in zip(*factors)]\n",
+    "        #print(weights)\n",
+    "        edge = choices(out_edges, weights=weights)[0]\n",
+    "        #print(edge)\n",
+    "        #edge = random.choice(out_edges)\n",
+    "        next_node = edge[1]\n",
+    "        node[1]['count'] += 1\n",
+    "        path.append(edge)\n",
+    "        if next_node in check_graph.nodes:\n",
+    "            check_graph.remove_node(next_node)\n",
+    "    print(len(check_graph.nodes()))\n",
+    "    return path\n",
+    "    \n",
+    "path = stochastic_hamiltonian(graph)\n",
+    "#for edge in path:\n",
+    "#    print(edge)\n",
+    "write_chord_sequence(path_to_chords(path, root))\n",
+    "len(path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 212,
+   "id": "7b76d848-fe53-4b60-b414-46cfe570f78b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "((4, 0, 0, 0, -1), (2, -1, 0, 0, 0), (0, 0, 0, 0, 0))\n",
+      "0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "219"
+      ]
+     },
+     "execution_count": 212,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "path = stochastic_hamiltonian(graph)\n",
+    "#for edge in path:\n",
+    "#    print(edge)\n",
+    "write_chord_sequence(path_to_chords(path, root))\n",
+    "len(path)"
+   ]
   }
  ],
  "metadata": {
diff --git a/compact_sets_extended_simplified.py b/compact_sets_extended_simplified.py
index baa1fe1..1deb3f2 100644
--- a/compact_sets_extended_simplified.py
+++ b/compact_sets_extended_simplified.py
@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # coding: utf-8
 
-# In[1]:
+# In[89]:
 
 
 from itertools import chain, combinations, permutations, product
@@ -76,7 +76,7 @@ def chords(chord, root, min_chord_size, max_chord_size):
 def edges(chords, min_symdiff, max_symdiff, max_chord_size):  
 
     def reverse_movements(movements):
-        return {value['destination']:{'destination':key, 'cent_difference':value['cent_difference']} for key, value in movements.items()}
+        return {value['destination']:{'destination':key, 'cent_difference':value['cent_difference'] * -1} for key, value in movements.items()}
 
     def is_directly_tunable(intersection, diff):
         # this only works for now when intersection if one element - need to fix that
@@ -161,7 +161,7 @@ def write_chord_sequence(path):
     file.close()
 
 
-# In[2]:
+# In[214]:
 
 
 dims = (2, 3, 5, 7, 11)
@@ -171,11 +171,12 @@ chord_set = chords(chord, root, 3, 3)
 graph = generate_graph(chord_set, 4, 4, 3)
 
 
-# In[7]:
+# In[215]:
 
 
 from random import choice, choices
 
+# This is for the static version
 def stochastic_hamiltonian(graph):
         
     def movement_size_weights(edges):
@@ -223,10 +224,12 @@ def stochastic_hamiltonian(graph):
 
         for e in edges:
             yield 10 if not has_voice_crossing(e) else 0
+
+    def is_bass_rooted(chord):
+        return max([sum(abs(p) for p in collapse_pitch(pitch_difference(chord[0], p))) for p in chord[1:]]) == 1
         
     check_graph = graph.copy()
-    #next_node = choice(list(graph.nodes()))
-    next_node = list(graph.nodes())[0]
+    next_node = choice([node for node in graph.nodes() if is_bass_rooted(node)])
     check_graph.remove_node(next_node)
     for node in graph.nodes(data=True):
         node[1]['count'] = 1
@@ -258,6 +261,15 @@ write_chord_sequence(path_to_chords(path, root))
 len(path)
 
 
+# In[25]:
+
+
+def is_super_compact(chord):
+    return max([sum(abs(p) for p in collapse_pitch(pitch_difference(c[0], c[1]))) for c in combinations(chord, 2)]) == 1
+        
+[node for node in graph.nodes() if is_super_compact(node)]
+
+
 # In[11]:
 
 
@@ -275,3 +287,136 @@ chord_set = chords(chord, root, 3, 3)
 
 lprun -f edge_data edges(chord_set, 3, 3, 4)
 
+
+# In[180]:
+
+
+dims = (2, 3, 5, 7, 11)
+root = (0, 0, 0, 0, 0)
+chord = (root,)
+chord_set = chords(chord, root, 3, 3)
+graph = generate_graph(chord_set, 2, 2, 3)
+
+
+# In[213]:
+
+
+from random import choice, choices
+
+# This is for the rising version / yitgadal
+def stochastic_hamiltonian(graph):
+        
+    def movement_size_weights(edges):
+        
+        def max_cent_diff(edge):
+            res = max([v for val in edge[2]['movements'].values() if (v:=val['cent_difference']) is not None])
+            return res
+            
+        def min_cent_diff(edge):
+            res = [v for val in edge[2]['movements'].values() if (v:=val['cent_difference']) is not None]
+            res.remove(0)
+            return min(res)
+            
+        for e in edges:
+            yield 1000 if ((max_cent_diff(e) < 175) and (min_cent_diff(e)) >= 0) else 1
+
+    def hamiltonian_weights(edges):
+        for e in edges:
+            yield 10 if e[1] not in [path_edge[0] for path_edge in path] else 1 / graph.nodes[e[1]]['count']
+    
+    def contrary_motion_weights(edges):
+
+        def is_contrary(edge):
+            cent_diffs = [v for val in edge[2]['movements'].values() if (v:=val['cent_difference']) is not None]
+            cent_diffs.sort()
+            return (cent_diffs[0] < 0) and (cent_diffs[1] == 0) and (cent_diffs[2] > 0)
+
+        for e in edges:
+            yield 2 if is_contrary(e) else 1
+    
+    def is_directly_tunable_weights(edges):
+        for e in edges:
+            yield 10 if e[2]['is_directly_tunable'] else 0
+
+    def transposition_weight(edges):
+        for e in edges:
+            yield 1000 if 0 <= hs_array_to_cents(e[2]['transposition']) < 100 else 0
+
+    def is_sustained_voice(edges, voice):
+        
+        def is_sustained(edge):
+            source = list(edge[0])
+            ordered_source = sorted(source, key=hs_array_to_fr)    
+            destination = [transpose_pitch(edge[2]['movements'][p]['destination'], edge[2]['transposition']) for p in source]
+            ordered_destination = sorted(destination, key=hs_array_to_fr)
+            return ordered_source[voice] == ordered_destination[voice]
+
+        for e in edges:
+            yield 10 if is_sustained(e) else 0
+
+    def voice_crossing_weights(edges):
+        
+        def has_voice_crossing(edge):
+            source = list(edge[0])
+            ordered_source = sorted(source, key=hs_array_to_fr)    
+            source_order = [ordered_source.index(p) for p in source]
+            destination = [transpose_pitch(edge[2]['movements'][p]['destination'], edge[2]['transposition']) for p in source]
+            ordered_destination = sorted(destination, key=hs_array_to_fr)
+            destination_order = [ordered_destination.index(p) for p in destination]
+            return source_order != destination_order
+
+        for e in edges:
+            yield 10 if not has_voice_crossing(e) else 0
+
+    def is_bass_rooted(chord):
+        return max([sum(abs(p) for p in collapse_pitch(pitch_difference(chord[0], p))) for p in chord[1:]]) == 1
+        
+    check_graph = graph.copy()
+    #next_node = choice([node for node in graph.nodes() if is_bass_rooted(node)])
+    next_node = choice(list(graph.nodes()))
+    print(next_node)
+    check_graph.remove_node(next_node)
+    for node in graph.nodes(data=True):
+        node[1]['count'] = 1
+    path = []
+    while (nx.number_of_nodes(check_graph) > 0) and (len(path) < 500):
+        out_edges = list(graph.out_edges(next_node, data=True))
+        #print([l for l in zip(movement_size_weights(out_edges), hamiltonian_weights(out_edges))])
+        factors = [
+            movement_size_weights(out_edges), 
+            hamiltonian_weights(out_edges), 
+            #contrary_motion_weights(out_edges), 
+            #is_directly_tunable_weights(out_edges),
+            voice_crossing_weights(out_edges),
+            #transposition_weight(out_edges)
+            #is_sustained_voice(out_edges, 0)
+        ]
+        weights = [prod(a) for a in zip(*factors)]
+        #print(weights)
+        edge = choices(out_edges, weights=weights)[0]
+        #print(edge)
+        #edge = random.choice(out_edges)
+        next_node = edge[1]
+        node[1]['count'] += 1
+        path.append(edge)
+        if next_node in check_graph.nodes:
+            check_graph.remove_node(next_node)
+    print(len(check_graph.nodes()))
+    return path
+    
+path = stochastic_hamiltonian(graph)
+#for edge in path:
+#    print(edge)
+write_chord_sequence(path_to_chords(path, root))
+len(path)
+
+
+# In[212]:
+
+
+path = stochastic_hamiltonian(graph)
+#for edge in path:
+#    print(edge)
+write_chord_sequence(path_to_chords(path, root))
+len(path)
+
diff --git a/compact_sets_play.scd b/compact_sets_play.scd
index f2cf6ca..d5531e5 100644
--- a/compact_sets_play.scd
+++ b/compact_sets_play.scd
@@ -6,6 +6,7 @@ SynthDef(\string_model, {arg freq, gate = 1, del, sustain, amp, dur, attack, rel
 	sig1 = (Klank.ar(`[ Array.series(noHarms, freq, freq),
 		Array.geom(noHarms, 1, 0.2) + Array.fill(noHarms, {rrand(0.01, 0.03)}),
 		Array.fill(noHarms, {rrand(1, 2)}) ], exc) * 0.8).softclip;
+	//note that the delay cuts into the sustain portion of the tone!!!
 	Out.ar([0, 1], 0.75 * sig1 * amp * EnvGen.kr(Env.dadsr(del, attack, 0.3, 0.9, release, 0.9, -3), gate, doneAction: 2));
 }).add;
 )
@@ -13,7 +14,7 @@ SynthDef(\string_model, {arg freq, gate = 1, del, sustain, amp, dur, attack, rel
 (
 var primes, hsArrayToFreq, hsArrayDimDiff, file, seq, phraseLengths, musicData, patterns;
 
-thisThread.randSeed = 1923;
+thisThread.randSeed = 83924874938;
 
 primes = [2, 3, 5, 7, 11];
 
@@ -35,14 +36,25 @@ seq = file.readAllString.interpret;
 //seq = seq.collect({arg item; item.sort});
 seq = seq.collect({arg chord, index;
 	var ref_ins;
-	ref_ins = if(index == 0, {0}, {[seq[index - 1], chord].flop.collect({arg pair; pair[0] == pair[1]}).indexOf(true)});
+	ref_ins = if(index == 0, {
+		[0] // this should actually check which is the 'centered' pitch
+	}, {
+		[seq[index - 1], chord].postln.flop.collect({arg pair, p; if(pair[0] == pair[1], {p}, {-1})}).postln.removeEvery([-1])
+	});
 	chord.collect({arg pitch;
 		var dimDiff;
-		[pitch, [ref_ins, hsArrayDimDiff.value(chord[ref_ins], pitch)]]
+		ref_ins.postln;
+		if(ref_ins.size == 1, {
+			[pitch, [ref_ins[0], hsArrayDimDiff.value(chord[ref_ins[0]], pitch)]]
+		}, {
+			var min_ref_ins;
+			min_ref_ins = ref_ins.minItem({arg ins; (chord[ins].drop(1) - pitch.drop(1)).abs.sum});
+			[pitch, [min_ref_ins.postln, hsArrayDimDiff.value(chord[min_ref_ins], pitch)]]
+		});
 	})
 });
 
-seq.do({arg chord; chord; chord.collect({arg pitch; hsArrayToFreq.value(pitch[0])})});
+seq.do({arg chord; chord; chord.collect({arg pitch; hsArrayToFreq.value(pitch[0])}).postln});
 //seq.postln;
 
 
@@ -51,28 +63,33 @@ while({phraseLengths.sum < seq.size}, {phraseLengths = phraseLengths ++ [rrand(1
 //phraseLengths.postln;
 
 musicData = seq.clumps(phraseLengths).collect({arg subSeq, seqIndex;
-	var baseRound, baseDurs, baseDelay, baseSubtract;
+	var baseRound, baseDurs, minDelay, maxDelay, baseSubtract;
 	baseRound = 0.5;
-	//baseDurs = subSeq.size.collect({arg subSeqIndex; if(subSeqIndex != (subSeq.size - 1), {rrand(7.0, 10.0)}, {rrand(10.0, 15.0)})}).round(baseRound);
 	baseDurs = subSeq.size.collect({arg subSeqIndex; if(subSeqIndex != (subSeq.size - 1), {rrand(5.0, 7.0)}, {rrand(10.0, 15.0)})}).round(baseRound);
-	baseDelay = rrand(1.0, 2.0);
-	baseSubtract = rrand(2.0, 4.0);
+	//baseDurs = subSeq.size.collect({arg subSeqIndex; if(subSeqIndex != (subSeq.size - 1), {rrand(5.0, 7.0)}, {rrand(15.0, 20.0)})}).round(baseRound);
+	//maxDelay = rrand(1.0, 3.0);
+	//maxDelay = 5;
+	minDelay = 0;
+	maxDelay = 0;
+	baseDurs[0] = baseDurs[0] + maxDelay;
+	baseSubtract = rrand(0.0, 3.0);
 	subSeq.flop.collect({arg voice, v;
 		var phrases, freqs, durs, delays, attacks, rels, sustains, amps, refs;
 		phrases = voice.separate({arg a, b; a[0] != b[0]});
-		freqs = phrases.collect({arg phrase; if(phrase[0][0] != ["Rest"], {48.midicps * pow(2, (v * 2).clip(0, 1)) * hsArrayToFreq.value(phrase[0][0])}, {Rest(0)})});
+		freqs = phrases.collect({arg phrase; if(phrase[0][0] != ["Rest"], {45.midicps * pow(2, (v * 2).clip(0, 1)) * hsArrayToFreq.value(phrase[0][0])}, {Rest(0)})});
 		refs = phrases.collect({arg phrase; if(phrase[0][0] != ["Rest"], {phrase[0][1]}, {Rest(0)})});
 		durs = baseDurs.clumps(phrases.collect({arg phrase; phrase.size})).collect({arg c; c.sum});
-		delays = durs.collect({arg dur; rrand(0.0, 0.0)}).round(baseRound);
-		//delays = durs.collect({arg dur, d; if((d == 0) && (refs[d][0] != v), {[baseDelay, rrand(2.0, 3.0)].wchoose([2, 1].normalizeSum)}, {0})}).round(baseRound);
-		//delays = durs.collect({arg dur, d; if((d == 0) && (refs[d][0] != v), {baseDelay}, {0})}).round(baseRound);
-		//durs = durs + delays;
+		delays = durs.collect({arg dur, d; if((d == 0) && (refs[d][0] != v), {[rrand(minDelay, maxDelay), 0].wchoose([1, 1].normalizeSum)}, {0})}).round(baseRound);
+		//delays = durs.collect({0}}).round(baseRound);
 		attacks = durs.collect({arg dur, d; if(d == 0, {rrand(3.0, 5.0)}, {rrand(1.0, 3.0)})}).round(baseRound);
-		rels = durs.collect({arg dur, d; if(d != (durs.size - 1), {rrand(1.0, 2.0)}, {rrand(3.0, 5.0)})}).round(baseRound);
-		//sustains = durs.collect({arg dur, d; if(d != (durs.size - 1), {dur - rels[d] - delays[d]}, {dur - rels[d] - delays[d]})}).round(baseRound);
-		//sustains = durs.collect({arg dur, d; if(d != (durs.size - 1), {dur}, {dur - rrand(3.0, 5.0)})}).round(baseRound);
-		sustains = durs.collect({arg dur, d; if(d != (durs.size - 1), {dur - rels[d] - delays[d] - 0.5}, {dur - rels[d] - delays[d] - baseSubtract - rrand(0.0, 2.0)})}).round(baseRound);
-		amps = freqs.collect({rrand(0.6, 0.7) / [1, 2, 2][v]});
+		rels = durs.collect({arg dur, d; if(d != (durs.size - 1), {rrand(0.5, 1.0)}, {rrand(3.0, 5.0)})}).round(baseRound);
+		sustains = durs.collect({arg dur, d;
+			if(d != (durs.size - 1), {
+				dur - rels[d]
+			}, {
+				dur - rels[d] - baseSubtract - rrand(0.0, 1.0)})
+		}).round(baseRound);
+		amps = freqs.collect({rrand(0.6, 0.7) / [1, 2, 2, 2][v]});
 		[freqs, durs, attacks, delays, sustains, rels, amps, refs].flop;
 	});
 }).flop.collect({arg voice; voice.flatten});
@@ -80,7 +97,7 @@ musicData = seq.clumps(phraseLengths).collect({arg subSeq, seqIndex;
 musicData = musicData.collect({arg voice, v;
 	var clumps;
 	//(v + "~~~~~~~~~~").postln;
-	clumps = voice.separate({arg a, b; [true, a[0] != b[0]].wchoose([1, 1].normalizeSum)});
+	clumps = voice.separate({arg a, b; [true, a[0] != b[0]].wchoose([1, 2].normalizeSum)});
 	clumps = clumps.collect({arg clump;
 		if(clump.size == 1, {clump[0]}, {
 			var mergedClump;
@@ -99,6 +116,7 @@ musicData = musicData.collect({arg voice, v;
 	musicData.collect({arg voice, v;
 		var freqs, durs, attacks, delays, sustains, rels, amps;
 		# freqs, durs, attacks, delays, sustains, rels, amps = voice.flop;
+		//# durs, attacks, delays, sustains, rels = [durs, attacks, delays, sustains, rels].collect({arg data; data / 16});
 		Pbind(
 			\instrument, \string_model,
 			\freq, Pseq(freqs, 1),
@@ -116,4 +134,4 @@ musicData = musicData.collect({arg voice, v;
 ~patterns.play
 )
 
-~patterns.play
\ No newline at end of file
+
diff --git a/compact_sets_transcriber.scd b/compact_sets_transcriber.scd
index 56192a1..a7e5df2 100644
--- a/compact_sets_transcriber.scd
+++ b/compact_sets_transcriber.scd
@@ -14,13 +14,13 @@ formatMusicData = {arg seq;
 		var freqs, durs, attacks, delays, sustains, rels, amps, refs, res;
 		# freqs, durs, attacks, delays, sustains, rels, amps, refs = partData.flop;
 		durs = (durs / 0.5).round.asInteger;
-		sustains = ((sustains + delays + rels) / 0.5).round.asInteger;
-		//sustains = (sustains / 0.5).round.asInteger;
-		//[durs, sustains, delays, rels].flop.do({arg item; if(item[0] < item[1], {item.postln})});
-		res = [freqs, durs, sustains, refs].flop.collect({arg data, i;
-			var freq, dur, sus, ref;
-			# freq, dur, sus, ref = data;
-			sus.collect({[freq, ref, i]}) ++ (dur - sus).collect({[-1, ref, i]})
+		sustains = ((sustains + rels - 0.5) / 0.5).round.asInteger;
+		delays = (delays / 0.5).round.asInteger;
+		res = [freqs, durs, delays, sustains, refs].flop.collect({arg data, i;
+			var freq, dur, del, sus, ref;
+			# freq, dur, del, sus, ref = data;
+			del.collect({[-1, ref, i]}) ++ (sus - del).collect({[freq, ref, i]}) ++ (dur - sus).collect({[-1, ref, i]})
+			//sus.collect({[freq, ref, i]}) ++ (dur - sus).collect({[-1, ref, i]})
 		}).flatten;
 		if(res.size > maxSize, {maxSize = res.size});
 		res