content: ["I2M.CH"]  
  prototype = "I2M.CH"  
  prototype_set = "I2M.CH x"
  aliases = ["I2M.#"]    
  short = "Get currently set MIDI channel / Set MIDI channel `x` (1..16 for TRS, 17..32 for USB) for MIDI out"  
  description = """
  Get currently set MIDI channel / Set MIDI channel `x` (1..16 for TRS, 17..32 for USB) for MIDI out. Use MIDI channels 1-16 for TRS output, 17-32 for USB output. Default is `x = 1`.
  """
  
  ["I2M.TIME"]
  prototype = "I2M.TIME"  
  prototype_set = "I2M.TIME x"  
  aliases = ["I2M.T"]  
  short = "Get current note duration / Set note duration of MIDI notes to `x` ms (0..32767) for current channel"  
  description = """
  Get current note duration / Set note duration of MIDI notes to `x` ms (0..32767) for current channel. Based on note duration, i2c2midi will send a MIDI Note Off message automatically. Set `x = 0` to deactivate automatic Note Off messages. Default is `x = 100`.  
  """
  
  ["I2M.T#"]
  prototype = "I2M.T# ch"  
  prototype_set = "I2M.T# ch x"  
  short = "Get current note duration / Set note duration of MIDI notes to `x` ms (0..32767) for channel `ch` (0..32)."  
  description = """
  Get current note duration / Set note duration of MIDI notes to `x` ms (0..32767) for channel `ch` (0..32). Use `ch = 0` to set for all channels.
  """
  
  ["I2M.SHIFT"]  
  prototype = "I2M.SHIFT"  
  prototype_set = "I2M.SHIFT x"  
  aliases = ["I2M.S"]  
  short = "Get current transposition / Set transposition of MIDI notes to `x` semitones (-127..127) for current channel"  
  description = """
  Get current transposition / Set transposition of MIDI notes to `x` semitones (-127..127) for current channel. Default is `x = 0`.  
  """
  
  ["I2M.S#"]
  prototype = "I2M.S# ch"  
  prototype_set = "I2M.S# ch x"  
  short = "Get current transposition / Set transposition of MIDI notes to `x` semitones (-127..127) for channel `ch` (0..32)"
  description = """
  Get current transposition / Set transposition of MIDI notes to `x` semitones (-127..127) for channel `ch` (0..32). Use `ch = 0` to set for all channels."  
  """
  
  ["I2M.MIN"]  
  prototype = "I2M.MIN x y"  
  short = "Set minimum note number for MIDI notes to `x` (0..127), using mode `y` (0..3), for current channel"  
  description = """
  Set minimum note number for MIDI notes to `x` (0..127), using mode `y` (0..3), for current channel. Default is `x = 0` and `y = 0`. The following modes are available for notes lower than the minimum: 0) Ignore notes 1) Clamp notes 2) Fold back notes by one octave 3) Fold back notes by multiple octaves.  
  """
  
  ["I2M.MIN#"]
  prototype = "I2M.MIN# ch x y"  
  short = "Set minimum note number for MIDI notes to `x` (0..127), using mode `y` (0..3), for channel `ch` (0..32)"  
  description = """
  Set minimum note number for MIDI notes to `x` (0..127), using mode `y` (0..3), for channel `ch` (0..32). Use `ch = 0` to set for all channels.
  """
  
  ["I2M.MAX"]  
  prototype = "I2M.MAX x y"  
  short = "Set maximum note number for MIDI notes to `x` (0..127), using mode `y` (0..3), for current channel"  
  description = """
  Set maximum note number for MIDI notes to `x` (0..127), using mode `y` (0..3), for current channel. Default is `x = 0` and `y = 0`. The following modes are available for notes higher than the maximum: 0) Ignore notes 1) Clamp notes 2) Fold back notes by one octave 3) Fold back notes by multiple octaves.  
  """
  
  ["I2M.MAX#"]
  prototype = "I2M.MAX# ch x y"  
  short = "Set maximum note number for MIDI notes to `x` (0..127), using mode `y` (0..3), for channel `ch` (0..32)"
  description = """
  Set maximum note number for MIDI notes to `x` (0..127), using mode `y` (0..3), for channel `ch` (0..32). Use `ch = 0` to set for all channels.
  """
  
  ["I2M.REP"]  
  prototype = "I2M.REP"  
  prototype_set = "I2M.REP x"  
  short = "Get current repetition / Set repetition of MIDI notes to `x` repetitions (1..127) for current channel"  
  description = """
  Get current repetition / Set repetition of MIDI notes to `x` repetitions (1..127) for current channel. Set `x = 1` for no repetitions. Default is `x = 1`.  
  """
  
  ["I2M.REP#"]
  prototype = "I2M.REP# ch x"  
  short = "Get current repetition / Set repetition of MIDI notes to `x` repetitions (1..127) for channel `ch` (0..32)"
  description = """
  Get current repetition / Set repetition of MIDI notes to `x` repetitions (1..127) for channel `ch` (0..32). Use `ch = 0` to set for all channels.
  """
  
  ["I2M.RAT"]  
  prototype = "I2M.RAT"  
  prototype_set = "I2M.RAT x"  
  short = "Get current ratcheting / Set ratcheting of MIDI notes to `x` ratchets (1..127) for current channel"  
  description = """
  Get current ratcheting / Set ratcheting of MIDI notes to `x` ratchets (1..127) for current channel. Set `x = 1` for no ratcheting. Default is `x = 1`.  
  """
  
  ["I2M.RAT#"]
  prototype = "I2M.RAT# ch x"  
  short = "Get current ratcheting / Set ratcheting of MIDI notes to `x` ratchets (1..127) for channel `ch` (0..32)"  
  description = """
  Get current ratcheting / Set ratcheting of MIDI notes to `x` ratchets (1..127) for channel `ch` (0..32). Use `ch = 0` to set for all channels.  
  """
  
  ["I2M.MUTE"]
  prototype = "I2M.MUTE"
  prototype_set = "I2M.MUTE x"  
  short = "Get mute state / Set mute state of current MIDI channel to `x` (0..1)"  
  
  ["I2M.MUTE#"]
  prototype = "I2M.MUTE#"
  prototype_set = "I2M.MUTE# ch x"  
  short = "Get mute state / Set mute state of MIDI channel `ch` to `x` (0..1)"  
  
  ["I2M.SOLO"]
  prototype = "I2M.SOLO"
  prototype_set = "I2M.SOLO x"  
  short = "Get solo state / Set solo state of current MIDI channel to `x` (0..1)"  
  
  ["I2M.SOLO#"]
  prototype = "I2M.SOLO#"
  prototype_set = "I2M.SOLO# ch x"  
  short = "Get solo state / Set solo state of MIDI channel `ch` to `x` (0..1)"  
  
  ["I2M.NOTE"]  
  prototype = "I2M.NOTE x y"  
  aliases = ["I2M.N"]  
  short = "Send MIDI Note On message for note number `x` (0..127) with velocity `y` (1..127) on current channel"
  description = """
  Send MIDI Note On message for note number `x` (0..127) with velocity `y` (1..127) on current channel. A velocity of `0` will be treated as a MIDI Note Off message.  
  """
  
  ["I2M.N#"]  
  prototype = "I2M.N# ch x y"  
  short = "Send MIDI Note On message for note number `x` (0..127) with velocity `y` (1..127) on channel `ch` (1..32)"
  
  ["I2M.NOTE.O"]  
  prototype = "I2M.NOTE.O x"  
  aliases = ["I2M.NO"]  
  short = "Send a manual MIDI Note Off message for note number `x` (0..127)"  
  description = """
  Send a manual MIDI Note Off message for note number `x` (0..127). This can be used either before i2c2midi sends the automatic Note Off message (to stop the note from playing before its originally planned ending), or in combination with `I2M.TIME` set to `0` (in which case i2c2midi does not send automatic Note Off messages).  
  """
  
  ["I2M.NO#"]  
  prototype = "I2M.NO# ch x"  
  short = "Send a manual MIDI Note Off message for note number `x` (0..127) on channel `ch` (1..32)"  
  
  ["I2M.NT"]   
  prototype = "I2M.NT x y z"  
  short = "Send MIDI Note On message for note number `x` (0..127) with velocity `y` (1..127) and note duration `z` ms (0..32767)"  
  description = """
  Send MIDI Note On message for note number `x` (0..127) with velocity `y` (1..127) and note duration `z` ms (0..32767).  
  """
  
  ["I2M.NT#"]   
  prototype = "I2M.NT# ch x y z"  
  short = "Send MIDI Note On message for note number `x` (0..127) with velocity `y` (1..127) and note duration `z` ms (0..32767) on channel `ch` (1..32)"  
  
  ["I2M.CC"]  
  prototype = "I2M.CC x y"  
  short = "Send MIDI CC message for controller `x` (0..127) with value `y` (0..127)"  
  description = """
  Send MIDI CC message for controller `x` (0..127) with value `y` (0..127).  
  """
  
  ["I2M.CC#"]  
  prototype = "I2M.CC# ch x y"  
  short = "Send MIDI CC message for controller `x` (0..127) with value `y` (0..127) on channel `ch` (1..32)"  
  
  ["I2M.CC.SET"]  
  prototype = "I2M.CC.SET x y"  
  short = "Send MIDI CC message for controller `x` (0..127) with value `y` (0..127), bypassing any slew settings"  
  description = """
  Send MIDI CC message for controller `x` (0..127) with value `y` (0..127), bypassing any slew settings.  
  """
  
  ["I2M.CC.SET#"]  
  prototype = "I2M.CC.SET# ch x y"  
  short = "Send MIDI CC message for controller `x` (0..127) with value `y` (0..127) on channel `ch` (1..32), bypassing any slew settings"  
  
  ["I2M.CCV"]  
  prototype = "I2M.CCV x y"  
  short = "Send MIDI CC message for controller `x` (0..127) with volt value `y` (0..16383, 0..+10V)"  
  description = """
  Send MIDI CC message for controller `x` (0..127) with volt value `y` (0..16383, 0..+10V).  
  """
  
  ["I2M.CCV#"]  
  prototype = "I2M.CCV# ch x y"  
  short = "Send MIDI CC message for controller `x` (0..127) with volt value `y` (0..16383, 0..+10V) on channel `ch` (1..32)"  
  
  ["I2M.CC.OFF"]  
  prototype = "I2M.CC.OFF x"  
  prototype_set = "I2M.CC.OFF x y"  
  short = "Get current offset / Set offset of values of controller `x` (0..127) to `y` (-127..127)"  
  description = """
  Get current offset / Set offset of values of controller `x` (0..127) to `y` (-127..127). Default is `y = 0`.  
  """
  
  ["I2M.CC.OFF#"]  
  prototype = "I2M.CC.OFF# ch x"  
  prototype_set = "I2M.CC.OFF# ch x y"  
  short = "Get current offset / Set offset of values of controller `x` (0..127) to `y` (-127..127) for channel `ch` (1..32)"  
  
  ["I2M.CC.SLEW"]  
  prototype = "I2M.CC.SLEW x"  
  prototype_set = "I2M.CC.SLEW x y"  
  short = "Get current slew time for controller `x` / Set slew time for controller `x` (0..127) to `y` ms (0..32767)"   
  description = """
  Get current slew time for controller `x` / Set slew time for controller `x` (0..127) to `y` ms (0..32767). i2c2midi will ramp from the controller's last value to a new value within the given time `x`, sending MIDI CCs at a maximum rate of 30 ms. If the slewing is still ongoing when a new value is set, the slewing uses its current position as the last value. Is 8 CC controller values can be slewed simoultaneously before the oldest currently slewing value is overwritten by the newest. Default is `y = 0`.  
  """
  
  ["I2M.CC.SLEW#"]  
  prototype = "I2M.CC.SLEW# ch x"  
  prototype_set = "I2M.CC.SLEW# ch x y"  
  short = "Get current slew time for controller `x` / Set slew time for controller `x` (0..127) to `y` ms (0..32767) for channel `ch` (1..32)"   
  
  ["I2M.NRPN"]  
  prototype = "I2M.NRPN x y z"  
  short = "Send MIDI NRPN message (high-res CC) for parameter MSB `x` and LSB `y` with value `y` (0..16383)"  
  description = """
  Send MIDI NRPN message (high-res CC) for parameter MSB `x` and LSB `y` with value `y` (0..16383).  
  """
  
  ["I2M.NRPN#"]  
  prototype = "I2M.NRPN# ch x y z"  
  short = "Send MIDI NRPN message (high-res CC) for parameter MSB `x` and LSB `y` with value `y` (0..16383) on channel `ch` (1..32)"  
  
  ["I2M.NRPN.OFF"]  
  prototype = "I2M.NRPN.OFF x y"  
  prototype_set = "I2M.NRPN.OFF x y z"  
  short = "Get current offset / Set offset of values of NRPN messages to `z` (-16384..16383)"  
  description = """
  Get current offset / Set offset of values of NRPN messages to `z` (-16384..16383). Default is z = 0.  
  """
  
  ["I2M.NRPN.OFF#"]  
  prototype = "I2M.NRPN.OFF# ch x y"  
  prototype_set = "I2M.NRPN.OFF# ch x y z"  
  short = "Get current offset / Set offset of values of NRPN messages to `z` (-16384..16383) for channel `ch` (1..32)"  
  
  ["I2M.NRPN.SLEW"]  
  prototype = "I2M.NRPN.SLEW x y"  
  prototype_set = "I2M.NRPN.SLEW x y z"  
  short = "Get current slew time / Set slew time for NRPN messages to `z` ms (0..32767)"  
  description = """
  Get current slew time / Set slew time for NRPN messages to `z` ms (0..32767). Default is z = 0.  
  """
  
  ["I2M.NRPN.SLEW#"]  
  prototype = "I2M.NRPN.SLEW# ch x y"  
  prototype_set = "I2M.NRPN.SLEW# ch x y z"  
  short = "Get current slew time / Set slew time for NRPN messages to `z` ms (0..32767) for channel `ch` (1..32)"  
  
  ["I2M.NRPN.SET"]  
  prototype = "I2M.NRPN.SET x y z"  
  short = "Send MIDI NRPN message for parameter MSB `x` and LSB `y` with value `y` (0..16383), bypassing any slew settings"  
  description = """
  Send MIDI NRPN message for parameter MSB `x` and LSB `y` with value `y` (0..16383), bypassing any slew settings.  
  """
  
  ["I2M.NRPN.SET#"]  
  prototype = "I2M.NRPN.SET# ch x y z"  
  short = "Send MIDI NRPN message for parameter MSB `x` and LSB `y` with value `y` (0..16383) on channel `ch` (1..32), bypassing any slew settings"  
  
  ["I2M.PRG"]  
  prototype = "I2M.PRG x"  
  short = "Send MIDI Program Change message for program `x` (0..127)"  
  
  ["I2M.PB"]  
  prototype = "I2M.PB x"   
  short = "Send MIDI Pitch Bend message with value `x` (-8192..8191)"  
  
  ["I2M.AT"]  
  prototype = "I2M.AT x"  
  short = "Send MIDI After Touch message with value `x` (0..127)"  
  
  ["I2M.CLK"]  
  prototype = "I2M.CLK"  
  short = "Send MIDI Clock message, this still needs improvement ..."  
  
  ["I2M.START"]  
  prototype = "I2M.START"  
  short = "Send MIDI Clock Start message"  
  
  ["I2M.STOP"]  
  prototype = "I2M.STOP"  
  short = "Send MIDI Clock Stop message"  
  
  ["I2M.CONT"]  
  prototype = "I2M.CONT"  
  short = "Send MIDI Clock Continue message"  
  
  ["I2M.CHORD"]  
  prototype = "I2M.CHORD x y z"  
  aliases = ["I2M.C"]  
  short = "Play chord `x` (1..8) with root note `y` (-127..127) and velocity `z` (1..127)"  
  description = """
  Play chord `x` (1..8) with root note `y` (-127..127) and velocity `z` (1..127). A chord consists of up to eight notes defined relative to the root note via `I2M.C.ADD`, `I2M.C.RM`, `I2M.C.INS`, `I2M.C.DEL` or `I2M.C.SET`, which are sent out as MIDI Note On messages in the order they are defined in the chord. If no note has been defined in the chord yet, no note will be played. 8 chords can be defined using their respective index 1..8.  
  """
  
  ["I2M.C#"]  
  prototype = "I2M.C# ch x y z"  
  short = "Play chord `x` (1..8) with root note `y` (-127..127) and velocity `z` (1..127) on channel `ch` (1..32)"  
  
  ["I2M.C.ADD"]  
  prototype = "I2M.C.ADD x y"  
  aliases = ["I2M.C+"]  
  short = "Add relative note `y` (-127..127) to chord `x` (0..8), use `x = 0` to add to all chords"  
  description = """
  Add note `y` (-127..127) to chord `x` (0..8), with `y` relative to the root note specified when playing a chord. E.g. add `0`, `4` and `7` to define a major triad. Or go more experimental, e.g. `-2`, `13`, `2`, `13`. Up to eight chords can be defined, with eight notes each. Use `x = 0` to add the note to all chords.
  """
  
  ["I2M.C.RM"]  
  prototype = "I2M.C.RM x y"  
  aliases = ["I2M.C-"]  
  short = "Remove note `y` (-127..127) from chord `x` (0..8), use `x = 0` to remove from all chords"  
  description = """
  Remove note `y` (-127..127) from chord `x` (0..8). If the chord contains note `y` multiple times, the latest instance is removed. If the chord does not contain the note the message is simply ignored. Use `x = 0` to remove the note from all chords.
  """
  
  ["I2M.C.INS"]  
  prototype = "I2M.C.INS x y z"  
  short = "Add note `z` (-127..127) to chord `x` (0..8) at index `y` (0..7), with `z` relative to the root note; use `x = 0` to insert into all chords"  
  description = """
  Add note `z` (-127..127) to chord `x` (0..8) at index `y` (0..7), with `z` relative to the root note. Already defined notes at index `y` and higher are pushed to the right. Use `x = 0` to insert the note to all chords.
  """
  
  ["I2M.C.DEL"]  
  prototype = "I2M.C.DEL x y"  
  short = "Delete note at index `y` (0..7) from chord `x` (0..8), use `x = 0` to delete from all chords"  
  description = """
  Delete note at index `y` (0..7) from chord `x` (0..8). Notes at index `y + 1` and higher are pushed to the left. If `y` is higher than the length of the chord, the message is ignored. Use `x = 0` to delete the note from all chords.
  """
  
  ["I2M.C.SET"]  
  prototype = "I2M.C.SET x y z"  
  short = "Set note at index `y` (0..7) in chord `x` (0..8) to note `z` (-127..127), use `x = 0` to set in all chords"  
  description = """
  Set note at index `y` (0..7) in chord `x` (0..8) to note `z` (-127..127), replacing what was defined earlier at this index. If `y` is higher than the length of the chord, the message is ignored. Use `x = 0` to set the note in all chords.
  """
  
  ["I2M.C.B"]  
  prototype = "I2M.C.B x y"  
  short = "Clear and define chord `x` (0..8) using reverse binary notation (`R...`)"  
  description = """
  Clear and define chord `x` (0..8) using reverse binary notation (`R...`). Use `1` or `0` in order to include or exclude notes from the chord. E.g. use `x = R10001001` for `0,4,7` (major triad) or `x = R1000000100000001` for `0,7,15`. `y` can be a maximum of 16 digit long. Use `x = 0` to clear and define all chords.
  """
  
  ["I2M.C.CLR"]  
  prototype = "I2M.C.CLR x"  
  short = "Clear chord `x` (0..8), use `x = 0` to clear all chords"  
  description = """
  Clear chord `x` (0..8). Use `x = 0` to clear all chords.
  """
  
  ["I2M.C.L"]  
  prototype = "I2M.C.L x"  
  prototype_set = "I2M.C.L x y"  
  short = "Get current length / Set length of chord `x` (0..8) to `y` (1..8), use `x = 0` to set length of all chords"  
  description = """
  Get current length / Set length of chord `x` (0..8) to `y` (1..8). The length of a chord changes automatically each time a note is added or removed. Values of `x` higher than number of actual defined notes are ignored. Already defined notes are not affected by setting the chord length, but won't be played if their index is outside of the set chord length. Use `x = 0` to set the length of all chords.
  """
  
  ["I2M.C.SC"]  
  prototype = "I2M.C.SC x y"  
  short = "Set scale for chord `x` (0..8) based on chord `y` (0..8), use `x = 0` to set for all chords, use `y = 0` to remove scale"    
  description = """
  Set scale for chord `x` (0..8) based on chord `y` (0..8). Setting a scale for a chord comes in handy when using chord transformations that introduce new notes, like `I2M.C.TRP`, `I2M.C.DIS` or `I2M.C.REF`. Use `y = 0` to remove the scale. Use `x = 0` to set reversal for all chords.
  """
  
  ["I2M.C.REV"]  
  prototype = "I2M.C.REV x y"  
  short = "Set reversal of notes in chord `x` (0..8) to `y`. `y = 0` or an even number means not reversed, y = 1 or an uneven number  means reversed. Use `x = 0` to set for all chords."  
  description = """
  Set reverse of notes in chord `x` (0..8) to `y`. `y = 0` or an even number means not reversed, `y = 1` or an uneven number  means reversed. E.g. `y = 1` for chord `0,3,7` will lead to `7,3,0`. Default is `y = 0`. Use `x = 0` to reverse all chords.
  """
  
  ["I2M.C.ROT"]  
  prototype = "I2M.C.ROT x y"  
  short = "Set rotation of notes in chord `x` (0..8) to `y` steps (-127..127), use `x = 0` to set for all chords"  
  description = """
  Set rotation of notes in chord `x` (0..8) to `y` steps (-127..127). E.g. `y = 1` of chord `0,3,7` will lead to `3,7,0`, `y = 2` will lead to `7,0,3`, `y = -1` will lead to `7,0,3`. Default is `y = 0`. Use `x = 0` to set rotation for all chords.
  """
  
  ["I2M.C.TRP"]  
  prototype = "I2M.C.TRP x y"  
  short = "Set transposition of chord `x` (0..8) to `y` (-127..127), use `x = 0` to set for all chords"  
  description = """
  Set transposition of chord `x` (0..8) to `y` (-127..127). Transposition adds `y` to the note number of each note in the chord.Default is `y = 0`. Use `x = 0` to set transposition for all chords. This transformation introduces new notes to the chord – try it in combination with setting a scale.
  """
  
  ["I2M.C.DIS"]  
  prototype = "I2M.C.DIS x y z"  
  short = "Set distortion of chord `x` (0..8) to `y` (-127..127) with anchor point `z` (0..16), use `x = 0` to set for all chords"  
  description = """
  Set distortion of chord `x` (0..8) to width `y` (-127..127) with anchor point `z` (0..16). Distortion adds `y+n` to the note number of each note in the chord. The anchor point influences the direction and amount (`n`) of the transformation. Default is `y = 0`. Use `x = 0` to set distortion for all chords. This transformation introduces new notes to the chord – try it in combination with setting a scale.
  """
  
  ["I2M.C.REF"]  
  prototype = "I2M.C.REF x y z"  
  short = "Set reflection of chord `x` (0..8) to `y` iterations (-127..127) with anchor point `z` (0..16), use `x = 0` to set for all chords"  
  description = """
  Set reflection of chord `x` (0..8) to `y` (-127..127) with anchor point `z` (0..16). The anchor point defines at which axis the chord gets reflected. Default is `y = 0`. Use `x = 0` to set distortion for all chords. This transformation introduces new notes to the chord – try it in combination with setting a scale.
  """
  
  ["I2M.C.INV"]  
  prototype = "I2M.C.INV x y"  
  short = "Set inversion of chord `x` (0..8) to `y` (-32..32), use `x = 0` to set for all chords"  
  description = """
  Set inversion of chord `x` (0..8) to `y` (-32..32). Default is `y = 0`. Use `x = 0` to set inversion for all chords.
  """
  
  ["I2M.C.STR"]  
  prototype = "I2M.C.STR x y"  
  short = "Set strumming of chord `x` (0..8) to `x` ms (0..32767), use `x = 0` to set for all chords"   
  description = """
  Set strumming of chord `x` (0..8) to `x` ms (0..32767). Strumming plays the notes of a chord arpeggiated, with an interval of `y` ms in between notes. Default is `y = 0`. Use `x = 0` to set strumming for all chords.
  """
  
  ["I2M.C.VCUR"]  
  prototype = "I2M.C.VCUR w x y z"  
  aliases = ["I2M.C.V~"]
  short = "Set velocity curve for chord `w` (0..8) with curve type `x` (0..5), start value `y`% (0..32767) and end value `z`% (0..32767), use `w = 0` to set for all chords, use `x = 0` to turn off"   
  description = """
  Set velocity curve for chord `w` (0..8) with curve type `x` (0..5), start value `y`% (0..32767) and end value `z`% (0..32767). This will affect the velocity of the notes in the order they are defined in the chord. Start and end percentages refer to the velocity with which the chord is played via `I2M.C`. Use `x = 0` to turn velocity curve off. The following curves are available: 0) Off 1) Linear 2) Exponential 3) Triangle 4) Square 5) Random. Use `w = 0` to set velocity curve for all chords. Try a random curve with subtle values for a humanizing effect.
  """
  
  ["I2M.C.TCUR"]  
  prototype = "I2M.C.TCUR w x y z"  
  aliases = ["I2M.C.T~"]
  short = "Set time curve to strumming for chord `w` (0..8) with curve type `x` (0..5), start value `y`% (0..32767) and end value `z`% (0..32767), use `w = 0` to set for all chords, use `x = 0` to turn off"   
  description = """
  Set time curve for chord `w` (0..8) with curve type `x` (0..5), start value `y`% (0..32767) and end value `z`% (0..32767). This will affect the time interval between the notes in the order they are defined in the chord. Start and end percentages refer to the current strumming setting of the chord, set via `I2M.C.STR`. Use `x = 0` to turn time curve off. The following curves are available: 0) Off 1) Linear 2) Exponential 3) Triangle 4) Square 5) Random. Use `w = 0` to set time curve for all chords. Try a square curve with similar values to create swing. Try a random curve with subtle values for a humanizing effect.
  """
  
  ["I2M.C.DIR"]  
  prototype = "I2M.C.DIR x y"  
  short = "Set play direction for chord `x` (0..8) to direction `y` (0..8)"
  description = """
  Set play direction for chord `x` (0..8) to direction `y` (0..8). This will affect the order in which chord notes are played. Make sure to set strumming via `I2M.C.STR`. The following directions are available: 0) Forward (0,1,2,3,4) 1) Backward (4,3,2,1,0) 2) Inside out (2,1,3,0,4) 3) Outside in (0,4,1,3,2) 4) Random (2,3,1,0,4) 5) Bottom repeat (0,1,0,2,0,3,0,4) 6) Top repeat (0,4,1,4,2,4,3,4) 7) Pingpong (0,1,2,3,4,3,2,1,0) 8) Ping & pong (0,1,2,3,4,4,3,2,1,0). Default is `y = 0`.
  """
  
  ["I2M.C.QN"]
  prototype = "I2M.C.QN x y z"    
  short = "Get the transformed note number of a chord note for chord `x` (1..8) with root note `y` (-127..127) at index `z` (0..7)"  
  description = """
  Get the transformed note number of a chord note for chord `x` (1..8) with root note `y` (-127..127) at index `z` (0..7). The response is the absolute note number (0..127). Use this OP to send the transformed note number to other devices within eurorack, e.g. via V/OCT to any oscillator or via I2C to I2C-enabled devices like Just Friends or disting EX.
  """
  
  ["I2M.C.QV"]
  prototype = "I2M.C.QV x y z"   
  short = "Get the transformed note velocity of a chord note for chord `x` (1..8) with root velocity `y` (1..127) at index `z` (0..7)"  
  description = """
  Get the transformed note velocity of a chord note for chord `x` (1..8) with root velocity `y` (1..127) at index `z` (0..7). The response is the absolute note velocity (0..127). Use this OP to send the transformed note velocity to other devices within eurorack, e.g. via CV to a VCA or via I2C to I2C-enabled devices like Just Friends or disting EX.
  """
  
  ["I2M.B.R"]  
  prototype = "I2M.B.R x" 
  short = "Turn recording of notes into the buffer on or off"
  description = """
  Turn recording of notes into the buffer on or off. `x = 1` is on, `x = 0` is off. If recording is turned on, all outgoing MIDI notes are recorded into the buffer, storing note number, note velocity, note duration and MIDI channel.
  """
  
  ["I2M.B.L"]  
  prototype = "I2M.B.L x"  
  short = "Set the length of the buffer to `x` ms (0..32767)"
  description = """
  Set the length of the buffer to `x` ms (0..32767). Default is `x = 1000`.
  """
  
  ["I2M.B.START"]  
  prototype = "I2M.B.START x"  
  short = "Add an offset of `x` ms (0..32767) to the start of the buffer"
  description = """
  Add an offset of `x` ms (0..32767) to the start of the buffer. The offset time is non-distructively added to the start of the looping buffer. E.g. if the buffer length is set to `1000` ms and start offset is set to `200` ms, the buffer will loop the section `200` - `1000` ms, resulting in a looping buffer length of `800` ms. Default is `x = 0`.
  """
  
  ["I2M.B.END"]  
  prototype = "I2M.B.END x"  
  short = "Add a negative offset of `x` ms (0..32767) to the end of the buffer"
  description = """
  Add a negative offset of `x` ms (0..32767) to the end of the buffer. The offset time is non-distructively substracted from the end of the looping buffer. E.g. if the buffer length is set to `1000` ms, start offset is set to `200` ms, and end offset is set to `300` ms, the buffer will loop the section `200` - `700` ms, resulting in a looping buffer length of `500` ms. Default is `x = 0`.
  """
  
  ["I2M.B.DIR"]    
  prototype = "I2M.B.DIR x"  
  short = "Set the play direction `x` (0..2) of the buffer"
  description = """
  Set the play direction `x` (0..2) of the buffer. The following directions are available: 0) Forward 1) Backward 2) Pingpong. Keep in mind that changing the direction only affects notes that have been already recorded to the buffer before the change in direction; all notes recorded afterwards are recorded relative to the new direction. Default is `x = 0`.
  """
  
  ["I2M.B.SPE"]  
  prototype = "I2M.B.SPE x"  
  short = "Set the playing speed `x` (1..32767) of the buffer. `x = 100` is equivalent to 'normal speed', `x = 50` means double the speed, `x = 200` means half the speed, etc."
  description = """
  Set the playing speed `x` (1..32767) of the buffer. `x = 100` is equivalent to 'normal speed', `x = 50` means double the speed, `x = 200` means half the speed, etc. Of course, all values in between can be chosen. Keep in mind that changing the speed only affects notes that have been already recorded to the buffer before the change in speed; all notes recorded afterwards are recorded relative to the new speed. Default is `x = 100`.
  """
  
  ["I2M.B.FB"]  
  prototype = "I2M.B.FB x"  
  short = "Set the feedback length `x` (0..255) of the buffer"
  description = """
  Set the feedback length `x` (0..255) of the buffer. By default, each recorded note is getting decreased in velocity with each buffer iteration. The feedback value determines, how many buffer iterations a recorded note will 'survive' in the buffer, before the decreasing velocity will reach zero (meaning the note is remove from the buffer). Set `x = 0` to turn off the automatic decrease in velocity, keeping notes in the buffer indefinitely. Use this setting in combination with `I2M.B.VSHIFT` or `I2M.B.CLR`. Default is `x = 8`.
  """
  
  ["I2M.B.NSHIFT"]  
  prototype = "I2M.B.NSHIFT x"  
  short = "Set the note shift of recorded notes to `x` semitones (-127..127)"
  description = """
  Set the note shift of recorded notes to `x` semitones (-127..127). With each buffer iteration, this value gets added accumulatively to the original note number. E.g. with a note shift setting of `x = 12`, a recorded note `60` will be played as note `72` during the first buffer iteration, as note `84` during the second iteration, etc. Default is `x = 0`.
  """
  
  ["I2M.B.VSHIFT"]    
  prototype = "I2M.B.VSHIFT x"  
  short = "Set the velocity shift of recorded notes to `x` (-127..127)"
  description = """
  Set the velocity shift of recorded notes to `x` (-127..127). With each buffer iteration, this value gets added accumulatively to the original note velocity. E.g. with a velocity shift setting of `x = -10`, a recorded note with velocity `110` will be played with velocity `100` during the first buffer iteration, with velocity `90` during the second iteration, etc. Default is `x = 0`.  Please note: This setting is the twin sibling of `I2M.B.FB`: While `I2M.B.FB` defines the number of iterations determining the amount of change in velocity per iteration, `I2M.B.VSHIFT` defines the amount of change in velocity per iteration determining the number of iterations.
  """
  
  ["I2M.B.TSHIFT"]    
  prototype = "I2M.B.TSHIFT x"  
  short = "Set the note duration shift ('time shift') of recorded notes to `x` ms (-16384..16383)"
  description = """
  Set the note duration shift ('time shift') of recorded notes to `x` ms (-16384..16383). With each buffer iteration, this value gets added accumulatively to the original note duration. E.g. with a duration shift setting of `x = 100`, a recorded note with duration `200` will be played with duration `300` during the first buffer iteration, with duration `400` during the second iteration, etc. Default is `x = 0`.
  """
  
  ["I2M.B.NOFF"]     
  prototype = "I2M.B.NOFF x"  
  short = "Set the note offset of recorded notes to `x` semitones (-127..127)"
  description = """
  Set the note offset of recorded notes to `x` semitones (-127..127). This value gets added once to the original note number and is then kept for all buffer iterations. E.g. with a note offset setting of `x = 7`, a recorded note `60` will be played as note `67` for all buffer iterations. Default is `x = 0`.
  """
  
  ["I2M.B.VOFF"]    
  prototype = "I2M.B.VOFF x"  
  short = "Set the velocity offset of recorded notes to `x` (-127..127)"
  description = """
  Set the velocity offset of recorded notes to `x` (-127..127). This value gets added once to the original note velocity and is then kept for all buffer iterations. E.g. with a velocity offset setting of `x = -50`, a recorded note with velocity `120` will be played with velocity `70` for all buffer iterations. Default is `x = 0`.
  """
  
  ["I2M.B.TOFF"]    
  prototype = "I2M.B.TOFF x"  
  short = "Set the note duration offset ('time offset') of recorded notes to `x` ms (-16384..16383)"
  description = """
  Set the note duration offset ('time offset') of recorded notes to `x` ms (-16384..16383). This value gets added once to the original note duration and is then kept for all buffer iterations. E.g. with a duration offset setting of `x = -50`, a recorded note with duration `200` will be played with duration `150` for all buffer iterations. Default is `x = 0`.
  """
  
  ["I2M.B.CLR"]  
  prototype = "I2M.B.CLR"  
  short = "Clear the buffer, erasing all recorded notes in the buffer"
  
  ["I2M.B.MODE"]    
  prototype = "I2M.B.MODE x"  
  short = "Set the buffer mode to `x` (0..1). 1) Digital 2) Tape"
  description = """
  Set the buffer mode to `x` (0..1). The buffer can work in two different modes: 1) Digital 2) Tape. In Digital mode, the buffer speed ( set via `I2M.B.SPE`) works independent of note number and note duration: If the buffer speed changes, the note number and note duration of a recorded note stays unaffected. In Tape mode on the other hand, the buffer speed affects the note number and note duration of recorded notes in the buffer, mimicking the behaviour of real tape. If the buffer speed gets doubled, the note number is pitched up by one octave and the note duration gets divided in half. Similarly, if the buffer speed gets divided in half, the note number is pitched down an octave and the note duration gets doubled, etc. Default is `x = 0`.
  """
  
  ["I2M.Q.CH"]  
  prototype = "I2M.Q.CH"  
  prototype_set = "I2M.Q.CH x"  
  aliases = ["I2M.Q.#"]  
  short = "Get currently set MIDI channel / Set MIDI channel `x` (1..16) for MIDI in"  
  description = """
  Get currently set MIDI channel / Set MIDI channel `x` (1..16) for MIDI in. Default is `x = 1`.
  """
  
  ["I2M.Q.LATCH"]  
  prototype = "I2M.Q.LATCH x"  
  short = "Turn on or off 'latching' for MIDI notes received via MIDI in"  
  description = """
  Turn on or off 'latching' for MIDI notes received via MIDI in. `x = 0` means Note Off messages are recorded in the note history, so only notes with keys currently held down on the MIDI controller are stored. `x = 1` means Note Off messages are not recorded in the note history, so notes are still stored after releasing the respective key on the MIDI controller. Default is `x = 1`.
  """
  
  ["I2M.Q.NOTE"]  
  prototype = "I2M.Q.NOTE x"  
  aliases = ["I2M.Q.N"]  
  short = "Get `x` (0..7) last note number (0..127) received via MIDI in"
  
  ["I2M.Q.VEL"]  
  prototype = "I2M.Q.VEL x"  
  aliases = ["I2M.Q.V"]  
  short = "Get `x` (0..7) last note velocity (1..127) received via MIDI in"
  
  ["I2M.Q.CC"]  
  prototype = "I2M.Q.CC x"  
  short = "Get current value (0..127) of controller `x` (0..127) received via MIDI in"  
  
  ["I2M.Q.LCH"]  
  prototype = "I2M.Q.LCH"  
  short = "Get the latest channel (1..16) received via MIDI in"  
  
  ["I2M.Q.LN"]  
  prototype = "I2M.Q.LN"   
  short = "Get the note number (0..127) of the latest Note On received via MIDI in"  
  
  ["I2M.Q.LV"]  
  prototype = "I2M.Q.LV"  
  short = "Get the velocity (1..127) of the latest Note On received via MIDI in"
  
  ["I2M.Q.LO"]  
  prototype = "I2M.Q.LO"  
  short = "Get the note number (0..127) of the latest Note Off received via MIDI in"  
  
  ["I2M.Q.LC"]  
  prototype = "I2M.Q.LC"  
  short = "Get the latest controller number (0..127) received via MIDI in"   
  
  ["I2M.Q.LCC"]  
  prototype = "I2M.Q.LCC"  
  short = "Get the latest controller value (0..127) received via MIDI in"  
  
  ["I2M.PANIC"]  
  prototype = "I2M.PANIC"  
  short = "Send MIDI Note Off messages for all notes on all channels, and reset note duration, shift, repetition, ratcheting, min/max"