@swiftbrowser/native 0.19.0 → 0.21.0

package/swift/Packages/SwiftBrowserDSP/Sources/SwiftBrowserDSPCore/Machine.swift

@@ -17,13 +17,44 @@ import Foundation
 /// else a free one, else the oldest released, else the oldest; a lane's gate
 /// is up from its note on to its note off, or under the sustain pedal until
 /// the pedal lifts, and it sounds while the gate is up and then while any
-/// `adsr` in the program has not finished its release.
+/// `adsr` in the program has not finished its release. A `mono` or `legato`
+/// program is one voice playing the newest of the notes held (up to 16
+/// remembered): releasing it goes back to the one before, and `mono` starts
+/// its envelopes over at every change of note, `legato` only when no note
+/// was held.
+///
+/// The transport: `tempo` beats a minute (120 until set) and `beat`, which
+/// advances every frame from 0 (or where `seek` puts it), sounding or not.
+/// An event given a beat waits for it (up to 1024 at once) and applies on
+/// the frame nearest it, the block split there, so a sequencer that
+/// schedules ahead plays in time; one whose beat has passed applies at the
+/// next block. All notes off and all sound off drop what waits.
+///
+/// Memory is sized in `init` and never after: the wavetables (built from
+/// their harmonics with the JavaScript machine's inverse FFT, 2048 samples a
+/// frame at ten band-limited levels), a ring buffer per voice for each
+/// `delay`, the shapes' points and the samples' audio.
+///
+/// With a `master` stage, the voices' sum goes through it once a frame, in
+/// lane 0, whether or not a voice sounds; its state and its builtins' are
+/// reset only in `init` and on `reset`.
+///
+/// Block processing: a block runs in chunks of 16 frames, each instruction over every frame of the chunk for every
+/// sounding lane, but for a stream's serial part (feedback through state, which the compiler marks), which runs
+/// frame by frame within the chunk. Unlike the JavaScript machine's, a register holds a frame's lanes side by side,
+/// then the next frame's, so the loops over lanes stay vector loops; the results are the same.
 public final class DSPMachine: @unchecked Sendable {
     public let program: DSPProgram
     public let sampleRate: Float
 
     private static let lanes = 16
+    /// Frames a chunk has: each instruction runs over a chunk's frames together (block processing).
+    private static let frames = 16
+    /// The registers, each `width` values: a chunk's frames one after another, each its lanes (as many as the
+    /// program has voices) side by side, so an instruction runs over lanes as a SIMD vector and a builtin's state
+    /// follows its lanes; a state register's value is its lane's at the first frame.
     private let registers: UnsafeMutablePointer<Float>
+    private let width: Int
     private let state: UnsafeMutablePointer<Float>
     private let stateCount: Int
     private let noise: UnsafeMutablePointer<UInt32>
@@ -32,6 +63,13 @@ public final class DSPMachine: @unchecked Sendable {
     private let blockCount: Int
     private let sampleCode: UnsafeMutablePointer<Int32>
     private let sampleCount: Int
+    private let masterCode: UnsafeMutablePointer<Int32>
+    private let masterCount: Int
+    /// The parts of `sample` and `master` that run frame by frame, in instructions.
+    private let sampleSerial: Range<Int>
+    private let masterSerial: Range<Int>
+    /// Per instance: whether the master stage runs it.
+    private let instanceMaster: [Bool]
     /// Each instance's builtin and where its state starts (in floats, lanes included; a noise instance's in `noise`).
     private let instanceKinds: [DSPBuiltin]
     private let instanceOffsets: [Int]
@@ -42,6 +80,36 @@ public final class DSPMachine: @unchecked Sendable {
     private let parameterIndices: [String: Int]
     private let targets: UnsafeMutablePointer<Float>
     private var snapped = true
+    /// The wavetables' samples (table, level, 2048 samples, each its frames side by side), where each table starts
+    /// and its frames.
+    private let tableSamples: UnsafeMutablePointer<Float>
+    private let tableCount: Int
+    /// Envelopes' curves (attack, decay, release exponents), three a curve; an `adsr` names its curve in slot 11.
+    private let curveExponents: [Float]
+    private let tableBases: [Int]
+    private let tableFrames: [Int]
+    /// The delays' samples: each instance's buffer per lane, a power of two long; by instance, where it starts and its length.
+    private let delaySamples: UnsafeMutablePointer<Float>
+    private let delaySampleCount: Int
+    private let delayBases: [Int]
+    private let delayLengths: [Int]
+    /// The shapes' points, one after another; where each starts and its length.
+    private let shapePoints: UnsafeMutablePointer<Float>
+    private let shapeBases: [Int]
+    private let shapeLengths: [Int]
+    /// The samples' audio, one after another; per sample where it starts, its length, its frames a frame at this
+    /// rate, and its spray (20 ms) in frames.
+    private let sampleAudio: UnsafeMutablePointer<Float>
+    private let sampleBases: [Int]
+    private let sampleLengths: [Int]
+    private let sampleRatios: [Float]
+    private let sampleSprays: [UInt32]
+    /// `modsum`'s route lists one after another, as register offsets (× `width`): a source's, then its amount's, pair
+    /// after pair; list i is `routeStarts[i] ..< routeStarts[i + 1]`.
+    private let routeRegisters: UnsafeMutablePointer<Int>
+    /// Whether each route's register is state (one value a lane, not one a frame).
+    private let routeState: UnsafeMutablePointer<Bool>
+    private let routeStarts: [Int]
 
     private let laneNote: UnsafeMutablePointer<Int32>
     private let laneGate: UnsafeMutablePointer<Float>
@@ -50,31 +118,60 @@ public final class DSPMachine: @unchecked Sendable {
     private let laneActive: UnsafeMutablePointer<Float>
     private let laneAge: UnsafeMutablePointer<Double>
     private let trigger: UnsafeMutablePointer<Float>
+    /// The master stage's trigger: counts the notes (as the voice a mono program's starts over at).
+    private let masterTrigger: UnsafeMutablePointer<Float>
+    /// The lane of the newest note, for a master stage that reads it (-1 before the first).
+    private var newestLane = -1
     private var age: Double = 0
     private var pedal = false
     private var bend: Double = 0
+    private var tempo: Double = 120
+    private var beat: Double = 0
+    /// A mono program's held notes, oldest first.
+    private let stack: UnsafeMutablePointer<Int32>
+    private var stackCount = 0
+    /// Events waiting for their beat, soonest first: the beat, then the kind (note on, note off, controller,
+    /// bend) and two values.
+    private static let queueCapacity = 1024
+    private let queueBeat: UnsafeMutablePointer<Double>
+    private let queueEvent: UnsafeMutablePointer<Int32>
+    private var queueCount = 0
 
     public init(program: DSPProgram, sampleRate: Double) {
         let L = Self.lanes
         self.program = program
         self.sampleRate = Float(sampleRate)
-        registers = .allocate(capacity: program.registers * L)
-        registers.initialize(repeating: 0, count: program.registers * L)
+        let W = program.voices * Self.frames
+        width = W
+        registers = .allocate(capacity: program.registers * W)
+        registers.initialize(repeating: 0, count: program.registers * W)
+        let stateRegisters = Set(program.state.map(\.register))
+        var isMaster = [Bool](repeating: false, count: program.instances.count)
+        if let master = program.master {
+            var pc = 0
+            while pc < master.code.count {
+                let op = DSPOpcode(rawValue: master.code[pc])!
+                if op.builtin != nil { isMaster[Int(master.code[pc + 2 + op.arity])] = true }
+                pc += 2 + op.arity + (op.builtin == nil ? 0 : 1)
+            }
+        }
+        instanceMaster = isMaster
         var kinds: [DSPBuiltin] = []
         var offsets: [Int] = []
         var envelopes: [Int] = []
         var filters: [Int] = []
         var words = 0
         var noises = 0
-        for builtin in program.instances {
+        for (i, builtin) in program.instances.enumerated() {
             kinds.append(builtin)
             if builtin == .noise {
                 offsets.append(noises * L)
                 noises += 1
             } else {
                 offsets.append(words * L)
-                if builtin == .adsr { envelopes.append(words * L) }
-                if builtin == .lowpass || builtin == .highpass || builtin == .bandpass { filters.append(words * L) }
+                if builtin == .adsr && !isMaster[i] { envelopes.append(words * L) }
+                // The filters' integrators, a one-pole's, a DC blocker's and a comb's loop.
+                if [.lowpass, .highpass, .bandpass, .onepole, .dcblock, .comb].contains(builtin) { filters.append(words * L) }
                 words += builtin.words
             }
         }
@@ -88,19 +185,67 @@ public final class DSPMachine: @unchecked Sendable {
         noiseCount = max(1, noises) * L
         noise = .allocate(capacity: noiseCount)
         noise.initialize(repeating: 1, count: noiseCount)
-        (blockCode, blockCount) = Self.decode(program.block, offsets: offsets)
-        (sampleCode, sampleCount) = Self.decode(program.sample, offsets: offsets)
+        (tableSamples, tableBases, tableFrames) = Self.buildTables(program.tables)
+        tableCount = program.tables.count
+        (shapePoints, shapeBases, shapeLengths) = Self.concatenate(program.shapes.map(\.points))
+        (sampleAudio, sampleBases, sampleLengths) = Self.concatenate(program.samples.map(\.data))
+        sampleRatios = program.samples.map { Float($0.rate / Double(Float(sampleRate))) }
+        routeStarts = program.routes.reduce(into: [0]) { starts, list in starts.append(starts.last! + list.count) }
+        routeRegisters = .allocate(capacity: Swift.max(1, routeStarts.last!))
+        routeState = .allocate(capacity: Swift.max(1, routeStarts.last!))
+        routeState.initialize(repeating: false, count: Swift.max(1, routeStarts.last!))
+        for (i, list) in program.routes.enumerated() {
+            for (k, r) in list.enumerated() {
+                routeRegisters[routeStarts[i] + k] = r * W
+                routeState[routeStarts[i] + k] = stateRegisters.contains(r)
+            }
+        }
+        sampleSprays = program.samples.map { UInt32(Swift.max(1, ($0.rate * 0.02).rounded(.down))) }
+        // Each delay's buffer: its longest time (a constant register) at this sample rate, rounded up to a power of
+        // two, per voice (the master stage's, once).
+        let constantValues = Dictionary(program.constants.map { ($0.register, $0.value) }, uniquingKeysWith: { _, last in last })
+        var bases = [Int](repeating: 0, count: program.instances.count)
+        var lengths = [Int](repeating: 0, count: program.instances.count)
+        var delayTotal = 0
+        for code in [program.sample, program.master?.code ?? []] {
+            var pc = 0
+            while pc < code.count {
+                let op = DSPOpcode(rawValue: code[pc])!
+                if let longestAt = op.longest {
+                    let instance = Int(code[pc + 2 + op.arity])
+                    let longest = Double(Swift.min(Swift.max(constantValues[Int(code[pc + 1 + longestAt])] ?? 1, 0), 2))
+                    var length = 4
+                    while Double(length) < (longest * Double(Float(sampleRate))).rounded(.up) + 2 { length *= 2 }
+                    bases[instance] = delayTotal
+                    lengths[instance] = length
+                    delayTotal += length * (isMaster[instance] ? 1 : L)
+                }
+                pc += 2 + op.arity + (op.builtin == nil ? 0 : 1)
+            }
+        }
+        delayBases = bases
+        delayLengths = lengths
+        delaySampleCount = Swift.max(1, delayTotal)
+        delaySamples = .allocate(capacity: delaySampleCount)
+        delaySamples.initialize(repeating: 0, count: delaySampleCount)
+        curveExponents = program.curves.flatMap { [$0.attack, $0.decay, $0.release] }
+        let curves = Dictionary(program.curves.enumerated().map { ($1.instance, $0 + 1) }, uniquingKeysWith: { _, last in last })
+        (blockCode, blockCount, _) = Self.decode(program.block, nil, width: W, state: stateRegisters, offsets: offsets, delays: (bases, lengths), curves: curves)
+        (sampleCode, sampleCount, sampleSerial) = Self.decode(
+            program.sample, program.serial, width: W, state: stateRegisters, offsets: offsets, delays: (bases, lengths), curves: curves)
+        (masterCode, masterCount, masterSerial) = Self.decode(
+            program.master?.code ?? [], program.master?.serial, width: W, state: stateRegisters, offsets: offsets, delays: (bases, lengths), curves: curves)
         for constant in program.constants {
-            (registers + constant.register * L).update(repeating: constant.value, count: L)
+            (registers + constant.register * W).update(repeating: constant.value, count: W)
         }
-        registers.update(repeating: Float(sampleRate), count: L)
+        registers.update(repeating: Float(sampleRate), count: W)
         parameterRegisters = program.parameters.map(\.register)
         parameterRanges = program.parameters.map { ($0.min, $0.max) }
         parameterIndices = Dictionary(program.parameters.enumerated().map { ($1.name, $0) }, uniquingKeysWith: { first, _ in first })
         targets = .allocate(capacity: max(1, program.parameters.count))
         for (i, parameter) in program.parameters.enumerated() {
             targets[i] = parameter.defaultValue
-            (registers + parameter.register * L).update(repeating: parameter.defaultValue, count: L)
+            (registers + parameter.register * W).update(repeating: parameter.defaultValue, count: W)
         }
         laneNote = .allocate(capacity: L)
         laneNote.initialize(repeating: -1, count: L)
@@ -116,37 +261,187 @@ public final class DSPMachine: @unchecked Sendable {
         laneAge.initialize(repeating: 0, count: L)
         trigger = .allocate(capacity: L)
         trigger.initialize(repeating: 0, count: L)
+        masterTrigger = .allocate(capacity: 1)
+        masterTrigger.initialize(to: 1)
+        stack = .allocate(capacity: L)
+        stack.initialize(repeating: 0, count: L)
+        queueBeat = .allocate(capacity: Self.queueCapacity)
+        queueBeat.initialize(repeating: 0, count: Self.queueCapacity)
+        queueEvent = .allocate(capacity: Self.queueCapacity * 3)
+        queueEvent.initialize(repeating: 0, count: Self.queueCapacity * 3)
         for lane in 0..<L { resetLane(lane) }
+        resetMaster()
     }
 
     deinit {
-        for pointer in [registers, state, targets, laneGate, laneVelocity, laneActive, trigger] { pointer.deallocate() }
+        for pointer in [registers, state, targets, laneGate, laneVelocity, laneActive, trigger, masterTrigger, shapePoints, sampleAudio] { pointer.deallocate() }
         noise.deallocate()
+        routeRegisters.deallocate()
+        routeState.deallocate()
+        tableSamples.deallocate()
+        delaySamples.deallocate()
         blockCode.deallocate()
         sampleCode.deallocate()
+        masterCode.deallocate()
         laneNote.deallocate()
+        stack.deallocate()
+        queueBeat.deallocate()
+        queueEvent.deallocate()
         laneHeld.deallocate()
         laneAge.deallocate()
     }
 
-    /// Instructions at a stride of 8 (op, destination, five operands, state offset), registers as offsets into the file.
-    private static func decode(_ code: [Int32], offsets: [Int]) -> (UnsafeMutablePointer<Int32>, Int) {
+    /// Instructions at a stride of 12 (op, destination, five operands, state offset, which of slots 1 … 6 are state
+    /// registers as bits, then a delay line's buffer: where it starts and its length, then an envelope's curve, 1 up,
+    /// 0 for none), registers as offsets into the file. With the serial part's word offsets, its instructions.
+    private static func decode(
+        _ code: [Int32], _ serial: Range<Int>?, width: Int, state: Set<Int>, offsets: [Int], delays: (bases: [Int], lengths: [Int]),
+        curves: [Int: Int]
+    ) -> (UnsafeMutablePointer<Int32>, Int, Range<Int>) {
         var out: [Int32] = []
+        var from = 0
+        var to = 0
         var pc = 0
         while pc < code.count {
+            if pc == serial?.lowerBound { from = out.count / 12 }
+            if pc == serial?.upperBound { to = out.count / 12 }
             let op = DSPOpcode(rawValue: code[pc])!
-            var slot = [Int32](repeating: 0, count: 8)
+            var slot = [Int32](repeating: 0, count: 12)
             slot[0] = op.rawValue
-            slot[1] = code[pc + 1] * Int32(lanes)
-            for k in 0..<op.arity { slot[2 + k] = code[pc + 2 + k] * Int32(lanes) }
+            for k in 0..<(1 + op.arity) {
+                let register = Int(code[pc + 1 + k])
+                slot[1 + k] = Int32(register * width)
+                if state.contains(register) { slot[8] |= 1 << (1 + k) }
+            }
             if op.builtin != nil { slot[7] = Int32(offsets[Int(code[pc + 2 + op.arity])]) }
+            if op == .adsr { slot[11] = Int32(curves[Int(code[pc + 2 + op.arity])] ?? 0) }
+            if op.longest != nil {
+                let instance = Int(code[pc + 2 + op.arity])
+                slot[9] = Int32(delays.bases[instance])
+                slot[10] = Int32(delays.lengths[instance])
+            }
             out += slot
             pc += 2 + op.arity + (op.builtin == nil ? 0 : 1)
         }
-        let pointer = UnsafeMutablePointer<Int32>.allocate(capacity: max(8, out.count))
-        pointer.initialize(repeating: 0, count: max(8, out.count))
+        if pc == serial?.lowerBound { from = out.count / 12 }
+        if pc == serial?.upperBound { to = out.count / 12 }
+        let pointer = UnsafeMutablePointer<Int32>.allocate(capacity: max(12, out.count))
+        pointer.initialize(repeating: 0, count: max(12, out.count))
         out.withUnsafeBufferPointer { pointer.update(from: $0.baseAddress!, count: out.count) }
-        return (pointer, out.count / 8)
+        return (pointer, out.count / 12, from..<to)
+    }
+
+    /// Lists one after another: where each starts and its length.
+    private static func concatenate(_ lists: [[Float]]) -> (UnsafeMutablePointer<Float>, [Int], [Int]) {
+        let total = Swift.max(1, lists.reduce(0) { $0 + $1.count })
+        let pointer = UnsafeMutablePointer<Float>.allocate(capacity: total)
+        pointer.initialize(repeating: 0, count: total)
+        var bases: [Int] = []
+        var at = 0
+        for list in lists {
+            bases.append(at)
+            list.withUnsafeBufferPointer { (pointer + at).update(from: $0.baseAddress!, count: list.count) }
+            at += list.count
+        }
+        return (pointer, bases, lists.map(\.count))
+    }
+
+    /// The wavetables' samples: per table, per frame, per level (level n keeps the harmonics up to 512 >> n), 2048
+    /// samples from an inverse FFT of the frame's sine harmonics (and cosine ones, when it has them) in doubles, stored as floats, a level's samples in
+    /// order with each sample's frames side by side: the JavaScript machine's `buildTables`, step for step.
+    private static func buildTables(_ tables: [DSPProgram.Table]) -> (UnsafeMutablePointer<Float>, [Int], [Int]) {
+        let N = DSPProgram.tableFrame
+        let levels = DSPProgram.tableLevels
+        let frameCount = tables.reduce(0) { $0 + $1.frames.count }
+        let count = Swift.max(1, frameCount * levels * N)
+        let samples = UnsafeMutablePointer<Float>.allocate(capacity: count)
+        samples.initialize(repeating: 0, count: count)
+        var bases: [Int] = []
+        var frames: [Int] = []
+        var cosT = [Double](repeating: 0, count: N / 2)
+        var sinT = [Double](repeating: 0, count: N / 2)
+        for j in 0..<(N / 2) {
+            cosT[j] = Foundation.cos(2 * Double.pi * Double(j) / Double(N))
+            sinT[j] = Foundation.sin(2 * Double.pi * Double(j) / Double(N))
+        }
+        var re = [Double](repeating: 0, count: N)
+        var im = [Double](repeating: 0, count: N)
+        var at = 0
+        for table in tables {
+            bases.append(at)
+            let count = table.frames.count
+            frames.append(count)
+            // A level's samples one after another, each its frames side by side: a read between two samples and two
+            // frames is one span of memory.
+            func store(_ level: Int, _ n: Int, _ f: Int) -> Int { at + (level * N + n) * count + f }
+            for (f, amplitudes) in table.frames.enumerated() {
+                for level in 0..<levels {
+                    let limit = Swift.min(512 >> level, amplitudes.count)
+                    if level > 0 && limit == Swift.min(512 >> (level - 1), amplitudes.count) {
+                        // No harmonic dropped: the level above's samples.
+                        for n in 0..<N { samples[store(level, n, f)] = samples[store(level - 1, n, f)] }
+                        continue
+                    }
+                    for i in 0..<N {
+                        re[i] = 0
+                        im[i] = 0
+                    }
+                    // sin(kθ) = (e^{ikθ} − e^{−ikθ}) / 2i
+                    if limit >= 1 {
+                        for k in 1...limit {
+                            let a = Double(amplitudes[k - 1])
+                            im[k] = -a / 2
+                            im[N - k] = a / 2
+                        }
+                        // cos(kθ) = (e^{ikθ} + e^{−ikθ}) / 2
+                        if let cosines = table.cosines?[f] {
+                            for k in 1...limit {
+                                let c = Double(cosines[k - 1])
+                                re[k] = c / 2
+                                re[N - k] = c / 2
+                            }
+                        }
+                    }
+                    // Bit reversal, then radix-2 butterflies with e^{+2πij/len}.
+                    var j = 0
+                    for i in 1..<N {
+                        var bit = N >> 1
+                        while j & bit != 0 {
+                            j ^= bit
+                            bit >>= 1
+                        }
+                        j ^= bit
+                        if i < j {
+                            re.swapAt(i, j)
+                            im.swapAt(i, j)
+                        }
+                    }
+                    var len = 2
+                    while len <= N {
+                        let half = len >> 1
+                        let step = N / len
+                        var i = 0
+                        while i < N {
+                            for k in 0..<half {
+                                let wr = cosT[k * step]
+                                let wi = sinT[k * step]
+                                let xr = re[i + k + half] * wr - im[i + k + half] * wi
+                                let xi = re[i + k + half] * wi + im[i + k + half] * wr
+                                re[i + k + half] = re[i + k] - xr
+                                im[i + k + half] = im[i + k] - xi
+                                re[i + k] = re[i + k] + xr
+                                im[i + k] = im[i + k] + xi
+                            }
+                            i += len
+                        }
+                        len <<= 1
+                    }
+                    for n in 0..<N { samples[store(level, n, f)] = Float(re[n]) }
+                }
+            }
+            at += count * levels * N
+        }
+        return (samples, bases, frames)
     }
 
     // MARK: Events
@@ -162,10 +457,119 @@ public final class DSPMachine: @unchecked Sendable {
         targets[index] = Swift.min(Swift.max(value, parameterRanges[index].min), parameterRanges[index].max)
     }
 
-    /// MIDI note on: `velocity` 1 … 127 (0 is a note off).
-    public func noteOn(_ note: Int32, velocity: Int32) {
+    /// The transport's tempo, in beats a minute (1 … 999), from the next block.
+    public func setTempo(_ bpm: Double) {
+        if bpm.isFinite { tempo = Swift.min(Swift.max(bpm, 1), 999) }
+    }
+
+    /// Moves the transport to `beat`.
+    public func seek(toBeat beat: Double) {
+        if beat.isFinite { self.beat = beat }
+    }
+
+    /// Where the transport is, in beats.
+    public var position: Double { beat }
+
+    /// MIDI note on: `velocity` 1 … 127 (0 is a note off); at `atBeat` on the transport, or at the next block. False
+    /// when too many wait.
+    @discardableResult
+    public func noteOn(_ note: Int32, velocity: Int32, atBeat: Double? = nil) -> Bool {
+        if let atBeat { return schedule(atBeat, 0, note, velocity) }
+        start(note, velocity: velocity)
+        return true
+    }
+
+    /// MIDI note off; at `atBeat` on the transport, or at the next block.
+    @discardableResult
+    public func noteOff(_ note: Int32, atBeat: Double? = nil) -> Bool {
+        if let atBeat { return schedule(atBeat, 1, note, 0) }
+        release(note)
+        return true
+    }
+
+    /// 64 the sustain pedal, 120 all sound off, 123 all notes off (both dropping what waits); at `atBeat`, or at the
+    /// next block.
+    @discardableResult
+    public func controller(_ number: Int32, value: Int32, atBeat: Double? = nil) -> Bool {
+        if let atBeat { return schedule(atBeat, 2, number, value) }
+        if number == 120 || number == 123 { queueCount = 0 }
+        control(number, value: value)
+        return true
+    }
+
+    /// The pitch wheel, 0 … 16383, 8192 centered: ±2 semitones; at `atBeat`, or at the next block.
+    @discardableResult
+    public func pitchBend(_ value: Int32, atBeat: Double? = nil) -> Bool {
+        if let atBeat { return schedule(atBeat, 3, value, 0) }
+        bend = Double(Swift.min(16383, Swift.max(0, value)) - 8192) / 8192 * 2
+        return true
+    }
+
+    /// Puts an event in the queue after those at or before its beat.
+    private func schedule(_ beat: Double, _ kind: Int32, _ a: Int32, _ b: Int32) -> Bool {
+        guard beat.isFinite, queueCount < Self.queueCapacity else { return false }
+        var at = queueCount
+        while at > 0 && queueBeat[at - 1] > beat { at -= 1 }
+        (queueBeat + at + 1).update(from: queueBeat + at, count: queueCount - at)
+        (queueEvent + (at + 1) * 3).update(from: queueEvent + at * 3, count: (queueCount - at) * 3)
+        queueBeat[at] = beat
+        queueEvent[at * 3] = kind
+        queueEvent[at * 3 + 1] = a
+        queueEvent[at * 3 + 2] = b
+        queueCount += 1
+        return true
+    }
+
+    /// Applies what is due: each event whose beat is nearer this frame than the next.
+    private func applyDue(_ step: Double) {
+        while queueCount > 0 && queueBeat[0] < beat + step / 2 {
+            let kind = queueEvent[0]
+            let a = queueEvent[1]
+            let b = queueEvent[2]
+            queueBeat.update(from: queueBeat + 1, count: queueCount - 1)
+            queueEvent.update(from: queueEvent + 3, count: (queueCount - 1) * 3)
+            queueCount -= 1
+            switch kind {
+            case 0: start(a, velocity: b)
+            case 1: release(a)
+            case 2: control(a, value: b)
+            default: pitchBend(a)
+            }
+        }
+    }
+
+    /// Frames to the next waiting event, at most a block's.
+    private func framesToNext(_ step: Double) -> Int {
+        let frames = ((queueBeat[0] - beat) / step).rounded()
+        return frames >= Double(DSPProgram.blockFrames) ? DSPProgram.blockFrames : Swift.max(1, Int(frames))
+    }
+
+    private func start(_ note: Int32, velocity: Int32) {
         if velocity <= 0 {
-            noteOff(note)
+            release(note)
+            return
+        }
+        if let mode = program.mode {
+            // One voice: the newest note, legato while another is held.
+            unstack(note)
+            if stackCount == Self.lanes {
+                (stack).update(from: stack + 1, count: stackCount - 1)
+                stackCount -= 1
+            }
+            stack[stackCount] = note
+            stackCount += 1
+            let held = laneGate[0] > 0.5
+            if laneActive[0] == 0 { resetLane(0) }
+            laneNote[0] = note
+            laneGate[0] = 1
+            laneHeld[0] = false
+            laneVelocity[0] = Float(Double(Swift.min(127, velocity)) / 127)
+            laneActive[0] = 1
+            newestLane = 0
+            if mode == .mono || !held {
+                trigger[0] += 1
+                masterTrigger[0] += 1
+            }
             return
         }
         let voices = program.voices
@@ -191,19 +595,35 @@ public final class DSPMachine: @unchecked Sendable {
         laneVelocity[lane] = Float(Double(Swift.min(127, velocity)) / 127)
         laneActive[lane] = 1
         trigger[lane] += 1
+        masterTrigger[0] += 1
+        newestLane = lane
         age += 1
         laneAge[lane] = age
     }
 
-    public func noteOff(_ note: Int32) {
+    private func release(_ note: Int32) {
+        if let mode = program.mode {
+            unstack(note)
+            guard laneNote[0] == note && laneGate[0] > 0.5 else { return }
+            if stackCount > 0 {
+                // Back to the note held before it.
+                laneNote[0] = stack[stackCount - 1]
+                laneHeld[0] = false
+                if mode == .mono { trigger[0] += 1 }
+            } else if pedal {
+                laneHeld[0] = true
+            } else {
+                laneGate[0] = 0
+            }
+            return
+        }
         for l in 0..<program.voices where laneNote[l] == note && laneGate[l] > 0.5 {
             // Under the pedal the gate stays up until it lifts.
             if pedal { laneHeld[l] = true } else { laneGate[l] = 0 }
         }
     }
 
-    /// 64 the sustain pedal, 120 all sound off, 123 all notes off.
-    public func controller(_ number: Int32, value: Int32) {
+    private func control(_ number: Int32, value: Int32) {
         let L = Self.lanes
         switch number {
         case 64:
@@ -215,24 +635,32 @@ public final class DSPMachine: @unchecked Sendable {
         case 123:
             laneGate.update(repeating: 0, count: L)
             laneHeld.update(repeating: false, count: L)
+            stackCount = 0
         case 120:
+            stackCount = 0
             for l in 0..<L {
                 laneGate[l] = 0
                 laneHeld[l] = false
                 laneActive[l] = 0
                 resetLane(l)
             }
+            resetMaster()
         default:
             break
         }
     }
 
-    /// The pitch wheel, 0 … 16383, 8192 centered: ±2 semitones.
-    public func pitchBend(_ value: Int32) {
-        bend = Double(Swift.min(16383, Swift.max(0, value)) - 8192) / 8192 * 2
+    /// Drops `note` from a mono program's held notes.
+    private func unstack(_ note: Int32) {
+        var kept = 0
+        for i in 0..<stackCount where stack[i] != note {
+            stack[kept] = stack[i]
+            kept += 1
+        }
+        stackCount = kept
     }
 
-    /// Silences every voice at once.
+    /// Silences every voice, and the master stage, at once, and drops what waits.
     public func reset() {
         controller(120, value: 0)
     }
@@ -244,79 +672,202 @@ public final class DSPMachine: @unchecked Sendable {
 
     // MARK: Rendering
 
-    /// Writes `frames` mono frames to `out`, in blocks of up to 128.
+    /// Writes `frames` frames to `out`, in blocks of up to 128: a program's two sides averaged (a mono program's
+    /// samples either way).
     public func render(into out: UnsafeMutablePointer<Float>, frames: Int) {
         var done = 0
         while done < frames {
-            let n = Swift.min(DSPProgram.blockFrames, frames - done)
-            block(out + done, n)
+            let step = tempo / 60 / Double(sampleRate)
+            applyDue(step)
+            // A block ends where the next event is due.
+            let n = Swift.min(DSPProgram.blockFrames, frames - done, queueCount > 0 ? framesToNext(step) : DSPProgram.blockFrames)
+            block(out + done, nil, n)
+            done += n
+        }
+    }
+
+    /// Writes `frames` frames, the left side to `left` and the right to `right`, in blocks of up to 128.
+    public func render(left: UnsafeMutablePointer<Float>, right: UnsafeMutablePointer<Float>, frames: Int) {
+        var done = 0
+        while done < frames {
+            let step = tempo / 60 / Double(sampleRate)
+            applyDue(step)
+            let n = Swift.min(DSPProgram.blockFrames, frames - done, queueCount > 0 ? framesToNext(step) : DSPProgram.blockFrames)
+            block(left + done, right + done, n)
             done += n
         }
     }
 
+    /// A voice starts over: its state and its builtins', not the master stage's.
     private func resetLane(_ l: Int) {
+        // A register holds the program's voices' lanes (a state register's value its lane's first frame).
+        if l < program.voices {
+            for entry in program.state where !entry.master { registers[entry.register * width + l] = entry.initial }
+        }
+        for i in instanceKinds.indices where !instanceMaster[i] { resetInstance(i, l) }
+    }
+
+    /// The master stage starts over, in lane 0.
+    private func resetMaster() {
+        for entry in program.state where entry.master { registers[entry.register * width] = entry.initial }
+        for i in instanceKinds.indices where instanceMaster[i] { resetInstance(i, 0) }
+    }
+
+    private func resetInstance(_ i: Int, _ l: Int) {
         let L = Self.lanes
-        for entry in program.state { registers[entry.register * L + l] = entry.initial }
-        for (i, kind) in instanceKinds.enumerated() {
-            let base = instanceOffsets[i] + l
-            if kind == .noise {
-                let seed = UInt32(truncatingIfNeeded: i + 1) &* 2_654_435_761 &+ UInt32(truncatingIfNeeded: l + 1) &* 2_246_822_519
-                noise[base] = seed == 0 ? 1 : seed
-                continue
-            }
-            for w in 0..<kind.words { state[base + w * L] = 0 }
-            if kind == .adsr {
-                state[base + 4 * L] = .nan
-                state[base + 6 * L] = .nan
-            } else if kind.words == 8 {
-                state[base + 2 * L] = .nan
-            }
+        let kind = instanceKinds[i]
+        let base = instanceOffsets[i] + l
+        let seed = UInt32(truncatingIfNeeded: i + 1) &* 2_654_435_761 &+ UInt32(truncatingIfNeeded: l + 1) &* 2_246_822_519
+        if kind == .noise {
+            noise[base] = seed == 0 ? 1 : seed
+            return
+        }
+        for w in 0..<kind.words { state[base + w * L] = 0 }
+        if kind == .delay || kind == .comb || kind == .allpass {
+            (delaySamples + delayBases[i] + l * delayLengths[i]).update(repeating: 0, count: delayLengths[i])
+        }
+        if kind == .grains {
+            // Its random state, a word of raw bits.
+            UnsafeMutableRawPointer(state + base + L).storeBytes(of: seed == 0 ? 1 : seed, as: UInt32.self)
+        }
+        if kind == .adsr {
+            state[base + 4 * L] = .nan
+            state[base + 6 * L] = .nan
+        } else if kind.words == 8 {
+            state[base + 2 * L] = .nan
+        } else if kind == .smooth {
+            state[base] = .nan
+            state[base + L] = .nan
         }
     }
 
-    private func block(_ out: UnsafeMutablePointer<Float>, _ n: Int) {
+    private func block(_ out: UnsafeMutablePointer<Float>, _ right: UnsafeMutablePointer<Float>?, _ n: Int) {
         let L = Self.lanes
+        let F = Self.frames
+        let W = width
         let R = registers
         let sr = sampleRate
         // Parameters glide toward their targets, about 20 ms.
         let alpha = snapped ? Float(1) : 1 - exp(-Float(n) / (0.02 * sr))
         snapped = false
         for (i, register) in parameterRegisters.enumerated() {
-            let at = R + register * L
-            at.update(repeating: at[0] + (targets[i] - at[0]) * alpha, count: L)
+            let at = R + register * W
+            at.update(repeating: at[0] + (targets[i] - at[0]) * alpha, count: W)
         }
-        var any = false
-        for l in 0..<L where laneActive[l] != 0 { any = true }
-        guard any else {
+        (R + 5 * W).update(repeating: Float(tempo), count: W)
+        let beatStep = tempo / 60 / Double(sr)
+        // The voices run up to the highest that sounds: a note takes the lowest free lane, and an idle one starts
+        // over before it sounds again, so what the ones above would compute is never heard.
+        var lanes = 0
+        for l in 0..<L where laneActive[l] != 0 { lanes = l + 1 }
+        let any = lanes > 0
+        let master = program.master
+        guard any || master != nil else {
+            beat += Double(n) * beatStep
             out.update(repeating: 0, count: n)
+            right?.update(repeating: 0, count: n)
             return
         }
-        for l in 0..<L {
-            let note = laneNote[l]
-            R[1 * L + l] = note >= 0 ? Float(440 * Foundation.pow(2, (Double(note) - 69 + bend) / 12)) : 0
-            R[2 * L + l] = laneGate[l]
-            R[3 * L + l] = laneVelocity[l]
-            R[4 * L + l] = note >= 0 ? Float(note) : 0
+        if any {
+            let V = program.voices
+            for l in 0..<V {
+                let note = laneNote[l]
+                let freq = note >= 0 ? Float(440 * Foundation.pow(2, (Double(note) - 69 + bend) / 12)) : 0
+                for k in 0..<F {
+                    R[1 * W + k * V + l] = freq
+                    R[2 * W + k * V + l] = laneGate[l]
+                    R[3 * W + k * V + l] = laneVelocity[l]
+                    R[4 * W + k * V + l] = note >= 0 ? Float(note) : 0
+                }
+            }
+            run(blockCode, 0..<blockCount, lanes: lanes, trigger: trigger, frames: F)
+        }
+        if master != nil {
+            // The newest note, the master stage's inputs (registers 7 … 10), in lane 0.
+            let l = newestLane
+            let note = l >= 0 ? laneNote[l] : -1
+            let values: [Float] = [
+                note >= 0 ? Float(440 * Foundation.pow(2, (Double(note) - 69 + bend) / 12)) : 0,
+                l >= 0 ? laneGate[l] : 0,
+                l >= 0 ? laneVelocity[l] : 0,
+                note >= 0 ? Float(note) : 0,
+            ]
+            let V = program.voices
+            for (i, value) in values.enumerated() { for k in 0..<F { R[(7 + i) * W + k * V] = value } }
         }
-        run(blockCode, blockCount)
-        let o = R + program.output * L
+        let o = R + program.output * W
+        let or = R + (program.outputRight ?? program.output) * W
+        let V = program.voices
         var check: Float = 0
-        for i in 0..<n {
-            run(sampleCode, sampleCount)
-            var sum: Float = 0
-            for l in 0..<L { sum += o[l] * laneActive[l] }
-            out[i] = sum
-            check += sum
+        // A chunk of up to 16 frames at a time: each instruction over all of them, the serial part frame by frame.
+        var chunk = 0
+        while chunk < n {
+            let fc = Swift.min(F, n - chunk)
+            for k in 0..<fc {
+                for l in 0..<Swift.max(lanes, 1) { R[6 * W + k * V + l] = Float(beat) }
+                beat += beatStep
+            }
+            if any {
+                run(sampleCode, 0..<sampleSerial.lowerBound, lanes: lanes, trigger: trigger, frames: fc)
+                if !sampleSerial.isEmpty {
+                    for k in 0..<fc { run(sampleCode, sampleSerial, lanes: lanes, trigger: trigger, frames: 1, frame: k) }
+                }
+                run(sampleCode, sampleSerial.upperBound..<sampleCount, lanes: lanes, trigger: trigger, frames: fc)
+            }
+            for k in 0..<fc {
+                var leftSum: Float = 0
+                var rightSum: Float = 0
+                // The sounding voices only: an idle one may hold anything (log(0) of its freq, say), and NaN × 0 is NaN.
+                if any {
+                    for l in 0..<lanes where laneActive[l] != 0 {
+                        leftSum += o[k * V + l]
+                        rightSum += or[k * V + l]
+                    }
+                }
+                if let master {
+                    R[master.inputs[0] * W + k * V] = leftSum
+                    R[master.inputs[1] * W + k * V] = rightSum
+                } else {
+                    if let right {
+                        out[chunk + k] = leftSum
+                        right[chunk + k] = rightSum
+                    } else {
+                        out[chunk + k] = (leftSum + rightSum) * 0.5
+                    }
+                    check += leftSum + rightSum
+                }
+            }
+            if let master {
+                run(masterCode, 0..<masterSerial.lowerBound, lanes: 1, trigger: masterTrigger, frames: fc)
+                if !masterSerial.isEmpty {
+                    for k in 0..<fc { run(masterCode, masterSerial, lanes: 1, trigger: masterTrigger, frames: 1, frame: k) }
+                }
+                run(masterCode, masterSerial.upperBound..<masterCount, lanes: 1, trigger: masterTrigger, frames: fc)
+                for k in 0..<fc {
+                    let leftSum = R[master.outputs[0] * W + k * V]
+                    let rightSum = R[master.outputs[1] * W + k * V]
+                    if let right {
+                        out[chunk + k] = leftSum
+                        right[chunk + k] = rightSum
+                    } else {
+                        out[chunk + k] = (leftSum + rightSum) * 0.5
+                    }
+                    check += leftSum + rightSum
+                }
+            }
+            chunk += fc
         }
         guard check.isFinite else {
-            // A voice went to infinity or NaN: silence the block and start every voice over.
+            // A voice or the master stage went to infinity or NaN: silence the block and start everything over.
             out.update(repeating: 0, count: n)
+            right?.update(repeating: 0, count: n)
             for l in 0..<L {
                 laneActive[l] = 0
                 laneGate[l] = 0
                 laneHeld[l] = false
                 resetLane(l)
             }
+            resetMaster()
             return
         }
         // Denormals in the filters' integrators would slow every frame after.
@@ -344,180 +895,667 @@ public final class DSPMachine: @unchecked Sendable {
         return 0
     }
 
-    // The interpreter: one instruction at a time, every lane per instruction.
-    private func run(_ code: UnsafeMutablePointer<Int32>, _ count: Int) {
+    /// A table's, shape's or sample's index from its register: in range, or the first.
+    @inline(__always)
+    private static func index(_ value: Float, _ count: Int) -> Int {
+        value >= 0 && value < Float(count) ? Int(value) : 0
+    }
+
+    // The interpreter: instructions `range` of `code` in the first `lanes` lanes (every voice's, or the master
+    // stage's one), each lane's note on counted in `trigger`, over the chunk's first `frames` frames; or, given a
+    // `frame`, at that frame alone, as the serial part runs (a state register's one value a lane, its first).
+    private func run(
+        _ code: UnsafeMutablePointer<Int32>, _ range: Range<Int>, lanes: Int, trigger: UnsafeMutablePointer<Float>, frames: Int, frame: Int = -1
+    ) {
         let L = Self.lanes
+        let F = Self.frames
         let R = registers
         let S = state
         let N = noise
         let sr = sampleRate
-        var at = 0
-        let end = count * 8
+        let serial = frame >= 0
+        let fc = serial ? 1 : frames
+        let V = program.voices
+        let shift = serial ? frame * V : 0
+        // A stateless instruction: every lane's frames at once (the chunk's last ones, past fc, go unread), the
+        // sounding lanes of each frame; in the serial part, the one frame's.
+        @inline(__always) func each(_ body: (Int) -> Void) {
+            if serial {
+                for l in 0..<lanes { body(l) }
+            } else if lanes == V {
+                for i in 0..<(F * V) { body(i) }
+            } else {
+                for k in 0..<F {
+                    for l in 0..<lanes { body(k * V + l) }
+                }
+            }
+        }
+        var at = range.lowerBound * 12
+        let end = range.upperBound * 12
         while at < end {
             let op = code[at]
-            let d = R + Int(code[at + 1])
-            let a = R + Int(code[at + 2])
-            let b = R + Int(code[at + 3])
-            let c = R + Int(code[at + 4])
+            let states = code[at + 8]
+            // A register at this frame, or a state register's one value.
+            @inline(__always) func register(_ slot: Int) -> UnsafeMutablePointer<Float> {
+                R + Int(code[at + slot]) + (states & (1 << slot) != 0 ? 0 : shift)
+            }
+            let d = register(1)
+            let a = register(2)
+            let b = register(3)
+            let c = register(4)
             switch op {
-            case 0: for l in 0..<L { d[l] = a[l] }
-            case 1: for l in 0..<L { d[l] = a[l] + b[l] }
-            case 2: for l in 0..<L { d[l] = a[l] - b[l] }
-            case 3: for l in 0..<L { d[l] = a[l] * b[l] }
-            case 4: for l in 0..<L { d[l] = a[l] / b[l] }
-            case 5: for l in 0..<L { d[l] = a[l].truncatingRemainder(dividingBy: b[l]) }
-            case 6: for l in 0..<L { d[l] = -a[l] }
-            case 7: for l in 0..<L { d[l] = Swift.min(a[l], b[l]) }
-            case 8: for l in 0..<L { d[l] = Swift.max(a[l], b[l]) }
-            case 9: for l in 0..<L { d[l] = Swift.abs(a[l]) }
-            case 10: for l in 0..<L { d[l] = a[l].rounded(.down) }
-            case 11: for l in 0..<L { d[l] = a[l].rounded(.up) }
-            case 12: for l in 0..<L { d[l] = (a[l] + 0.5).rounded(.down) }
-            case 13: for l in 0..<L { d[l] = a[l].squareRoot() }
-            case 14: for l in 0..<L { d[l] = Foundation.sin(a[l]) }
-            case 15: for l in 0..<L { d[l] = Foundation.cos(a[l]) }
-            case 16: for l in 0..<L { d[l] = Foundation.tan(a[l]) }
-            case 17: for l in 0..<L { d[l] = Foundation.exp(a[l]) }
-            case 18: for l in 0..<L { d[l] = Foundation.log(a[l]) }
-            case 19: for l in 0..<L { d[l] = Foundation.pow(a[l], b[l]) }
-            case 20: for l in 0..<L { d[l] = Foundation.tanh(a[l]) }
-            case 21: for l in 0..<L { d[l] = a[l] < b[l] ? 1 : 0 }
-            case 22: for l in 0..<L { d[l] = a[l] <= b[l] ? 1 : 0 }
-            case 23: for l in 0..<L { d[l] = a[l] > b[l] ? 1 : 0 }
-            case 24: for l in 0..<L { d[l] = a[l] >= b[l] ? 1 : 0 }
-            case 25: for l in 0..<L { d[l] = a[l] == b[l] ? 1 : 0 }
-            case 26: for l in 0..<L { d[l] = a[l] != b[l] ? 1 : 0 }
-            case 27: for l in 0..<L { d[l] = a[l] != 0 && b[l] != 0 ? 1 : 0 }
-            case 28: for l in 0..<L { d[l] = a[l] != 0 || b[l] != 0 ? 1 : 0 }
-            case 29: for l in 0..<L { d[l] = a[l] == 0 ? 1 : 0 }
-            case 30: for l in 0..<L { d[l] = a[l] != 0 ? b[l] : c[l] }
-            case 31: for l in 0..<L { d[l] = Swift.min(Swift.max(a[l], b[l]), c[l]) }
-            case 32: for l in 0..<L { d[l] = a[l] + (b[l] - a[l]) * c[l] }
-            case 33: for l in 0..<L { d[l] = a[l] - a[l].rounded(.down) }
-            case 34: for l in 0..<L { d[l] = a[l] > 0 ? 1 : a[l] < 0 ? -1 : 0 }
-            case 35: for l in 0..<L { d[l] = Foundation.atan(a[l]) }
+            case 0: each { d[$0] = a[$0] }
+            case 1: each { d[$0] = a[$0] + b[$0] }
+            case 2: each { d[$0] = a[$0] - b[$0] }
+            case 3: each { d[$0] = a[$0] * b[$0] }
+            case 4: each { d[$0] = a[$0] / b[$0] }
+            case 5: each { d[$0] = a[$0].truncatingRemainder(dividingBy: b[$0]) }
+            case 6: each { d[$0] = -a[$0] }
+            case 7: each { d[$0] = Swift.min(a[$0], b[$0]) }
+            case 8: each { d[$0] = Swift.max(a[$0], b[$0]) }
+            case 9: each { d[$0] = Swift.abs(a[$0]) }
+            case 10: each { d[$0] = a[$0].rounded(.down) }
+            case 11: each { d[$0] = a[$0].rounded(.up) }
+            case 12: each { d[$0] = (a[$0] + 0.5).rounded(.down) }
+            case 13: each { d[$0] = a[$0].squareRoot() }
+            case 14: each { d[$0] = Foundation.sin(a[$0]) }
+            case 15: each { d[$0] = Foundation.cos(a[$0]) }
+            case 16: each { d[$0] = Foundation.tan(a[$0]) }
+            case 17: each { d[$0] = Foundation.exp(a[$0]) }
+            case 18: each { d[$0] = Foundation.log(a[$0]) }
+            case 19: each { d[$0] = Foundation.pow(a[$0], b[$0]) }
+            case 20: each { d[$0] = Foundation.tanh(a[$0]) }
+            case 21: each { d[$0] = a[$0] < b[$0] ? 1 : 0 }
+            case 22: each { d[$0] = a[$0] <= b[$0] ? 1 : 0 }
+            case 23: each { d[$0] = a[$0] > b[$0] ? 1 : 0 }
+            case 24: each { d[$0] = a[$0] >= b[$0] ? 1 : 0 }
+            case 25: each { d[$0] = a[$0] == b[$0] ? 1 : 0 }
+            case 26: each { d[$0] = a[$0] != b[$0] ? 1 : 0 }
+            case 27: each { d[$0] = a[$0] != 0 && b[$0] != 0 ? 1 : 0 }
+            case 28: each { d[$0] = a[$0] != 0 || b[$0] != 0 ? 1 : 0 }
+            case 29: each { d[$0] = a[$0] == 0 ? 1 : 0 }
+            case 30: each { d[$0] = a[$0] != 0 ? b[$0] : c[$0] }
+            case 31: each { d[$0] = Swift.min(Swift.max(a[$0], b[$0]), c[$0]) }
+            case 32: each { d[$0] = a[$0] + (b[$0] - a[$0]) * c[$0] }
+            case 33: each { d[$0] = a[$0] - a[$0].rounded(.down) }
+            case 34: each { d[$0] = a[$0] > 0 ? 1 : a[$0] < 0 ? -1 : 0 }
+            case 35: each { d[$0] = Foundation.atan(a[$0]) }
+            // The superinstructions: the product or the sum a float, as its own instruction would have stored it.
+            case 58: each { d[$0] = a[$0] * b[$0] + c[$0] }
+            case 59: each { d[$0] = (a[$0] + b[$0]) * c[$0] }
+            case 60: each { d[$0] = Foundation.log2(a[$0]) }
+            case 61: each { d[$0] = Foundation.log10(a[$0]) }
+            case 62: each { d[$0] = Foundation.exp2(a[$0]) }
+            case 63: each { d[$0] = a[$0].rounded(.towardZero) }
+            case 64: each { d[$0] = Foundation.asin(a[$0]) }
+            case 65: each { d[$0] = Foundation.acos(a[$0]) }
+            case 66: each { d[$0] = Foundation.atan2(a[$0], b[$0]) }
+            case 67: each { d[$0] = Foundation.sinh(a[$0]) }
+            case 68: each { d[$0] = Foundation.cosh(a[$0]) }
+            case 69: each { d[$0] = Foundation.cbrt(a[$0]) }
+            case 70: each { d[$0] = Foundation.hypot(a[$0], b[$0]) }
+            case 71: each { d[$0] = Foundation.expm1(a[$0]) }
+            case 72: each { d[$0] = Foundation.log1p(a[$0]) }
+            case 73:
+                // softclip(x): x (27 + x²) / (27 + 9x²) within ±3.
+                each {
+                    let x = a[$0] > -3 ? (a[$0] < 3 ? a[$0] : 3) : -3
+                    let x2 = x * x
+                    d[$0] = x * (27 + x2) / (27 + 9 * x2)
+                }
+            case 74:
+                // onepole(input, cutoff): toward the input by 1 − e^(−2π cutoff / sampleRate) a frame.
+                let s = S + Int(code[at + 7])
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let cutoff = Swift.min(Swift.max(b[el], 0), 0.49 * sr)
+                        if !(s[L + l] == cutoff) {
+                            s[L + l] = cutoff
+                            s[2 * L + l] = 1 - Foundation.exp(-2 * Float.pi * cutoff / sr)
+                        }
+                        let y = s[l]
+                        s[l] = y + (a[el] - y) * s[2 * L + l]
+                        d[el] = s[l]
+                    }
+                }
+            case 75:
+                // dcblock(input): y = x − x before + r × y before, r = 1 − 2π 20 / sampleRate.
+                let s = S + Int(code[at + 7])
+                let r = 1 - Float(125.66370614359172) / sr
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let x = a[el]
+                        let y = (x - s[l]) + r * s[L + l]
+                        s[l] = x
+                        s[L + l] = y
+                        d[el] = y
+                    }
+                }
+            case 76, 77:
+                // comb(input, seconds, feedback, damp, longest): its line read seconds back, between samples, through a
+                // one-pole (damp the share it keeps) back in with the input times feedback. allpass(input, seconds,
+                // gain, longest): w = input + gain × w seconds back, out = w seconds back − gain × w.
+                let s = S + Int(code[at + 7])
+                let length = Int(code[at + 10])
+                let mask = length - 1
+                let memory = delaySamples + Int(code[at + 9])
+                let damping = register(5)
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let w = Int(s[l])
+                        var ds = b[el] * sr
+                        ds = ds >= 1 ? (ds <= Float(length - 2) ? ds : Float(length - 2)) : 1
+                        let position = Float(w) - ds
+                        let i0 = Int(position.rounded(.down))
+                        let fr = position - Float(i0)
+                        let line = memory + l * length
+                        let v0 = line[i0 & mask]
+                        let v = v0 + (line[(i0 + 1) & mask] - v0) * fr
+                        let x = a[el]
+                        let g = c[el]
+                        if op == 76 {
+                            let damp = damping[el] > 0 ? (damping[el] < 1 ? damping[el] : 1) : 0
+                            let store = v * (1 - damp) + s[L + l] * damp
+                            s[L + l] = store
+                            line[w & mask] = x + store * g
+                            d[el] = v
+                        } else {
+                            let into = x + g * v
+                            line[w & mask] = into
+                            d[el] = v - g * into
+                        }
+                        s[l] = Float((w + 1) & mask)
+                    }
+                }
             case 40, 41, 42, 43, 44:
                 // Oscillators: the output from the phase now, then the phase steps by freq / sampleRate.
                 let s = S + Int(code[at + 7])
-                for l in 0..<L {
-                    let p = s[l]
-                    let dt = a[l] / sr
-                    var v: Float
-                    switch op {
-                    case 40: v = p
-                    case 41: v = Foundation.sin(2 * Float.pi * p)
-                    case 42:
-                        v = 2 * p - 1
-                        if dt > 0 { v -= Self.blep(p, dt) }
-                    case 43:
-                        let w = Swift.min(Swift.max(b[l], 0), 1)
-                        v = p < w ? 1 : -1
-                        if dt > 0 {
-                            let q = p + 1 - w
-                            v += Self.blep(p, dt) - Self.blep(q - q.rounded(.down), dt)
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let p = s[l]
+                        let dt = a[el] / sr
+                        var v: Float
+                        switch op {
+                        case 40: v = p
+                        case 41: v = Foundation.sin(2 * Float.pi * p)
+                        case 42:
+                            v = 2 * p - 1
+                            if dt > 0 { v -= Self.blep(p, dt) }
+                        case 43:
+                            let w = Swift.min(Swift.max(b[el], 0), 1)
+                            v = p < w ? 1 : -1
+                            if dt > 0 {
+                                let q = p + 1 - w
+                                v += Self.blep(p, dt) - Self.blep(q - q.rounded(.down), dt)
+                            }
+                        default: v = 1 - 4 * Swift.abs(p - 0.5)
                         }
-                    default: v = 1 - 4 * Swift.abs(p - 0.5)
+                        d[el] = v
+                        let next = p + dt
+                        s[l] = next >= 0 && next < 1 ? next : next - next.rounded(.down)
                     }
-                    d[l] = v
-                    let next = p + dt
-                    s[l] = next - next.rounded(.down)
                 }
             case 45:
                 let s = N + Int(code[at + 7])
-                for l in 0..<L {
-                    var x = s[l]
-                    x ^= x << 13
-                    x ^= x >> 17
-                    x ^= x << 5
-                    s[l] = x
-                    d[l] = Float(Double(x) / 4_294_967_296 * 2 - 1)
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        var x = s[l]
+                        x ^= x << 13
+                        x ^= x >> 17
+                        x ^= x << 5
+                        s[l] = x
+                        d[el] = Float(Double(x) / 4_294_967_296 * 2 - 1)
+                    }
                 }
             case 46:
                 // adsr(gate, attack, decay, sustain, release): stage, level, trigger, gate before, decay time and coefficient, release time and coefficient.
+                // With curves, what it puts out is each stage bent by its exponent, and a stage that starts takes up
+                // where the last left off: its last output, and where a release started.
                 let s = S + Int(code[at + 7])
-                let sustainIn = R + Int(code[at + 5])
-                let releaseIn = R + Int(code[at + 6])
-                for l in 0..<L {
-                    let gate = a[l]
-                    var stage = s[l]
-                    var level = s[L + l]
-                    if s[2 * L + l] != trigger[l] {
-                        s[2 * L + l] = trigger[l]
-                        if gate > 0.5 { stage = 1 }
-                    } else if gate > 0.5 && s[3 * L + l] <= 0.5 {
-                        stage = 1
-                    }
-                    if gate <= 0.5 && stage >= 1 && stage <= 3 { stage = 4 }
-                    s[3 * L + l] = gate
-                    let sustain = Swift.min(Swift.max(sustainIn[l], 0), 1)
-                    if stage == 1 {
-                        level += 1 / Swift.max(1, b[l] * sr)
-                        if level >= 1 {
-                            level = 1
-                            stage = 2
-                        }
-                    } else if stage == 2 {
-                        let time = c[l]
-                        if !(s[4 * L + l] == time) {
-                            s[4 * L + l] = time
-                            s[5 * L + l] = Foundation.exp(-9.2 / Swift.max(1, time * sr))
+                let sustainIn = register(5)
+                let releaseIn = register(6)
+                let curve = Int(code[at + 11]) - 1
+                let curved = curve >= 0
+                let ea = curved ? Double(curveExponents[curve * 3]) : 1
+                let ed = curved ? Double(curveExponents[curve * 3 + 1]) : 1
+                let er = curved ? Double(curveExponents[curve * 3 + 2]) : 1
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let gate = a[el]
+                        var stage = s[l]
+                        var level = s[L + l]
+                        let before = stage
+                        if s[2 * L + l] != trigger[l] {
+                            s[2 * L + l] = trigger[l]
+                            if gate > 0.5 { stage = 1 }
+                        } else if gate > 0.5 && s[3 * L + l] <= 0.5 {
+                            stage = 1
                         }
-                        level = sustain + (level - sustain) * s[5 * L + l]
-                        if level - sustain < 0.0001 { stage = 3 }
-                    } else if stage == 3 {
-                        level = sustain
-                    } else if stage == 4 {
-                        let time = releaseIn[l]
-                        if !(s[6 * L + l] == time) {
-                            s[6 * L + l] = time
-                            s[7 * L + l] = Foundation.exp(-9.2 / Swift.max(1, time * sr))
+                        if gate <= 0.5 && stage >= 1 && stage <= 3 { stage = 4 }
+                        s[3 * L + l] = gate
+                        if curved && stage != before {
+                            let last = s[8 * L + l]
+                            if stage == 1 {
+                                level = last > 0 ? Float(Foundation.pow(Double(last), 1 / ea)) : 0
+                            } else if stage == 4 {
+                                level = last
+                                s[9 * L + l] = last
+                            }
                         }
-                        level *= s[7 * L + l]
-                        if level < 0.0001 {
+                        let sustain = Swift.min(Swift.max(sustainIn[el], 0), 1)
+                        if stage == 1 {
+                            level += 1 / Swift.max(1, b[el] * sr)
+                            if level >= 1 {
+                                level = 1
+                                stage = 2
+                            }
+                        } else if stage == 2 {
+                            let time = c[el]
+                            if !(s[4 * L + l] == time) {
+                                s[4 * L + l] = time
+                                s[5 * L + l] = Foundation.exp(-9.2 / Swift.max(1, time * sr))
+                            }
+                            level = sustain + (level - sustain) * s[5 * L + l]
+                            if level - sustain < 0.0001 { stage = 3 }
+                        } else if stage == 3 {
+                            level = sustain
+                        } else if stage == 4 {
+                            let time = releaseIn[el]
+                            if !(s[6 * L + l] == time) {
+                                s[6 * L + l] = time
+                                s[7 * L + l] = Foundation.exp(-9.2 / Swift.max(1, time * sr))
+                            }
+                            level *= s[7 * L + l]
+                            if level < 0.0001 {
+                                level = 0
+                                stage = 0
+                            }
+                        } else {
                             level = 0
-                            stage = 0
                         }
-                    } else {
-                        level = 0
+                        s[l] = stage
+                        s[L + l] = level
+                        var out = level
+                        if curved {
+                            if stage == 1 {
+                                out = Float(Foundation.pow(Double(level), ea))
+                            } else if stage == 2 {
+                                let span = 1 - sustain
+                                out = span > 1e-6 ? sustain + span * Float(Foundation.pow(Double(Swift.max(0, (level - sustain) / span)), ed)) : level
+                            } else if stage == 4 {
+                                let from = s[9 * L + l]
+                                out = from > 0 ? from * Float(Foundation.pow(Double(Swift.min(1, level / from)), er)) : 0
+                            }
+                            s[8 * L + l] = out
+                        }
+                        d[el] = out
                     }
-                    s[l] = stage
-                    s[L + l] = level
-                    d[l] = level
                 }
             case 47, 48, 49:
                 // A state-variable filter (Simper's form): resonance 0 … 1.
                 let s = S + Int(code[at + 7])
-                for l in 0..<L {
-                    let cutoff = Swift.min(Swift.max(b[l], 10), 0.49 * sr)
-                    let resonance = Swift.min(Swift.max(c[l], 0), 0.98)
-                    if !(s[2 * L + l] == cutoff && s[3 * L + l] == resonance) {
-                        s[2 * L + l] = cutoff
-                        s[3 * L + l] = resonance
-                        let g = Foundation.tan(Float.pi * cutoff / sr)
-                        let k = 2 - 2 * resonance
-                        let a1 = 1 / (1 + g * (g + k))
-                        s[4 * L + l] = a1
-                        s[5 * L + l] = g * a1
-                        s[6 * L + l] = g * g * a1
-                        s[7 * L + l] = k
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let cutoff = Swift.min(Swift.max(b[el], 10), 0.49 * sr)
+                        let resonance = Swift.min(Swift.max(c[el], 0), 0.98)
+                        if !(s[2 * L + l] == cutoff && s[3 * L + l] == resonance) {
+                            s[2 * L + l] = cutoff
+                            s[3 * L + l] = resonance
+                            let g = Foundation.tan(Float.pi * cutoff / sr)
+                            let k = 2 - 2 * resonance
+                            let a1 = 1 / (1 + g * (g + k))
+                            s[4 * L + l] = a1
+                            s[5 * L + l] = g * a1
+                            s[6 * L + l] = g * g * a1
+                            s[7 * L + l] = k
+                        }
+                        let a1 = s[4 * L + l]
+                        let a2 = s[5 * L + l]
+                        let a3 = s[6 * L + l]
+                        let ic1 = s[l]
+                        let ic2 = s[L + l]
+                        let x = a[el]
+                        let v3 = x - ic2
+                        let v1 = a1 * ic1 + a2 * v3
+                        let v2 = ic2 + a2 * ic1 + a3 * v3
+                        s[l] = 2 * v1 - ic1
+                        s[L + l] = 2 * v2 - ic2
+                        d[el] = op == 47 ? v2 : op == 49 ? v1 : x - s[7 * L + l] * v1 - v2
+                    }
+                }
+            case 50:
+                // wavetable(table, freq, position): the level that cannot alias at freq (worked out again only when freq
+                // changes), read between samples and between frames.
+                let s = S + Int(code[at + 7])
+                let T = tableSamples
+                // The table is a constant register's, the same in every lane.
+                let index = a[0]
+                let t = index >= 0 && Int(exactly: index.rounded(.down)).map { $0 < tableCount } == true ? Int(index) : 0
+                let frames = tableFrames.isEmpty ? 1 : tableFrames[t]
+                let base = tableBases.isEmpty ? 0 : tableBases[t]
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let p = s[l]
+                        let f = b[el]
+                        let dt = f / sr
+                        if s[L + l] != f {
+                            s[L + l] = f
+                            var level = 0
+                            let allowed = 0.5 * Double(sr) / Double(Swift.abs(f))
+                            if allowed < 512 {
+                                let octaves = Foundation.log2(512 / allowed)
+                                level = octaves > 8 ? 9 : Int(octaves.rounded(.up))
+                            }
+                            s[2 * L + l] = Float(level)
+                        }
+                        let level = Int(s[2 * L + l])
+                        // NaN reads as 0 here, as in the JavaScript machine.
+                        let morph = c[el] > 0 ? (c[el] < 1 ? c[el] : 1) : 0
+                        let position = morph * Float(frames - 1)
+                        // Never below 0: truncating is rounding down.
+                        let f0 = Int(position)
+                        let f1 = Swift.min(f0 + 1, frames - 1)
+                        let ff = position - Float(f0)
+                        let x = p * 2048
+                        // A phase gone to NaN reads NaN, which the block's check silences.
+                        let i0 = x >= 0 && x < 2048 ? Int(x) : x.isFinite ? Int(x.rounded(.down)) : 0
+                        let fr = x - Float(i0)
+                        let j0 = i0 & 2047
+                        let j1 = (i0 + 1) & 2047
+                        // Samples j0 and j1, each its frames side by side.
+                        let row0 = base + (level * 2048 + j0) * frames
+                        let row1 = base + (level * 2048 + j1) * frames
+                        let v0 = T[row0 + f0] + (T[row1 + f0] - T[row0 + f0]) * fr
+                        let v1 = T[row0 + f1] + (T[row1 + f1] - T[row0 + f1]) * fr
+                        d[el] = v0 + (v1 - v0) * ff
+                        let next = p + dt
+                        s[l] = next >= 0 && next < 1 ? next : next - next.rounded(.down)
+                    }
+                }
+            case 51:
+                // delay(input, seconds, longest): read at least a sample back, between samples, then write.
+                let s = S + Int(code[at + 7])
+                let length = Int(code[at + 10])
+                let mask = length - 1
+                let memory = delaySamples + Int(code[at + 9])
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let w = Int(s[l])
+                        let x = a[el]
+                        var ds = b[el] * sr
+                        ds = ds >= 1 ? (ds <= Float(length - 2) ? ds : Float(length - 2)) : 1
+                        let position = Float(w) - ds
+                        let i0 = Int(position.rounded(.down))
+                        let fr = position - Float(i0)
+                        let line = memory + l * length
+                        let v0 = line[i0 & mask]
+                        let v1 = line[(i0 + 1) & mask]
+                        d[el] = v0 + (v1 - v0) * fr
+                        line[w & mask] = x
+                        s[l] = Float((w + 1) & mask)
+                    }
+                }
+            case 52:
+                // shape(shape, x): x 0 … 1 along it, between points.
+                let P = shapePoints
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let t = Self.index(a[el], shapeLengths.count)
+                        let points = shapeLengths.isEmpty ? 1 : shapeLengths[t]
+                        let base = shapeBases.isEmpty ? 0 : shapeBases[t]
+                        let x = b[el]
+                        let position = (x > 0 ? (x < 1 ? x : 1) : 0) * Float(points - 1)
+                        let i0 = Int(position.rounded(.down))
+                        let v0 = P[base + i0]
+                        let v1 = P[base + Swift.min(i0 + 1, points - 1)]
+                        d[el] = v0 + (v1 - v0) * (position - Float(i0))
+                    }
+                }
+            case 53:
+                // play(sample, rate, start): from start (0 … 1 along it) at each note on, at rate (1 its own pitch),
+                // between samples; silent past either end. Where it plays is a whole sample and the fraction past it,
+                // so it keeps time.
+                let s = S + Int(code[at + 7])
+                let A = sampleAudio
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let t = Self.index(a[el], sampleLengths.count)
+                        let length = sampleLengths.isEmpty ? 2 : sampleLengths[t]
+                        let base = sampleBases.isEmpty ? 0 : sampleBases[t]
+                        if s[2 * L + l] != trigger[l] {
+                            s[2 * L + l] = trigger[l]
+                            let start = c[el]
+                            let p = (start > 0 ? (start < 1 ? start : 1) : 0) * Float(length - 1)
+                            s[l] = p.rounded(.down)
+                            s[L + l] = p - p.rounded(.down)
+                        }
+                        let index = s[l]
+                        let fraction = s[L + l]
+                        var v: Float = 0
+                        if index >= 0 && index < Float(length) {
+                            // Past the last sample, silence.
+                            let k = base + Int(index)
+                            let after = index < Float(length - 1) ? A[k + 1] : 0
+                            v = A[k] + (after - A[k]) * fraction
+                        }
+                        d[el] = v
+                        var step = b[el] * (sampleRatios.isEmpty ? 1 : sampleRatios[t])
+                        step = step > -65536 ? (step < 65536 ? step : 65536) : -65536
+                        let next = fraction + step
+                        let whole = next.rounded(.down)
+                        let moved = index + whole
+                        s[l] = moved > -1 ? (moved < Float(length) ? moved : Float(length)) : -1
+                        s[L + l] = next - whole
+                    }
+                }
+            case 78:
+                // tableread(table, phase, freq, position): wavetable's read, at a phase the program keeps (wrapped to
+                // 0 … 1), at the level that cannot alias at freq (worked out again only when freq changes).
+                let s = S + Int(code[at + 7])
+                let T = tableSamples
+                let e = register(5)
+                // The table is a constant register's, the same in every lane.
+                let index = a[0]
+                let t = index >= 0 && Int(exactly: index.rounded(.down)).map { $0 < tableCount } == true ? Int(index) : 0
+                let frames = tableFrames.isEmpty ? 1 : tableFrames[t]
+                let base = tableBases.isEmpty ? 0 : tableBases[t]
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let f = c[el]
+                        if s[l] != f {
+                            s[l] = f
+                            var level = 0
+                            let allowed = 0.5 * Double(sr) / Double(Swift.abs(f))
+                            if allowed < 512 {
+                                let octaves = Foundation.log2(512 / allowed)
+                                level = octaves > 8 ? 9 : Int(octaves.rounded(.up))
+                            }
+                            s[L + l] = Float(level)
+                        }
+                        let level = Int(s[L + l])
+                        let morph = e[el] > 0 ? (e[el] < 1 ? e[el] : 1) : 0
+                        let position = morph * Float(frames - 1)
+                        let f0 = Int(position)
+                        let f1 = Swift.min(f0 + 1, frames - 1)
+                        let ff = position - Float(f0)
+                        let phase = b[el]
+                        // 0 … 1 (1 itself, as a phase just below 0 rounds to); NaN past infinities.
+                        let p = phase - phase.rounded(.down)
+                        let x = p * 2048
+                        let i0 = x >= 0 && x <= 2048 ? Int(x) : 0
+                        let fr = x - Float(i0)
+                        let j0 = i0 & 2047
+                        let j1 = (i0 + 1) & 2047
+                        let row0 = base + (level * 2048 + j0) * frames
+                        let row1 = base + (level * 2048 + j1) * frames
+                        let v0 = T[row0 + f0] + (T[row1 + f0] - T[row0 + f0]) * fr
+                        let v1 = T[row0 + f1] + (T[row1 + f1] - T[row0 + f1]) * fr
+                        d[el] = v0 + (v1 - v0) * ff
+                    }
+                }
+            case 79:
+                // loop(sample, rate, start): play's, but round and round: past either end it comes in at the other.
+                let s = S + Int(code[at + 7])
+                let A = sampleAudio
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let t = Self.index(a[el], sampleLengths.count)
+                        let length = sampleLengths.isEmpty ? 2 : sampleLengths[t]
+                        let base = sampleBases.isEmpty ? 0 : sampleBases[t]
+                        if s[2 * L + l] != trigger[l] {
+                            s[2 * L + l] = trigger[l]
+                            let start = c[el]
+                            let p = (start > 0 ? (start < 1 ? start : 1) : 0) * Float(length - 1)
+                            s[l] = p.rounded(.down)
+                            s[L + l] = p - p.rounded(.down)
+                        }
+                        // Always a sample of this one, though a lane's index may change samples under it.
+                        let index = ((Int(s[l]) % length) + length) % length
+                        let fraction = s[L + l]
+                        let k = base + index
+                        let after = index < length - 1 ? A[k + 1] : A[base]
+                        d[el] = A[k] + (after - A[k]) * fraction
+                        var step = b[el] * (sampleRatios.isEmpty ? 1 : sampleRatios[t])
+                        step = step > -65536 ? (step < 65536 ? step : 65536) : -65536
+                        let next = fraction + step
+                        let whole = next.rounded(.down)
+                        s[l] = Float((((index + Int(whole)) % length) + length) % length)
+                        s[L + l] = next - whole
+                    }
+                }
+            case 54:
+                // grains(sample, position, density, length, pitch): a grain every 1 / density seconds from position
+                // (0 … 1 along the sample, and up to 20 ms on), length seconds (0.001 … 1) long, at pitch (1/16 …
+                // 16, 1 its own), under a parabola; up to 8 at once (with none free, one is skipped).
+                let s = S + Int(code[at + 7])
+                let lengthIn = register(5)
+                let pitchIn = register(6)
+                let A = sampleAudio
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let t = Self.index(a[el], sampleLengths.count)
+                        let length = sampleLengths.isEmpty ? 2 : sampleLengths[t]
+                        let base = sampleBases.isEmpty ? 0 : sampleBases[t]
+                        let ratio = sampleRatios.isEmpty ? 1 : sampleRatios[t]
+                        let density = c[el]
+                        var countdown = s[l]
+                        if density > 0 {
+                            if countdown <= 0 {
+                                var g = 0
+                                while g < 8 && s[(3 + 4 * g) * L + l] < s[(4 + 4 * g) * L + l] { g += 1 }
+                                if g < 8 {
+                                    let random = UnsafeMutableRawPointer(s + L + l)
+                                    var x = random.load(as: UInt32.self)
+                                    x ^= x << 13
+                                    x ^= x >> 17
+                                    x ^= x << 5
+                                    random.storeBytes(of: x, as: UInt32.self)
+                                    let position = b[el]
+                                    let spray = sampleSprays.isEmpty ? 1 : sampleSprays[t]
+                                    let start = ((position > 0 ? (position < 1 ? position : 1) : 0) * Float(length - 1)).rounded(.down) + Float(x % spray)
+                                    let seconds = lengthIn[el]
+                                    let frames = ((seconds > 0.001 ? (seconds < 1 ? seconds : 1) : 0.001) * sr).rounded(.down)
+                                    let pitch = pitchIn[el]
+                                    let w = s + (2 + 4 * g) * L + l
+                                    w[0] = start < Float(length - 1) ? start : Float(length - 1)
+                                    w[L] = 0
+                                    w[2 * L] = frames > 1 ? frames : 1
+                                    w[3 * L] = (pitch > 0.0625 ? (pitch < 16 ? pitch : 16) : 0.0625) * ratio
+                                }
+                                let interval = sr / density
+                                countdown += interval > 1 ? interval : 1
+                            }
+                            countdown -= 1
+                        } else {
+                            countdown = 0
+                        }
+                        s[l] = countdown
+                        var sum: Float = 0
+                        for g in 0..<8 {
+                            let w = s + (2 + 4 * g) * L + l
+                            let age = w[L]
+                            let frames = w[2 * L]
+                            guard age < frames else { continue }
+                            let offset = age * w[3 * L]
+                            let whole = offset.rounded(.down)
+                            let index = w[0] + whole
+                            if index >= 0 && index < Float(length - 1) {
+                                let k = base + Int(index)
+                                let v = A[k] + (A[k + 1] - A[k]) * (offset - whole)
+                                let phase = age / frames
+                                sum += v * (4 * phase * (1 - phase))
+                            }
+                            w[L] = age + 1
+                        }
+                        d[el] = sum
+                    }
+                }
+            case 57:
+                // modsum(routes): Σ amount × source over the list, route by route. An amount is a parameter, the same
+                // in every lane, so a route at 0 is passed over once for all of them and costs nothing.
+                each { d[$0] = 0 }
+                let index = Self.index(a[0], routeStarts.count - 1)
+                guard index < routeStarts.count - 1 else { break }
+                var k = routeStarts[index]
+                let end = routeStarts[index + 1]
+                while k < end {
+                    let amount = R + routeRegisters[k + 1]
+                    let source = R + routeRegisters[k] + (routeState[k] ? 0 : shift)
+                    k += 2
+                    if amount[0] == 0 { continue }
+                    each { d[$0] += amount[$0] * source[$0] }
+                }
+            case 55:
+                // smooth(input, seconds): toward the input by 1 − e^(−1 / (seconds × sampleRate)) a frame, from where
+                // the input is on its first.
+                let s = S + Int(code[at + 7])
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let x = a[el]
+                        var y = s[l]
+                        if y.isNaN { y = x }
+                        let time = b[el]
+                        if !(s[L + l] == time) {
+                            s[L + l] = time
+                            let frames = time * sr
+                            s[2 * L + l] = frames > 1 ? -Foundation.expm1(-1 / frames) : 1
+                        }
+                        y += (x - y) * s[2 * L + l]
+                        s[l] = y
+                        d[el] = y
+                    }
+                }
+            case 56:
+                // hold(input, trigger): takes the input as the trigger rises above 0.5, and keeps it.
+                let s = S + Int(code[at + 7])
+                for fk in 0..<fc {
+                    for l in 0..<lanes {
+                        let el = fk * V + l
+                        let t = b[el]
+                        if t > 0.5 && !(s[L + l] > 0.5) { s[l] = a[el] }
+                        s[L + l] = t
+                        d[el] = s[l]
                     }
-                    let a1 = s[4 * L + l]
-                    let a2 = s[5 * L + l]
-                    let a3 = s[6 * L + l]
-                    let ic1 = s[l]
-                    let ic2 = s[L + l]
-                    let x = a[l]
-                    let v3 = x - ic2
-                    let v1 = a1 * ic1 + a2 * v3
-                    let v2 = ic2 + a2 * ic1 + a3 * v3
-                    s[l] = 2 * v1 - ic1
-                    s[L + l] = 2 * v2 - ic2
-                    d[l] = op == 47 ? v2 : op == 49 ? v1 : x - s[7 * L + l] * v1 - v2
                 }
             default:
                 break
             }
-            at += 8
+            at += 12
         }
     }
 }