@oletizi/audio-tools/modules/sampler-devices/src/devices/s3000xl.ts

Monorepo for hardware sampler utilities and format parsers

//
// GENERATED Fri Oct 03 2025 22:37:37 GMT-0700 (Pacific Daylight Time). DO NOT EDIT.
//
import {byte2nibblesLE, bytes2numberLE, nibbles2byte, newClientOutput} from "@oletizi/sampler-lib"
import {nextByte, akaiByte2String, string2AkaiBytes} from "@/utils/akai-utils.js"

export interface ProgramHeader {
  KGRP1: number    // Block address of first keygroup (internal use)
  KGRP1Label: string

  PRNAME: string    // Name of program
  PRNAMELabel: string

  PRGNUM: number    // MIDI program number; Range: 0 to 128; After sending data to this parameter, Miscellaneous function BTSORT should be triggered to resort the list of programs into order and to flag active programs.
  PRGNUMLabel: string

  PMCHAN: number    // MIDI channel; Range: 255 signifies OMNI, 0 to 15 indicate MIDI channel
  PMCHANLabel: string

  POLYPH: number    // Depth of polyphony; Range: 0 to 31 (these represent polyphony values of 1 to 32)
  POLYPHLabel: string

  PRIORT: number    // Priority of voices playing this program; Range: 0=low, 1=norm, 2=high, 3=hold
  PRIORTLabel: string

  PLAYLO: number    // Lower limit of play range; Range: 21 to 127 represents A1 to G8
  PLAYLOLabel: string

  PLAYHI: number    // Upper limit of play range
  PLAYHILabel: string

  OSHIFT: number    // Not used
  OSHIFTLabel: string

  OUTPUT: number    // Individual output routing. This parameter also controls send to effects section.
  OUTPUTLabel: string

  STEREO: number    // Left and right output levels; Range: 0 to 99
  STEREOLabel: string

  PANPOS: number    // Balance between left and right outputs; Range: -50 to +50
  PANPOSLabel: string

  PRLOUD: number    // Basic loudness of this program; Range: 0 to 99
  PRLOUDLabel: string

  V_LOUD: number    // Note-on velocity dependence of loudness; Range: -50 to +50
  V_LOUDLabel: string

  K_LOUD: number    // Not used
  K_LOUDLabel: string

  P_LOUD: number    // Not used
  P_LOUDLabel: string

  PANRAT: number    // Speed of LFO2; 0 to 99
  PANRATLabel: string

  PANDEP: number    // Depth of LFO2
  PANDEPLabel: string

  PANDEL: number    // Delay in growth of LFO2
  PANDELLabel: string

  K_PANP: number    // Not used
  K_PANPLabel: string

  LFORAT: number    // Speed of LFO1
  LFORATLabel: string

  LFODEP: number    // Depth of LFO1
  LFODEPLabel: string

  LFODEL: number    // Delay in growth of LFO1
  LFODELLabel: string

  MWLDEP: number    // Amount of control of LFO1 depth by Modwheel
  MWLDEPLabel: string

  PRSDEP: number    // Amount of control of LFO1 depth by Aftertouch
  PRSDEPLabel: string

  VELDEP: number    // Amount of control of LFO1 depth by Note-On velocity
  VELDEPLabel: string

  B_PTCH: number    // Range of increase of Pitch by bendwheel
  B_PTCHLabel: string

  P_PTCH: number    // Amount of control of Pitch by Pressure
  P_PTCHLabel: string

  KXFADE: number    // Keygroup crossfade enable
  KXFADELabel: string

  GROUPS: number    // Number of keygroups. To change the number of keygroups in a program, the KDATA and DELK commands should be used.
  GROUPSLabel: string

  TPNUM: number    // Temporary program number (internal use)
  TPNUMLabel: string

  TEMPER: string    // Key temperament C, C#, D, D# etc.
  TEMPERLabel: string

  ECHOUT: number    // Not used
  ECHOUTLabel: string

  MW_PAN: number    // Not used
  MW_PANLabel: string

  COHERE: number    // Not used
  COHERELabel: string

  DESYNC: number    // Enable de-synchronisation of LFO1 across notes;  0 represents OFF, 1 represents ON
  DESYNCLabel: string

  PLAW: number    // Not used
  PLAWLabel: string

  VASSOQ: number    // Criterion by which voices are stolen; 0 represents OLDEST, 1 represents QUIETEST
  VASSOQLabel: string

  SPLOUD: number    // Reduction in loudness due to soft pedal
  SPLOUDLabel: string

  SPATT: number    // Stretch of attack due to soft pedal
  SPATTLabel: string

  SPFILT: number    // Reduction of filter frequency due to soft pedal
  SPFILTLabel: string

  PTUNO: number    // Tuning offset of program; -50.00 to +50.00 (fraction is binary)
  PTUNOLabel: string

  K_LRAT: number    // Not used
  K_LRATLabel: string

  K_LDEP: number    // Not used
  K_LDEPLabel: string

  K_LDEL: number    // Not used
  K_LDELLabel: string

  VOSCL: number    // Level sent to Individual outputs/effects
  VOSCLLabel: string

  VSSCL: number    // Not used
  VSSCLLabel: string

  LEGATO: number    // Mono legato mode enable; 0 represents OFF, 1 represents ON
  LEGATOLabel: string

  B_PTCHD: number    // Range of decrease of Pitch by bendwheel
  B_PTCHDLabel: string

  B_MODE: number    // Bending of held notes; 0 represents NORMAL mode, 1 represents HELD mode
  B_MODELabel: string

  TRANSPOSE: number    // Shift pitch of incoming MIDI
  TRANSPOSELabel: string

  MODSPAN1: number    // First source of assignable modulation of pan position
  MODSPAN1Label: string

  MODSPAN2: number    // Second source of assignable modulation of pan
  MODSPAN2Label: string

  MODSPAN3: number    // Third source of assignable modulation of pan
  MODSPAN3Label: string

  MODSAMP1: number    // First source of assignable modulation of loudness
  MODSAMP1Label: string

  MODSAMP2: number    // Second source of assignable modulation of loudness
  MODSAMP2Label: string

  MODSLFOT: number    // Source of assignable modulation of LFO1 speed
  MODSLFOTLabel: string

  MODSLFOL: number    // Source of assignable modulation of LFO1 depth
  MODSLFOLLabel: string

  MODSLFOD: number    // Source of assignable modulation of LFO1 delay
  MODSLFODLabel: string

  MODSFILT1: number    // First source of assignable modulation of filter frequency
  MODSFILT1Label: string

  MODSFILT2: number    // Second source of assignable modulation of filter frequency
  MODSFILT2Label: string

  MODSFILT3: number    // Third source of assignable modulation of filter frequency
  MODSFILT3Label: string

  MODSPITCH: number    // Source of assignable modulation of pitch
  MODSPITCHLabel: string

  MODSAMP3: number    // Third source of assignable modulation of loudness
  MODSAMP3Label: string

  MODVPAN1: number    // Amount of control of pan by assignable source 1
  MODVPAN1Label: string

  MODVPAN2: number    // Amount of control of pan by assignable source 2
  MODVPAN2Label: string

  MODVPAN3: number    // Amount of control of pan by assignable source 3
  MODVPAN3Label: string

  MODVAMP1: number    // Amount of control of loudness by assignable source 1
  MODVAMP1Label: string

  MODVAMP2: number    // Amount of control of loudness by assignable source 2
  MODVAMP2Label: string

  MODVLFOR: number    // Amount of control of LFO1 speed
  MODVLFORLabel: string

  MODVLVOL: number    // Amount of control of LFO1 depth
  MODVLVOLLabel: string

  MODVLFOD: number    // Amount of control of LFO1 delay
  MODVLFODLabel: string

  LFO1WAVE: number    // LFO1 waveform; 0 represents Triangle, 1 represents Sawtooth, 2 represents Square
  LFO1WAVELabel: string

  LFO2WAVE: number    // LFO2 waveform
  LFO2WAVELabel: string

  MODSLFLT2_1: number    // First source of assignable modulation of filter 2 frequency (only used on S3200).
  MODSLFLT2_1Label: string

  MODSLFLT2_2: number    // Second source of assignable modulation of filter 2 frequency (only used on S3200).
  MODSLFLT2_2Label: string

  MODSLFLT2_3: number    // Third source of assignable modulation of filter 2 frequency (only used on S3200).
  MODSLFLT2_3Label: string

  LFO2TRIG: number    // Retrigger mode for LFO2
  LFO2TRIGLabel: string

  RESERVED_1: number    // Not used
  RESERVED_1Label: string

  PORTIME: number    // PORTAMENTO TIME
  PORTIMELabel: string

  PORTYPE: number    // PORTAMENTO TYPE
  PORTYPELabel: string

  PORTEN: number    // PORTAMENTO ON/OFF
  PORTENLabel: string

  PFXCHAN: number    // Effects Bus Select; 0 to 4
  PFXCHANLabel: string

  raw: number[] // Raw sysex message data
}


export function parseProgramHeader(data: number[], offset: number, o: ProgramHeader) {
    const out = newClientOutput(false, 'parseProgramHeader')
    const v = {value: 0, offset: offset * 2}

    let b: number[]
    function reloff() {
        // This calculates the current offset into the header data so it will match with the Akai sysex docs for sanity checking. See https://lakai.sourceforge.net/docs/s2800_sysex.html
        // As such, The math here is weird: 
        // * Each offset "byte" in the docs is actually two little-endian nibbles, each of which take up a slot in the midi data array--hence v.offset /2 
        return (v.offset / 2)
    }

    // Block address of first keygroup (internal use)
    out.log('KGRP1: offset: ' + reloff())
    b = []
    for (let i=0; i<2; i++) {
        b.push(nextByte(data, v).value)
    }
    o.KGRP1 = bytes2numberLE(b)

    // Name of program
    out.log('PRNAME: offset: ' + reloff())
    o["PRNAMELabel"] = "Program Name"
    o.PRNAME = ''
    for (let i = 0; i < 12; i++) {
          nextByte(data, v)
          o.PRNAME += akaiByte2String([v.value])
          out.log('PRNAME at ' + i + ': ' + o.PRNAME)    }

    // MIDI program number; Range: 0 to 128; After sending data to this parameter, Miscellaneous function BTSORT should be triggered to resort the list of programs into order and to flag active programs.
    out.log('PRGNUM: offset: ' + reloff())
    o["PRGNUMLabel"] = "Program Number"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.PRGNUM = bytes2numberLE(b)

    // MIDI channel; Range: 255 signifies OMNI, 0 to 15 indicate MIDI channel
    out.log('PMCHAN: offset: ' + reloff())
    o["PMCHANLabel"] = "MIDI Channel"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.PMCHAN = bytes2numberLE(b)

    // Depth of polyphony; Range: 0 to 31 (these represent polyphony values of 1 to 32)
    out.log('POLYPH: offset: ' + reloff())
    o["POLYPHLabel"] = "Polyphony"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.POLYPH = bytes2numberLE(b)

    // Priority of voices playing this program; Range: 0=low, 1=norm, 2=high, 3=hold
    out.log('PRIORT: offset: ' + reloff())
    o["PRIORTLabel"] = "Voice Priority"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.PRIORT = bytes2numberLE(b)

    // Lower limit of play range; Range: 21 to 127 represents A1 to G8
    out.log('PLAYLO: offset: ' + reloff())
    o["PLAYLOLabel"] = "Low Note"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.PLAYLO = bytes2numberLE(b)

    // Upper limit of play range
    out.log('PLAYHI: offset: ' + reloff())
    o["PLAYHILabel"] = "High Note"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.PLAYHI = bytes2numberLE(b)

    // Not used
    out.log('OSHIFT: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.OSHIFT = bytes2numberLE(b)

    // Individual output routing. This parameter also controls send to effects section.
    out.log('OUTPUT: offset: ' + reloff())
    o["OUTPUTLabel"] = "Output"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.OUTPUT = bytes2numberLE(b)

    // Left and right output levels; Range: 0 to 99
    out.log('STEREO: offset: ' + reloff())
    o["STEREOLabel"] = "Stereo Output Lvl"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.STEREO = bytes2numberLE(b)

    // Balance between left and right outputs; Range: -50 to +50
    out.log('PANPOS: offset: ' + reloff())
    o["PANPOSLabel"] = "Pan"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.PANPOS = bytes2numberLE(b)

    // Basic loudness of this program; Range: 0 to 99
    out.log('PRLOUD: offset: ' + reloff())
    o["PRLOUDLabel"] = "Program Level"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.PRLOUD = bytes2numberLE(b)

    // Note-on velocity dependence of loudness; Range: -50 to +50
    out.log('V_LOUD: offset: ' + reloff())
    o["V_LOUDLabel"] = "Vel -> Amp"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.V_LOUD = bytes2numberLE(b)

    // Not used
    out.log('K_LOUD: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.K_LOUD = bytes2numberLE(b)

    // Not used
    out.log('P_LOUD: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.P_LOUD = bytes2numberLE(b)

    // Speed of LFO2; 0 to 99
    out.log('PANRAT: offset: ' + reloff())
    o["PANRATLabel"] = "Pan (LFO2) Rate"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.PANRAT = bytes2numberLE(b)

    // Depth of LFO2
    out.log('PANDEP: offset: ' + reloff())
    o["PANDEPLabel"] = "Pan (LFO2) Depth"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.PANDEP = bytes2numberLE(b)

    // Delay in growth of LFO2
    out.log('PANDEL: offset: ' + reloff())
    o["PANDELLabel"] = "Pan (LFO2) Delay"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.PANDEL = bytes2numberLE(b)

    // Not used
    out.log('K_PANP: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.K_PANP = bytes2numberLE(b)

    // Speed of LFO1
    out.log('LFORAT: offset: ' + reloff())
    o["LFORATLabel"] = "LFO1 Rate"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.LFORAT = bytes2numberLE(b)

    // Depth of LFO1
    out.log('LFODEP: offset: ' + reloff())
    o["LFODEPLabel"] = "LFO1 Depth"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.LFODEP = bytes2numberLE(b)

    // Delay in growth of LFO1
    out.log('LFODEL: offset: ' + reloff())
    o["LFODELLabel"] = "LFO1 Delay"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.LFODEL = bytes2numberLE(b)

    // Amount of control of LFO1 depth by Modwheel
    out.log('MWLDEP: offset: ' + reloff())
    o["MWLDEPLabel"] = "Modwheel -> LFO1"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MWLDEP = bytes2numberLE(b)

    // Amount of control of LFO1 depth by Aftertouch
    out.log('PRSDEP: offset: ' + reloff())
    o["PRSDEPLabel"] = "After -> LFO1"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.PRSDEP = bytes2numberLE(b)

    // Amount of control of LFO1 depth by Note-On velocity
    out.log('VELDEP: offset: ' + reloff())
    o["VELDEPLabel"] = "Vel -> LFO1"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.VELDEP = bytes2numberLE(b)

    // Range of increase of Pitch by bendwheel
    out.log('B_PTCH: offset: ' + reloff())
    o["B_PTCHLabel"] = "Bend Up -> Pitch"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.B_PTCH = bytes2numberLE(b)

    // Amount of control of Pitch by Pressure
    out.log('P_PTCH: offset: ' + reloff())
    o["P_PTCHLabel"] = "Pressure -> Pitch"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.P_PTCH = bytes2numberLE(b)

    // Keygroup crossfade enable
    out.log('KXFADE: offset: ' + reloff())
    o["KXFADELabel"] = "Crossfade [on | off]"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.KXFADE = bytes2numberLE(b)

    // Number of keygroups. To change the number of keygroups in a program, the KDATA and DELK commands should be used.
    out.log('GROUPS: offset: ' + reloff())
    o["GROUPSLabel"] = "Keygroup Count"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.GROUPS = bytes2numberLE(b)

    // Temporary program number (internal use)
    out.log('TPNUM: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.TPNUM = bytes2numberLE(b)

    // Key temperament C, C#, D, D# etc.
    out.log('TEMPER: offset: ' + reloff())
    o["TEMPERLabel"] = "Key"
    o.TEMPER = ''
    for (let i = 0; i < 12; i++) {
          nextByte(data, v)
          o.TEMPER += akaiByte2String([v.value])
          out.log('TEMPER at ' + i + ': ' + o.TEMPER)    }

    // Not used
    out.log('ECHOUT: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.ECHOUT = bytes2numberLE(b)

    // Not used
    out.log('MW_PAN: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MW_PAN = bytes2numberLE(b)

    // Not used
    out.log('COHERE: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.COHERE = bytes2numberLE(b)

    // Enable de-synchronisation of LFO1 across notes;  0 represents OFF, 1 represents ON
    out.log('DESYNC: offset: ' + reloff())
    o["DESYNCLabel"] = "LFO desync [on | off]"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.DESYNC = bytes2numberLE(b)

    // Not used
    out.log('PLAW: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.PLAW = bytes2numberLE(b)

    // Criterion by which voices are stolen; 0 represents OLDEST, 1 represents QUIETEST
    out.log('VASSOQ: offset: ' + reloff())
    o["VASSOQLabel"] = "Stealing [age | vel]"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.VASSOQ = bytes2numberLE(b)

    // Reduction in loudness due to soft pedal
    out.log('SPLOUD: offset: ' + reloff())
    o["SPLOUDLabel"] = "Pedal -> Amp"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.SPLOUD = bytes2numberLE(b)

    // Stretch of attack due to soft pedal
    out.log('SPATT: offset: ' + reloff())
    o["SPATTLabel"] = "Pedal -> Attack"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.SPATT = bytes2numberLE(b)

    // Reduction of filter frequency due to soft pedal
    out.log('SPFILT: offset: ' + reloff())
    o["SPFILTLabel"] = "Pedal -> Cutoff"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.SPFILT = bytes2numberLE(b)

    // Tuning offset of program; -50.00 to +50.00 (fraction is binary)
    out.log('PTUNO: offset: ' + reloff())
    o["PTUNOLabel"] = "Tuning"
    b = []
    for (let i=0; i<2; i++) {
        b.push(nextByte(data, v).value)
    }
    o.PTUNO = bytes2numberLE(b)

    // Not used
    out.log('K_LRAT: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.K_LRAT = bytes2numberLE(b)

    // Not used
    out.log('K_LDEP: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.K_LDEP = bytes2numberLE(b)

    // Not used
    out.log('K_LDEL: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.K_LDEL = bytes2numberLE(b)

    // Level sent to Individual outputs/effects
    out.log('VOSCL: offset: ' + reloff())
    o["VOSCLLabel"] = "VOSCL"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.VOSCL = bytes2numberLE(b)

    // Not used
    out.log('VSSCL: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.VSSCL = bytes2numberLE(b)

    // Mono legato mode enable; 0 represents OFF, 1 represents ON
    out.log('LEGATO: offset: ' + reloff())
    o["LEGATOLabel"] = "Legato [on | off]"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.LEGATO = bytes2numberLE(b)

    // Range of decrease of Pitch by bendwheel
    out.log('B_PTCHD: offset: ' + reloff())
    o["B_PTCHDLabel"] = "Bend Down -> Pitch"
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.B_PTCHD = bytes2numberLE(b)

    // Bending of held notes; 0 represents NORMAL mode, 1 represents HELD mode
    out.log('B_MODE: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.B_MODE = bytes2numberLE(b)

    // Shift pitch of incoming MIDI
    out.log('TRANSPOSE: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.TRANSPOSE = bytes2numberLE(b)

    // First source of assignable modulation of pan position
    out.log('MODSPAN1: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODSPAN1 = bytes2numberLE(b)

    // Second source of assignable modulation of pan
    out.log('MODSPAN2: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODSPAN2 = bytes2numberLE(b)

    // Third source of assignable modulation of pan
    out.log('MODSPAN3: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODSPAN3 = bytes2numberLE(b)

    // First source of assignable modulation of loudness
    out.log('MODSAMP1: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODSAMP1 = bytes2numberLE(b)

    // Second source of assignable modulation of loudness
    out.log('MODSAMP2: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODSAMP2 = bytes2numberLE(b)

    // Source of assignable modulation of LFO1 speed
    out.log('MODSLFOT: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODSLFOT = bytes2numberLE(b)

    // Source of assignable modulation of LFO1 depth
    out.log('MODSLFOL: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODSLFOL = bytes2numberLE(b)

    // Source of assignable modulation of LFO1 delay
    out.log('MODSLFOD: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODSLFOD = bytes2numberLE(b)

    // First source of assignable modulation of filter frequency
    out.log('MODSFILT1: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODSFILT1 = bytes2numberLE(b)

    // Second source of assignable modulation of filter frequency
    out.log('MODSFILT2: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODSFILT2 = bytes2numberLE(b)

    // Third source of assignable modulation of filter frequency
    out.log('MODSFILT3: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODSFILT3 = bytes2numberLE(b)

    // Source of assignable modulation of pitch
    out.log('MODSPITCH: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODSPITCH = bytes2numberLE(b)

    // Third source of assignable modulation of loudness
    out.log('MODSAMP3: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODSAMP3 = bytes2numberLE(b)

    // Amount of control of pan by assignable source 1
    out.log('MODVPAN1: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODVPAN1 = bytes2numberLE(b)

    // Amount of control of pan by assignable source 2
    out.log('MODVPAN2: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODVPAN2 = bytes2numberLE(b)

    // Amount of control of pan by assignable source 3
    out.log('MODVPAN3: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODVPAN3 = bytes2numberLE(b)

    // Amount of control of loudness by assignable source 1
    out.log('MODVAMP1: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODVAMP1 = bytes2numberLE(b)

    // Amount of control of loudness by assignable source 2
    out.log('MODVAMP2: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODVAMP2 = bytes2numberLE(b)

    // Amount of control of LFO1 speed
    out.log('MODVLFOR: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODVLFOR = bytes2numberLE(b)

    // Amount of control of LFO1 depth
    out.log('MODVLVOL: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODVLVOL = bytes2numberLE(b)

    // Amount of control of LFO1 delay
    out.log('MODVLFOD: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODVLFOD = bytes2numberLE(b)

    // LFO1 waveform; 0 represents Triangle, 1 represents Sawtooth, 2 represents Square
    out.log('LFO1WAVE: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.LFO1WAVE = bytes2numberLE(b)

    // LFO2 waveform
    out.log('LFO2WAVE: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.LFO2WAVE = bytes2numberLE(b)

    // First source of assignable modulation of filter 2 frequency (only used on S3200).
    out.log('MODSLFLT2_1: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODSLFLT2_1 = bytes2numberLE(b)

    // Second source of assignable modulation of filter 2 frequency (only used on S3200).
    out.log('MODSLFLT2_2: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODSLFLT2_2 = bytes2numberLE(b)

    // Third source of assignable modulation of filter 2 frequency (only used on S3200).
    out.log('MODSLFLT2_3: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.MODSLFLT2_3 = bytes2numberLE(b)

    // Retrigger mode for LFO2
    out.log('LFO2TRIG: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.LFO2TRIG = bytes2numberLE(b)

    // Not used
    out.log('RESERVED_1: offset: ' + reloff())
    b = []
    for (let i=0; i<7; i++) {
        b.push(nextByte(data, v).value)
    }
    o.RESERVED_1 = bytes2numberLE(b)

    // PORTAMENTO TIME
    out.log('PORTIME: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.PORTIME = bytes2numberLE(b)

    // PORTAMENTO TYPE
    out.log('PORTYPE: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.PORTYPE = bytes2numberLE(b)

    // PORTAMENTO ON/OFF
    out.log('PORTEN: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.PORTEN = bytes2numberLE(b)

    // Effects Bus Select; 0 to 4
    out.log('PFXCHAN: offset: ' + reloff())
    b = []
    for (let i=0; i<1; i++) {
        b.push(nextByte(data, v).value)
    }
    o.PFXCHAN = bytes2numberLE(b)

}

export function ProgramHeader_writeKGRP1(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeKGRP1')
    out.log('Offset: ' + 9)
    const d = byte2nibblesLE(v)
    header.raw[9] = d[0]
    header.raw[9 + 1] = d[1]
}

export function ProgramHeader_writePRNAME(header: ProgramHeader, v: string) {
    const out = newClientOutput(false, 'ProgramHeader_writePRNAME')
    out.log('Offset: ' + 13)
    const data = string2AkaiBytes(v)
    for (let i = 13, j = 0; i < 13 + 12 * 2; i += 2, j++) {
        const nibbles = byte2nibblesLE(data[j])
        header.raw[i] = nibbles[0]
        header.raw[i + 1] = nibbles[1]    }
}

export function ProgramHeader_writePRGNUM(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writePRGNUM')
    out.log('Offset: ' + 37)
    const d = byte2nibblesLE(v)
    header.raw[37] = d[0]
    header.raw[37 + 1] = d[1]
}

export function ProgramHeader_writePMCHAN(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writePMCHAN')
    out.log('Offset: ' + 39)
    const d = byte2nibblesLE(v)
    header.raw[39] = d[0]
    header.raw[39 + 1] = d[1]
}

export function ProgramHeader_writePOLYPH(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writePOLYPH')
    out.log('Offset: ' + 41)
    const d = byte2nibblesLE(v)
    header.raw[41] = d[0]
    header.raw[41 + 1] = d[1]
}

export function ProgramHeader_writePRIORT(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writePRIORT')
    out.log('Offset: ' + 43)
    const d = byte2nibblesLE(v)
    header.raw[43] = d[0]
    header.raw[43 + 1] = d[1]
}

export function ProgramHeader_writePLAYLO(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writePLAYLO')
    out.log('Offset: ' + 45)
    const d = byte2nibblesLE(v)
    header.raw[45] = d[0]
    header.raw[45 + 1] = d[1]
}

export function ProgramHeader_writePLAYHI(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writePLAYHI')
    out.log('Offset: ' + 47)
    const d = byte2nibblesLE(v)
    header.raw[47] = d[0]
    header.raw[47 + 1] = d[1]
}

export function ProgramHeader_writeOSHIFT(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeOSHIFT')
    out.log('Offset: ' + 49)
    const d = byte2nibblesLE(v)
    header.raw[49] = d[0]
    header.raw[49 + 1] = d[1]
}

export function ProgramHeader_writeOUTPUT(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeOUTPUT')
    out.log('Offset: ' + 51)
    const d = byte2nibblesLE(v)
    header.raw[51] = d[0]
    header.raw[51 + 1] = d[1]
}

export function ProgramHeader_writeSTEREO(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeSTEREO')
    out.log('Offset: ' + 53)
    const d = byte2nibblesLE(v)
    header.raw[53] = d[0]
    header.raw[53 + 1] = d[1]
}

export function ProgramHeader_writePANPOS(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writePANPOS')
    out.log('Offset: ' + 55)
    const d = byte2nibblesLE(v)
    header.raw[55] = d[0]
    header.raw[55 + 1] = d[1]
}

export function ProgramHeader_writePRLOUD(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writePRLOUD')
    out.log('Offset: ' + 57)
    const d = byte2nibblesLE(v)
    header.raw[57] = d[0]
    header.raw[57 + 1] = d[1]
}

export function ProgramHeader_writeV_LOUD(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeV_LOUD')
    out.log('Offset: ' + 59)
    const d = byte2nibblesLE(v)
    header.raw[59] = d[0]
    header.raw[59 + 1] = d[1]
}

export function ProgramHeader_writeK_LOUD(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeK_LOUD')
    out.log('Offset: ' + 61)
    const d = byte2nibblesLE(v)
    header.raw[61] = d[0]
    header.raw[61 + 1] = d[1]
}

export function ProgramHeader_writeP_LOUD(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeP_LOUD')
    out.log('Offset: ' + 63)
    const d = byte2nibblesLE(v)
    header.raw[63] = d[0]
    header.raw[63 + 1] = d[1]
}

export function ProgramHeader_writePANRAT(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writePANRAT')
    out.log('Offset: ' + 65)
    const d = byte2nibblesLE(v)
    header.raw[65] = d[0]
    header.raw[65 + 1] = d[1]
}

export function ProgramHeader_writePANDEP(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writePANDEP')
    out.log('Offset: ' + 67)
    const d = byte2nibblesLE(v)
    header.raw[67] = d[0]
    header.raw[67 + 1] = d[1]
}

export function ProgramHeader_writePANDEL(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writePANDEL')
    out.log('Offset: ' + 69)
    const d = byte2nibblesLE(v)
    header.raw[69] = d[0]
    header.raw[69 + 1] = d[1]
}

export function ProgramHeader_writeK_PANP(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeK_PANP')
    out.log('Offset: ' + 71)
    const d = byte2nibblesLE(v)
    header.raw[71] = d[0]
    header.raw[71 + 1] = d[1]
}

export function ProgramHeader_writeLFORAT(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeLFORAT')
    out.log('Offset: ' + 73)
    const d = byte2nibblesLE(v)
    header.raw[73] = d[0]
    header.raw[73 + 1] = d[1]
}

export function ProgramHeader_writeLFODEP(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeLFODEP')
    out.log('Offset: ' + 75)
    const d = byte2nibblesLE(v)
    header.raw[75] = d[0]
    header.raw[75 + 1] = d[1]
}

export function ProgramHeader_writeLFODEL(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeLFODEL')
    out.log('Offset: ' + 77)
    const d = byte2nibblesLE(v)
    header.raw[77] = d[0]
    header.raw[77 + 1] = d[1]
}

export function ProgramHeader_writeMWLDEP(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMWLDEP')
    out.log('Offset: ' + 79)
    const d = byte2nibblesLE(v)
    header.raw[79] = d[0]
    header.raw[79 + 1] = d[1]
}

export function ProgramHeader_writePRSDEP(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writePRSDEP')
    out.log('Offset: ' + 81)
    const d = byte2nibblesLE(v)
    header.raw[81] = d[0]
    header.raw[81 + 1] = d[1]
}

export function ProgramHeader_writeVELDEP(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeVELDEP')
    out.log('Offset: ' + 83)
    const d = byte2nibblesLE(v)
    header.raw[83] = d[0]
    header.raw[83 + 1] = d[1]
}

export function ProgramHeader_writeB_PTCH(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeB_PTCH')
    out.log('Offset: ' + 85)
    const d = byte2nibblesLE(v)
    header.raw[85] = d[0]
    header.raw[85 + 1] = d[1]
}

export function ProgramHeader_writeP_PTCH(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeP_PTCH')
    out.log('Offset: ' + 87)
    const d = byte2nibblesLE(v)
    header.raw[87] = d[0]
    header.raw[87 + 1] = d[1]
}

export function ProgramHeader_writeKXFADE(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeKXFADE')
    out.log('Offset: ' + 89)
    const d = byte2nibblesLE(v)
    header.raw[89] = d[0]
    header.raw[89 + 1] = d[1]
}

export function ProgramHeader_writeGROUPS(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeGROUPS')
    out.log('Offset: ' + 91)
    const d = byte2nibblesLE(v)
    header.raw[91] = d[0]
    header.raw[91 + 1] = d[1]
}

export function ProgramHeader_writeTPNUM(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeTPNUM')
    out.log('Offset: ' + 93)
    const d = byte2nibblesLE(v)
    header.raw[93] = d[0]
    header.raw[93 + 1] = d[1]
}

export function ProgramHeader_writeTEMPER(header: ProgramHeader, v: string) {
    const out = newClientOutput(false, 'ProgramHeader_writeTEMPER')
    out.log('Offset: ' + 95)
    const data = string2AkaiBytes(v)
    for (let i = 95, j = 0; i < 95 + 12 * 2; i += 2, j++) {
        const nibbles = byte2nibblesLE(data[j])
        header.raw[i] = nibbles[0]
        header.raw[i + 1] = nibbles[1]    }
}

export function ProgramHeader_writeECHOUT(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeECHOUT')
    out.log('Offset: ' + 119)
    const d = byte2nibblesLE(v)
    header.raw[119] = d[0]
    header.raw[119 + 1] = d[1]
}

export function ProgramHeader_writeMW_PAN(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMW_PAN')
    out.log('Offset: ' + 121)
    const d = byte2nibblesLE(v)
    header.raw[121] = d[0]
    header.raw[121 + 1] = d[1]
}

export function ProgramHeader_writeCOHERE(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeCOHERE')
    out.log('Offset: ' + 123)
    const d = byte2nibblesLE(v)
    header.raw[123] = d[0]
    header.raw[123 + 1] = d[1]
}

export function ProgramHeader_writeDESYNC(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeDESYNC')
    out.log('Offset: ' + 125)
    const d = byte2nibblesLE(v)
    header.raw[125] = d[0]
    header.raw[125 + 1] = d[1]
}

export function ProgramHeader_writePLAW(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writePLAW')
    out.log('Offset: ' + 127)
    const d = byte2nibblesLE(v)
    header.raw[127] = d[0]
    header.raw[127 + 1] = d[1]
}

export function ProgramHeader_writeVASSOQ(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeVASSOQ')
    out.log('Offset: ' + 129)
    const d = byte2nibblesLE(v)
    header.raw[129] = d[0]
    header.raw[129 + 1] = d[1]
}

export function ProgramHeader_writeSPLOUD(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeSPLOUD')
    out.log('Offset: ' + 131)
    const d = byte2nibblesLE(v)
    header.raw[131] = d[0]
    header.raw[131 + 1] = d[1]
}

export function ProgramHeader_writeSPATT(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeSPATT')
    out.log('Offset: ' + 133)
    const d = byte2nibblesLE(v)
    header.raw[133] = d[0]
    header.raw[133 + 1] = d[1]
}

export function ProgramHeader_writeSPFILT(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeSPFILT')
    out.log('Offset: ' + 135)
    const d = byte2nibblesLE(v)
    header.raw[135] = d[0]
    header.raw[135 + 1] = d[1]
}

export function ProgramHeader_writePTUNO(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writePTUNO')
    out.log('Offset: ' + 137)
    const d = byte2nibblesLE(v)
    header.raw[137] = d[0]
    header.raw[137 + 1] = d[1]
}

export function ProgramHeader_writeK_LRAT(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeK_LRAT')
    out.log('Offset: ' + 141)
    const d = byte2nibblesLE(v)
    header.raw[141] = d[0]
    header.raw[141 + 1] = d[1]
}

export function ProgramHeader_writeK_LDEP(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeK_LDEP')
    out.log('Offset: ' + 143)
    const d = byte2nibblesLE(v)
    header.raw[143] = d[0]
    header.raw[143 + 1] = d[1]
}

export function ProgramHeader_writeK_LDEL(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeK_LDEL')
    out.log('Offset: ' + 145)
    const d = byte2nibblesLE(v)
    header.raw[145] = d[0]
    header.raw[145 + 1] = d[1]
}

export function ProgramHeader_writeVOSCL(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeVOSCL')
    out.log('Offset: ' + 147)
    const d = byte2nibblesLE(v)
    header.raw[147] = d[0]
    header.raw[147 + 1] = d[1]
}

export function ProgramHeader_writeVSSCL(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeVSSCL')
    out.log('Offset: ' + 149)
    const d = byte2nibblesLE(v)
    header.raw[149] = d[0]
    header.raw[149 + 1] = d[1]
}

export function ProgramHeader_writeLEGATO(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeLEGATO')
    out.log('Offset: ' + 151)
    const d = byte2nibblesLE(v)
    header.raw[151] = d[0]
    header.raw[151 + 1] = d[1]
}

export function ProgramHeader_writeB_PTCHD(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeB_PTCHD')
    out.log('Offset: ' + 153)
    const d = byte2nibblesLE(v)
    header.raw[153] = d[0]
    header.raw[153 + 1] = d[1]
}

export function ProgramHeader_writeB_MODE(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeB_MODE')
    out.log('Offset: ' + 155)
    const d = byte2nibblesLE(v)
    header.raw[155] = d[0]
    header.raw[155 + 1] = d[1]
}

export function ProgramHeader_writeTRANSPOSE(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeTRANSPOSE')
    out.log('Offset: ' + 157)
    const d = byte2nibblesLE(v)
    header.raw[157] = d[0]
    header.raw[157 + 1] = d[1]
}

export function ProgramHeader_writeMODSPAN1(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODSPAN1')
    out.log('Offset: ' + 159)
    const d = byte2nibblesLE(v)
    header.raw[159] = d[0]
    header.raw[159 + 1] = d[1]
}

export function ProgramHeader_writeMODSPAN2(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODSPAN2')
    out.log('Offset: ' + 161)
    const d = byte2nibblesLE(v)
    header.raw[161] = d[0]
    header.raw[161 + 1] = d[1]
}

export function ProgramHeader_writeMODSPAN3(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODSPAN3')
    out.log('Offset: ' + 163)
    const d = byte2nibblesLE(v)
    header.raw[163] = d[0]
    header.raw[163 + 1] = d[1]
}

export function ProgramHeader_writeMODSAMP1(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODSAMP1')
    out.log('Offset: ' + 165)
    const d = byte2nibblesLE(v)
    header.raw[165] = d[0]
    header.raw[165 + 1] = d[1]
}

export function ProgramHeader_writeMODSAMP2(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODSAMP2')
    out.log('Offset: ' + 167)
    const d = byte2nibblesLE(v)
    header.raw[167] = d[0]
    header.raw[167 + 1] = d[1]
}

export function ProgramHeader_writeMODSLFOT(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODSLFOT')
    out.log('Offset: ' + 169)
    const d = byte2nibblesLE(v)
    header.raw[169] = d[0]
    header.raw[169 + 1] = d[1]
}

export function ProgramHeader_writeMODSLFOL(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODSLFOL')
    out.log('Offset: ' + 171)
    const d = byte2nibblesLE(v)
    header.raw[171] = d[0]
    header.raw[171 + 1] = d[1]
}

export function ProgramHeader_writeMODSLFOD(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODSLFOD')
    out.log('Offset: ' + 173)
    const d = byte2nibblesLE(v)
    header.raw[173] = d[0]
    header.raw[173 + 1] = d[1]
}

export function ProgramHeader_writeMODSFILT1(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODSFILT1')
    out.log('Offset: ' + 175)
    const d = byte2nibblesLE(v)
    header.raw[175] = d[0]
    header.raw[175 + 1] = d[1]
}

export function ProgramHeader_writeMODSFILT2(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODSFILT2')
    out.log('Offset: ' + 177)
    const d = byte2nibblesLE(v)
    header.raw[177] = d[0]
    header.raw[177 + 1] = d[1]
}

export function ProgramHeader_writeMODSFILT3(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODSFILT3')
    out.log('Offset: ' + 179)
    const d = byte2nibblesLE(v)
    header.raw[179] = d[0]
    header.raw[179 + 1] = d[1]
}

export function ProgramHeader_writeMODSPITCH(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODSPITCH')
    out.log('Offset: ' + 181)
    const d = byte2nibblesLE(v)
    header.raw[181] = d[0]
    header.raw[181 + 1] = d[1]
}

export function ProgramHeader_writeMODSAMP3(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODSAMP3')
    out.log('Offset: ' + 183)
    const d = byte2nibblesLE(v)
    header.raw[183] = d[0]
    header.raw[183 + 1] = d[1]
}

export function ProgramHeader_writeMODVPAN1(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODVPAN1')
    out.log('Offset: ' + 185)
    const d = byte2nibblesLE(v)
    header.raw[185] = d[0]
    header.raw[185 + 1] = d[1]
}

export function ProgramHeader_writeMODVPAN2(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODVPAN2')
    out.log('Offset: ' + 187)
    const d = byte2nibblesLE(v)
    header.raw[187] = d[0]
    header.raw[187 + 1] = d[1]
}

export function ProgramHeader_writeMODVPAN3(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODVPAN3')
    out.log('Offset: ' + 189)
    const d = byte2nibblesLE(v)
    header.raw[189] = d[0]
    header.raw[189 + 1] = d[1]
}

export function ProgramHeader_writeMODVAMP1(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODVAMP1')
    out.log('Offset: ' + 191)
    const d = byte2nibblesLE(v)
    header.raw[191] = d[0]
    header.raw[191 + 1] = d[1]
}

export function ProgramHeader_writeMODVAMP2(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODVAMP2')
    out.log('Offset: ' + 193)
    const d = byte2nibblesLE(v)
    header.raw[193] = d[0]
    header.raw[193 + 1] = d[1]
}

export function ProgramHeader_writeMODVLFOR(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODVLFOR')
    out.log('Offset: ' + 195)
    const d = byte2nibblesLE(v)
    header.raw[195] = d[0]
    header.raw[195 + 1] = d[1]
}

export function ProgramHeader_writeMODVLVOL(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODVLVOL')
    out.log('Offset: ' + 197)
    const d = byte2nibblesLE(v)
    header.raw[197] = d[0]
    header.raw[197 + 1] = d[1]
}

export function ProgramHeader_writeMODVLFOD(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODVLFOD')
    out.log('Offset: ' + 199)
    const d = byte2nibblesLE(v)
    header.raw[199] = d[0]
    header.raw[199 + 1] = d[1]
}

export function ProgramHeader_writeLFO1WAVE(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeLFO1WAVE')
    out.log('Offset: ' + 201)
    const d = byte2nibblesLE(v)
    header.raw[201] = d[0]
    header.raw[201 + 1] = d[1]
}

export function ProgramHeader_writeLFO2WAVE(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeLFO2WAVE')
    out.log('Offset: ' + 203)
    const d = byte2nibblesLE(v)
    header.raw[203] = d[0]
    header.raw[203 + 1] = d[1]
}

export function ProgramHeader_writeMODSLFLT2_1(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODSLFLT2_1')
    out.log('Offset: ' + 205)
    const d = byte2nibblesLE(v)
    header.raw[205] = d[0]
    header.raw[205 + 1] = d[1]
}

export function ProgramHeader_writeMODSLFLT2_2(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODSLFLT2_2')
    out.log('Offset: ' + 207)
    const d = byte2nibblesLE(v)
    header.raw[207] = d[0]
    header.raw[207 + 1] = d[1]
}

export function ProgramHeader_writeMODSLFLT2_3(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeMODSLFLT2_3')
    out.log('Offset: ' + 209)
    const d = byte2nibblesLE(v)
    header.raw[209] = d[0]
    header.raw[209 + 1] = d[1]
}

export function ProgramHeader_writeLFO2TRIG(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeLFO2TRIG')
    out.log('Offset: ' + 211)
    const d = byte2nibblesLE(v)
    header.raw[211] = d[0]
    header.raw[211 + 1] = d[1]
}

export function ProgramHeader_writeRESERVED_1(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writeRESERVED_1')
    out.log('Offset: ' + 213)
    const d = byte2nibblesLE(v)
    header.raw[213] = d[0]
    header.raw[213 + 1] = d[1]
}

export function ProgramHeader_writePORTIME(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writePORTIME')
    out.log('Offset: ' + 227)
    const d = byte2nibblesLE(v)
    header.raw[227] = d[0]
    header.raw[227 + 1] = d[1]
}

export function ProgramHeader_writePORTYPE(header: ProgramHeader, v: number) {
    const out = newClientOutput(false, 'ProgramHeader_writePORTYPE')
    out.log('Offset: ' + 229)
    const d = byte2nibblesLE(v)
    header.raw[229] = d[0]
    hea