######################################################################################
##
######################################################################################
name                   = droid
file_extensions []     = ini;


######################################################################################
## STYLE DEFS
######################################################################################

styles [] {

   .comment : style {
      color             = light_green
      italic            = true
      ace_scope         = comment
      textmate_scope    = comment
      pygments_scope    = Comment
   }

   .numeric : style {
      color             = blue
      ace_scope         = constant.numeric
      textmate_scope    = constant.numeric
      pygments_scope    = Number
   }

   .ioregister : style {
      color             = green
      italic            = true
      ace_scope         = support.constant
      textmate_scope    = support.constant
      pygments_scope    = String.Other
   }

   .cable : style {
      color             = yellow
      ace_scope         = constant.other
      textmate_scope    = constant.other
      pygments_scope    = Name.Constant
   }

   .punctuation : style {
      color             = red_2
      ace_scope         = punctuation
      textmate_scope    = punctuation
      pygments_scope    = Punctuation
   }

   .circuitheader : style {
      color             = pink
      ace_scope         = support.class
      textmate_scope    = support.class
      pygments_scope    = Name.Class
   }

   .inputparameter : style {
      color             = purple
      ace_scope         = support.variable
      textmate_scope    = support.variable
      pygments_scope    = Name.Variable
   }

   .outputparameter : style {
      color             = violet
      ace_scope         = support.other.variable
      textmate_scope    = support.other.variable
      pygments_scope    = Name.Variable.Class
   }

   .illegal : style {
      color                 = white
      background_color      = red
      ace_scope             = invalid
      textmate_scope        = invalid
      pygments_scope        = Generic.Error
   }

}

##########################################################################################
## CONTEXT DEFS
##########################################################################################

contexts [] {

   ######################################################################################
   ## MAIN CONTEXT - Entry point context
   ######################################################################################

   main : context {

      # BASICS
      : include "basics";
      # CONTROLLERS
      : include "controllers";

      # DROID CIRCUIT DEFS
      : include "adc";
      : include "algoquencer";
      : include "arpeggio";
      : include "bernoulli";
      : include "burst";
      : include "button";
      : include "buttongroup";
      : include "calibrator";
      : include "case";
      : include "chord";
      : include "clockedtrigger";
      : include "clocktool";
      : include "compare";
      : include "contour";
      : include "copy";
      : include "crossfader";
      : include "cvlooper";
      : include "dac";
      : include "delay";
      : include "detune";
      : include "display";
      : include "droid";
      : include "encoderbank";
      : include "encoder";
      : include "encoquencer";
      : include "euklid";
      : include "explin";
      : include "faderbank";
      : include "fadermatrix";
      : include "firefacecontrol";
      : include "flipflop";
      : include "fold";
      : include "fourstatebutton";
      : include "gatetool";
      : include "ifequal";
      : include "lfo";
      : include "logic";
      : include "math";
      : include "matrixmixer";
      : include "midifileplayer";
      : include "midiin";
      : include "midiout";
      : include "midithrough";
      : include "minifonion";
      : include "mixer";
      : include "motoquencer";
      : include "motorfader";
      : include "multicompare";
      : include "notchedpot";
      : include "notebuttons";
      : include "nudge";
      : include "octave";
      : include "once";
      : include "outputcalibrator";
      : include "polytool";
      : include "pot";
      : include "quantizer";
      : include "queue";
      : include "random";
      : include "recorder";
      : include "sample";
      : include "select";
      : include "sequencer";
      : include "sinfonionlink";
      : include "slew";
      : include "spring";
      : include "superjust";
      : include "switch";
      : include "switchedpot";
      : include "timing";
      : include "togglebutton";
      : include "transient";
      : include "triggerdelay";
      : include "unusedfaders";
      : include "vcotuner";
      : include "watch";
      # ILLEGALS
      : include "illegals";

   }

   ######################################################################################
   ## BASICS: COMMENTS, NUMERICS, REGISTERS, CABLES, PUNCTUATIONS
   ######################################################################################

   basics : context {
      : include "comment";
      : include "numeric";
      : include "ioregister";
      : include "cable";
      : include "punct";
   }

   # COMMENTS
   comment : context {
      : pattern {
         regex       \= (//.*)
         styles []    = .comment;
      }
      : pattern {
         regex       \= (#.*)
         styles []    = .comment;
      }
   }

   # NUMERIC
   numeric : context {
      : pattern {
         regex       \= (on|off|-?([0-9]|[1-9][0-9]*)(.[0-9]+)?[V%]?)
         styles []    = .numeric;
      }
   }

   # IOREGISTERS
   ioregister : context {
      :pattern {
         regex       \= ([ionION][1-8])
         styles []    = .ioregister;
      }
      :pattern {
         regex       \= ([rR](3[0-2]|[1-2]?[0-9]|[0-9]))
         styles []    = .ioregister;
      }
      :pattern {
         regex       \= ([gG](1[012]|[1-9]))
         styles []    = .ioregister;
      }
      :pattern {
         regex       \= ([xX]1)
         styles []    = .ioregister;
      }
      :pattern {
         regex       \= ([lbLB](1[1-6]|[1-9]).([1-2][0-9]|3[0-2]|[1-9]))
         styles []    = .ioregister;
      }
      :pattern {
         regex       \= ([psPS](1[1-6]|[1-9]).(10|[1-9]))
         styles []    = .ioregister;
      }
   }

   # INTERNAL CABLES
   cable : context {
      : pattern {
         regex       \= (_[A-Za-z0-9]*)
         styles []    = .cable;
      }
   }

   # PUNCTUATIONS
   punct : context {
      : pattern {
         regex       \= ([=+-/*\s])
         styles []    = .punctuation;
      }
   }

   # CONTROLLERS
   controllers : context {
      :pattern {
         regex       \= (\[p2b8\]|\[p4b2\]|\[b32\]|\[p10\]|\[s10\]|\[m4\]|\[x7\])
         styles []    = .circuitheader;
      }
   }

   illegals : context {
      : pattern {
         regex          \= ([^\s])
         styles []       = .illegal;
      }
   }

   ######################################################################################
   ## DROID CIRCUIT DEFS
   ######################################################################################

  # ---------------------------- ADC ----------------------------
  adc : context {

      : push {
         regex        \= (\[adc\])
         styles []       = .circuitheader;
         context []      = inside_adc;
      }   }   inside_adc : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (minimum|maximum|input)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (bit9|bit8|bit7|bit6|bit5|bit4|bit3|bit2|bit12|bit11|bit10|bit1|bit)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- ALGOQUENCER ----------------------------
  algoquencer : context {

      : push {
         regex        \= (\[algoquencer\])
         styles []       = .circuitheader;
         context []      = inside_algoquencer;
      }   }   inside_algoquencer : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (variation|unmutebutton|startaccents|selectat|select|savepreset|rollsteps|rollstartvelo|rolls|rollcount|reset|reroll|repeats|prevpattern|preset|pitchresolution|pitchlow|pitchhigh|pitch9|pitch8|pitch7|pitch6|pitch5|pitch4|pitch3|pitch2|pitch16|pitch15|pitch14|pitch13|pitch12|pitch11|pitch10|pitch1|pitch|pattern|offbeats|nextpattern|mutebutton|morphs|loadpreset|lengthbutton|length|header|gatelength|fills|fillorder|dontsave|distribution|display|dejavu|clock|clearpage|clearall|clear|button9|button8|button7|button6|button5|button4|button3|button2|button16|button15|button14|button13|button12|button11|button10|button1|button|branches|alternaterepeats|alternatebutton|alternatebars|activity|accentlow|accenthigh|accentbutton)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (unmuteled|trigger|startofbar|rollvelocity|pitch|muteled|morphled|lengthoutput|led9|led8|led7|led6|led5|led4|led3|led2|led16|led15|led14|led13|led12|led11|led10|led1|led|gate|fillsled|branch|barled4|barled3|barled2|barled1|barled|accent)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- ARPEGGIO ----------------------------
  arpeggio : context {

      : push {
         regex        \= (\[arpeggio\])
         styles []       = .circuitheader;
         context []      = inside_arpeggio;
      }   }   inside_arpeggio : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (tuningpitch|tuningmode|transpose|startnote|selectnoteshift|selectfill5|selectfill4|selectfill3|selectfill2|selectfill1|select9|select7|select5|select3|select13|select11|select1|root|reset|range|pitch|pingpong|pattern|octaves|noteshift|harmonicshift|drop|direction|degree|clock|butterfly|autoreset)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- BERNOULLI ----------------------------
  bernoulli : context {

      : push {
         regex        \= (\[bernoulli\])
         styles []       = .circuitheader;
         context []      = inside_bernoulli;
      }   }   inside_bernoulli : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (input|distribution)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output2|output1)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- BURST ----------------------------
  burst : context {

      : push {
         regex        \= (\[burst\])
         styles []       = .circuitheader;
         context []      = inside_burst;
      }   }   inside_burst : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (trigger|taptempo|skip|reset|rate|hz|count)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- BUTTON ----------------------------
  button : context {

      : push {
         regex        \= (\[button\])
         styles []       = .circuitheader;
         context []      = inside_button;
      }   }   inside_button : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (value4|value3|value2|value1|value|states|startvalue|selectat|select|savepreset|preset|onvalue|offvalue|longpresstime|loadpreset|header|doubleclickmode|dontsave|display|clearall|clear|button)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (shortpress|output|negated|longpress|led|inverted)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- BUTTONGROUP ----------------------------
  buttongroup : context {

      : push {
         regex        \= (\[buttongroup\])
         styles []       = .circuitheader;
         context []      = inside_buttongroup;
      }   }   inside_buttongroup : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (value9|value8|value7|value6|value5|value4|value32|value31|value30|value3|value29|value28|value27|value26|value25|value24|value23|value22|value21|value20|value2|value19|value18|value17|value16|value15|value14|value13|value12|value11|value10|value1|value|startbutton|selectat|select|savepreset|preset|minactive|maxactive|longpresstime|loadpreset|header|dontsave|display|clearall|clear|button9|button8|button7|button6|button5|button4|button32|button31|button30|button3|button29|button28|button27|button26|button25|button24|button23|button22|button21|button20|button2|button19|button18|button17|button16|button15|button14|button13|button12|button11|button10|button1|button)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (selectionchanged|output|longpress|led9|led8|led7|led6|led5|led4|led32|led31|led30|led3|led29|led28|led27|led26|led25|led24|led23|led22|led21|led20|led2|led19|led18|led17|led16|led15|led14|led13|led12|led11|led10|led1|led|extrapress|buttonpress|buttonoutput9|buttonoutput8|buttonoutput7|buttonoutput6|buttonoutput5|buttonoutput4|buttonoutput32|buttonoutput31|buttonoutput30|buttonoutput3|buttonoutput29|buttonoutput28|buttonoutput27|buttonoutput26|buttonoutput25|buttonoutput24|buttonoutput23|buttonoutput22|buttonoutput21|buttonoutput20|buttonoutput2|buttonoutput19|buttonoutput18|buttonoutput17|buttonoutput16|buttonoutput15|buttonoutput14|buttonoutput13|buttonoutput12|buttonoutput11|buttonoutput10|buttonoutput1|buttonoutput)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- CALIBRATOR ----------------------------
  calibrator : context {

      : push {
         regex        \= (\[calibrator\])
         styles []       = .circuitheader;
         context []      = inside_calibrator;
      }   }   inside_calibrator : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (tunelowtail|tunehightail|tune9|tune8|tune7|tune6|tune5|tune4|tune3|tune2|tune1|tune0|tune|selectat|select|savepreset|preset|nudgeup|nudgedown|nudgeamount|loadpreset|input|header|forcedisplay|dontsave|display|clearhere|clearall|clear)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output|ledup|leddown|correction)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- CASE ----------------------------
  case : context {

      : push {
         regex        \= (\[case\])
         styles []       = .circuitheader;
         context []      = inside_case;
      }   }   inside_case : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (value9|value8|value7|value6|value5|value4|value3|value2|value16|value15|value14|value13|value12|value11|value10|value1|value|else|case9|case8|case7|case6|case5|case4|case3|case2|case16|case15|case14|case13|case12|case11|case10|case1|case)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- CHORD ----------------------------
  chord : context {

      : push {
         regex        \= (\[chord\])
         styles []       = .circuitheader;
         context []      = inside_chord;
      }   }   inside_chord : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (tuningpitch|tuningmode|trigger|transpose|spread|selectnoteshift|selectfill5|selectfill4|selectfill3|selectfill2|selectfill1|select9|select7|select5|select3|select13|select11|select1|root|pitch|noteshift|inversion|harmonicshift|degree)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output4|output3|output2|output1|output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- CLOCKEDTRIGGER ----------------------------
  clockedtrigger : context {

      : push {
         regex        \= (\[clockedtrigger\])
         styles []       = .circuitheader;
         context []      = inside_clockedtrigger;
      }   }   inside_clockedtrigger : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (value|trigger|clock|clear)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (pendingvalue|pendingtrigger|clockedvalue|clockedtrigger)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- CLOCKTOOL ----------------------------
  clocktool : context {

      : push {
         regex        \= (\[clocktool\])
         styles []       = .circuitheader;
         context []      = inside_clocktool;
      }   }   inside_clocktool : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (reset|multiply|gatelength|dutycycle|divide|delay|clock)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (outputpitch|output|inputpitch)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- COMPARE ----------------------------
  compare : context {

      : push {
         regex        \= (\[compare\])
         styles []       = .circuitheader;
         context []      = inside_compare;
      }   }   inside_compare : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (precision|input|ifless|ifgreater|ifequal|else|compare)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- CONTOUR ----------------------------
  contour : context {

      : push {
         regex        \= (\[contour\])
         styles []       = .circuitheader;
         context []      = inside_contour;
      }   }   inside_contour : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (zerocrossing|velocity|trigger|taptempo|swelltime|swellshape|swelllevel|swell|sustain|startfromzero|shape|retrigger|releaseshape|release|predelay|pitch|loop|level|hold|gate|decayshape|decay|attackshape|attack|abortattack)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output|negated|inverted|endofrelease|endofpredelay|endofhold|endofdecay|endofattack)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- COPY ----------------------------
  copy : context {

      : push {
         regex        \= (\[copy\])
         styles []       = .circuitheader;
         context []      = inside_copy;
      }   }   inside_copy : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (input)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- CROSSFADER ----------------------------
  crossfader : context {

      : push {
         regex        \= (\[crossfader\])
         styles []       = .circuitheader;
         context []      = inside_crossfader;
      }   }   inside_crossfader : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (input8|input7|input6|input5|input4|input3|input2|input1|input|fade)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- CVLOOPER ----------------------------
  cvlooper : context {

      : push {
         regex        \= (\[cvlooper\])
         styles []       = .circuitheader;
         context []      = inside_cvlooper;
      }   }   inside_cvlooper : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (tapespeed|reset|pause|overlay|overdub|loopswitch|length|gatein|cvin|clock|bypass)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (gateout|cvout)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- DAC ----------------------------
  dac : context {

      : push {
         regex        \= (\[dac\])
         styles []       = .circuitheader;
         context []      = inside_dac;
      }   }   inside_dac : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (minimum|maximum|bit9|bit8|bit7|bit6|bit5|bit4|bit3|bit2|bit12|bit11|bit10|bit1|bit)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- DELAY ----------------------------
  delay : context {

      : push {
         regex        \= (\[delay\])
         styles []       = .circuitheader;
         context []      = inside_delay;
      }   }   inside_delay : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (timewindow|save|sample|numberin|load|gatein8|gatein7|gatein6|gatein5|gatein4|gatein3|gatein2|gatein1|gatein|filenumber|delay|cvin|clock|bypass)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (overflow|numberout|gateout8|gateout7|gateout6|gateout5|gateout4|gateout3|gateout2|gateout1|gateout|cvout)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- DETUNE ----------------------------
  detune : context {

      : push {
         regex        \= (\[detune\])
         styles []       = .circuitheader;
         context []      = inside_detune;
      }   }   inside_detune : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (tuningpitch|tuningmode|input8|input7|input6|input5|input4|input3|input2|input1|input|detune)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output8|output7|output6|output5|output4|output3|output2|output1|output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- DISPLAY ----------------------------
  display : context {

      : push {
         regex        \= (\[display\])
         styles []       = .circuitheader;
         context []      = inside_display;
      }   }   inside_display : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (value|useasdefault|trigger|threshold|text|takeovercontrols|selectat|select|screensaver|numbermode|linger|header|fontsize|display)
         styles []    = .inputparameter;
      }
      : include "basics";
   }
  # ---------------------------- DROID ----------------------------
  droid : context {

      : push {
         regex        \= (\[droid\])
         styles []       = .circuitheader;
         context []      = inside_droid;
      }   }   inside_droid : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (uislowdown|statusdump|startx7upgrade|startcontrollerupgrade|maxslope8|maxslope7|maxslope6|maxslope5|maxslope4|maxslope3|maxslope2|maxslope1|maxslope|m4touchgain8|m4touchgain7|m4touchgain6|m4touchgain5|m4touchgain4|m4touchgain3|m4touchgain2|m4touchgain1|m4touchgain|m4notchpower|m4faderspeed|lpfilter8|lpfilter7|lpfilter6|lpfilter5|lpfilter4|lpfilter3|lpfilter2|lpfilter1|lpfilter|ledbrightness|clearall|clear|calibrate)
         styles []    = .inputparameter;
      }
      : include "basics";
   }
  # ---------------------------- ENCODERBANK ----------------------------
  encoderbank : context {

      : push {
         regex        \= (\[encoderbank\])
         styles []       = .circuitheader;
         context []      = inside_encoderbank;
      }   }   inside_encoderbank : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (startvalue|snapto|snapforce|smooth|sensivity|selectat|select|savepreset|preset|outputscale|outputoffset|notch|negativecolor|mode|loadpreset|ledfill|led8|led7|led6|led5|led4|led3|led2|led1|led|header|firstencoder|dontsave|display|discrete|color|clearall|clear|autozoom)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output8|output7|output6|output5|output4|output3|output2|output1|output|button8|button7|button6|button5|button4|button3|button2|button1|button)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- ENCODER ----------------------------
  encoder : context {

      : push {
         regex        \= (\[encoder\])
         styles []       = .circuitheader;
         context []      = inside_encoder;
      }   }   inside_encoder : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (startvalue|snapto|snapforce|smooth|sharewithnext|sensivity|selectat|select|savepreset|preset|override|outputscale|outputoffset|notch|negativecolor|movementticks|mode|loadpreset|ledfill|led|header|encoder|dontsave|display|discrete|color|clearall|clear|autozoom)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (valuechanged|output|movedup|moveddown|button)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- ENCOQUENCER ----------------------------
  encoquencer : context {

      : push {
         regex        \= (\[encoquencer\])
         styles []       = .circuitheader;
         context []      = inside_encoquencer;
      }   }   inside_encoquencer : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (zorder|tuningpitch|tuningmode|transpose|taptempo|stepcopy|startstep|shiftsteps|setendstep|selectnoteshift|selectfill5|selectfill4|selectfill3|selectfill2|selectfill1|selectat|select9|select7|select5|select3|select13|select11|select1|select|savepreset|run|root|reset|repeatshift|recordsilence|recordmode|ratchetshift|quantize|preset|pingpong|pattern|pastefaders|pastebuttons|paste|page|numsteps|numfaders|nume4s|noteshift|mute|metricsaver|luckyties|luckyspread|luckyskips|luckyshuffle|luckyscope|luckyreverse|luckyrepeats|luckyratchets|luckyrandomizecv|luckyinvert|luckygates|luckygateprob|luckygatepattern|luckyfaders|luckycvs|luckycvdrift|luckycvbase|luckychance|luckybuttons|luckyamount|loadpreset|linktonext|ledpreview|keyboardmode|keyboardgate|keyboardcv|invert|holdcv|harmonicshift|gatename|gatelength|form|firstfader|fadermode|endstep|doublerange|dontsave|display|direction|degree|defaultgate|defaultcv|cvrange|cvnotches|cvname|cvbase|copy|constantlength|composemode|clock|clearstartend|clearskips|clearrepeats|clearall|clear|buttonmode|buttoncolor|bulkedit|autoreset|accumulatorrange)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (startstepout|startofsequence|startofpart|gate|endstepout|cv|currentstep|currentpage|accumulator)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- EUKLID ----------------------------
  euklid : context {

      : push {
         regex        \= (\[euklid\])
         styles []       = .circuitheader;
         context []      = inside_euklid;
      }   }   inside_euklid : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (reset|outputsignal|offset|length|clock|beats)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output|offbeats)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- EXPLIN ----------------------------
  explin : context {

      : push {
         regex        \= (\[explin\])
         styles []       = .circuitheader;
         context []      = inside_explin;
      }   }   inside_explin : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (startvalue|mix|input|endvalue)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- FADERBANK ----------------------------
  faderbank : context {

      : push {
         regex        \= (\[faderbank\])
         styles []       = .circuitheader;
         context []      = inside_faderbank;
      }   }   inside_faderbank : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (startvalue|selectat|select|savepreset|preset|notches|loadpreset|ledvalue9|ledvalue8|ledvalue7|ledvalue6|ledvalue5|ledvalue4|ledvalue3|ledvalue2|ledvalue16|ledvalue15|ledvalue14|ledvalue13|ledvalue12|ledvalue11|ledvalue10|ledvalue1|ledvalue|ledcolor|header|firstfader|dontsave|display|clearall|clear)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output9|output8|output7|output6|output5|output4|output3|output2|output16|output15|output14|output13|output12|output11|output10|output1|output|button9|button8|button7|button6|button5|button4|button3|button2|button16|button15|button14|button13|button12|button11|button10|button1|button)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- FADERMATRIX ----------------------------
  fadermatrix : context {

      : push {
         regex        \= (\[fadermatrix\])
         styles []       = .circuitheader;
         context []      = inside_fadermatrix;
      }   }   inside_fadermatrix : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (startvalue4|startvalue3|startvalue2|startvalue1|startvalue|selectat|select|savepreset|rowcolumn|preset|notches4|notches3|notches2|notches1|notches|loadpreset|ledvalue44|ledvalue43|ledvalue42|ledvalue41|ledvalue4|ledvalue34|ledvalue33|ledvalue32|ledvalue31|ledvalue3|ledvalue24|ledvalue23|ledvalue22|ledvalue21|ledvalue2|ledvalue14|ledvalue13|ledvalue12|ledvalue11|ledvalue1|ledcolor4|ledcolor3|ledcolor2|ledcolor1|ledcolor|header|firstfader|dontsave|display|clearall|clear)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output44|output43|output42|output41|output4|output34|output33|output32|output31|output3|output24|output23|output22|output21|output2|output14|output13|output12|output11|output1|button44|button43|button42|button41|button4|button34|button33|button32|button31|button3|button24|button23|button22|button21|button2|button14|button13|button12|button11|button1)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- FIREFACECONTROL ----------------------------
  firefacecontrol : context {

      : push {
         regex        \= (\[firefacecontrol\])
         styles []       = .circuitheader;
         context []      = inside_firefacecontrol;
      }   }   inside_firefacecontrol : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (update|unmute9|unmute8|unmute7|unmute6|unmute5|unmute4|unmute3|unmute2|unmute16|unmute15|unmute14|unmute13|unmute12|unmute11|unmute10|unmute1|unmute|trs|selectat|select|postfader9|postfader8|postfader7|postfader6|postfader5|postfader4|postfader3|postfader2|postfader16|postfader15|postfader14|postfader13|postfader12|postfader11|postfader10|postfader1|postfader|phonesoutput2|phonesoutput1|phonesoutput|pan9|pan8|pan7|pan6|pan5|pan4|pan3|pan2|pan16|pan15|pan14|pan13|pan12|pan11|pan10|pan1|pan|outputmix9in9|outputmix9in8|outputmix9in7|outputmix9in6|outputmix9in5|outputmix9in4|outputmix9in3|outputmix9in2|outputmix9in16|outputmix9in15|outputmix9in14|outputmix9in13|outputmix9in12|outputmix9in11|outputmix9in10|outputmix9in1|outputmix9in|outputmix8in9|outputmix8in8|outputmix8in7|outputmix8in6|outputmix8in5|outputmix8in4|outputmix8in3|outputmix8in2|outputmix8in16|outputmix8in15|outputmix8in14|outputmix8in13|outputmix8in12|outputmix8in11|outputmix8in10|outputmix8in1|outputmix8in|outputmix7in9|outputmix7in8|outputmix7in7|outputmix7in6|outputmix7in5|outputmix7in4|outputmix7in3|outputmix7in2|outputmix7in16|outputmix7in15|outputmix7in14|outputmix7in13|outputmix7in12|outputmix7in11|outputmix7in10|outputmix7in1|outputmix7in|outputmix6in9|outputmix6in8|outputmix6in7|outputmix6in6|outputmix6in5|outputmix6in4|outputmix6in3|outputmix6in2|outputmix6in16|outputmix6in15|outputmix6in14|outputmix6in13|outputmix6in12|outputmix6in11|outputmix6in10|outputmix6in1|outputmix6in|outputmix5in9|outputmix5in8|outputmix5in7|outputmix5in6|outputmix5in5|outputmix5in4|outputmix5in3|outputmix5in2|outputmix5in16|outputmix5in15|outputmix5in14|outputmix5in13|outputmix5in12|outputmix5in11|outputmix5in10|outputmix5in1|outputmix5in|outputmix4in9|outputmix4in8|outputmix4in7|outputmix4in6|outputmix4in5|outputmix4in4|outputmix4in3|outputmix4in2|outputmix4in16|outputmix4in15|outputmix4in14|outputmix4in13|outputmix4in12|outputmix4in11|outputmix4in10|outputmix4in1|outputmix4in|outputmix3in9|outputmix3in8|outputmix3in7|outputmix3in6|outputmix3in5|outputmix3in4|outputmix3in3|outputmix3in2|outputmix3in16|outputmix3in15|outputmix3in14|outputmix3in13|outputmix3in12|outputmix3in11|outputmix3in10|outputmix3in1|outputmix3in|outputmix2in9|outputmix2in8|outputmix2in7|outputmix2in6|outputmix2in5|outputmix2in4|outputmix2in3|outputmix2in2|outputmix2in16|outputmix2in15|outputmix2in14|outputmix2in13|outputmix2in12|outputmix2in11|outputmix2in10|outputmix2in1|outputmix2in|outputmix1in9|outputmix1in8|outputmix1in7|outputmix1in6|outputmix1in5|outputmix1in4|outputmix1in3|outputmix1in2|outputmix1in16|outputmix1in15|outputmix1in14|outputmix1in13|outputmix1in12|outputmix1in11|outputmix1in10|outputmix1in1|outputmix1in|outputmix16in9|outputmix16in8|outputmix16in7|outputmix16in6|outputmix16in5|outputmix16in4|outputmix16in3|outputmix16in2|outputmix16in16|outputmix16in15|outputmix16in14|outputmix16in13|outputmix16in12|outputmix16in11|outputmix16in10|outputmix16in1|outputmix16in|outputmix15in9|outputmix15in8|outputmix15in7|outputmix15in6|outputmix15in5|outputmix15in4|outputmix15in3|outputmix15in2|outputmix15in16|outputmix15in15|outputmix15in14|outputmix15in13|outputmix15in12|outputmix15in11|outputmix15in10|outputmix15in1|outputmix15in|outputmix14in9|outputmix14in8|outputmix14in7|outputmix14in6|outputmix14in5|outputmix14in4|outputmix14in3|outputmix14in2|outputmix14in16|outputmix14in15|outputmix14in14|outputmix14in13|outputmix14in12|outputmix14in11|outputmix14in10|outputmix14in1|outputmix14in|outputmix13in9|outputmix13in8|outputmix13in7|outputmix13in6|outputmix13in5|outputmix13in4|outputmix13in3|outputmix13in2|outputmix13in16|outputmix13in15|outputmix13in14|outputmix13in13|outputmix13in12|outputmix13in11|outputmix13in10|outputmix13in1|outputmix13in|outputmix12in9|outputmix12in8|outputmix12in7|outputmix12in6|outputmix12in5|outputmix12in4|outputmix12in3|outputmix12in2|outputmix12in16|outputmix12in15|outputmix12in14|outputmix12in13|outputmix12in12|outputmix12in11|outputmix12in10|outputmix12in1|outputmix12in|outputmix11in9|outputmix11in8|outputmix11in7|outputmix11in6|outputmix11in5|outputmix11in4|outputmix11in3|outputmix11in2|outputmix11in16|outputmix11in15|outputmix11in14|outputmix11in13|outputmix11in12|outputmix11in11|outputmix11in10|outputmix11in1|outputmix11in|outputmix10in9|outputmix10in8|outputmix10in7|outputmix10in6|outputmix10in5|outputmix10in4|outputmix10in3|outputmix10in2|outputmix10in16|outputmix10in15|outputmix10in14|outputmix10in13|outputmix10in12|outputmix10in11|outputmix10in10|outputmix10in1|outputmix10in|outputlevel9|outputlevel8|outputlevel7|outputlevel6|outputlevel5|outputlevel4|outputlevel3|outputlevel2|outputlevel16|outputlevel15|outputlevel14|outputlevel13|outputlevel12|outputlevel11|outputlevel10|outputlevel1|outputlevel|mainoutput)
         styles []    = .inputparameter;
      }
      : include "basics";
   }
  # ---------------------------- FLIPFLOP ----------------------------
  flipflop : context {

      : push {
         regex        \= (\[flipflop\])
         styles []       = .circuitheader;
         context []      = inside_flipflop;
      }   }   inside_flipflop : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (toggle|startvalue|set|reset|loadvalue|load|clear)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- FOLD ----------------------------
  fold : context {

      : push {
         regex        \= (\[fold\])
         styles []       = .circuitheader;
         context []      = inside_fold;
      }   }   inside_fold : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (minimum|maximum|input|foldby)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- FOURSTATEBUTTON ----------------------------
  fourstatebutton : context {

      : push {
         regex        \= (\[fourstatebutton\])
         styles []       = .circuitheader;
         context []      = inside_fourstatebutton;
      }   }   inside_fourstatebutton : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (value4|value3|value2|value1|value|startvalue|reset|button)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output|led)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- GATETOOL ----------------------------
  gatetool : context {

      : push {
         regex        \= (\[gatetool\])
         styles []       = .circuitheader;
         context []      = inside_gatetool;
      }   }   inside_gatetool : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (taptempo|mingatelength|maxgatelength|inputtrigger|inputgate|inputedge|gatestretch|gatelength)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (outputtrigger|outputgate|outputedge)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- IFEQUAL ----------------------------
  ifequal : context {

      : push {
         regex        \= (\[ifequal\])
         styles []       = .circuitheader;
         context []      = inside_ifequal;
      }   }   inside_ifequal : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (input2|input1|ifequal|else)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- LFO ----------------------------
  lfo : context {

      : push {
         regex        \= (\[lfo\])
         styles []       = .circuitheader;
         context []      = inside_lfo;
      }   }   inside_lfo : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (waveform|taptempo|syncphase|sync|skew|rate|randomize|pulsewidth|phase|offset|level|hz|bipolar)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (triangle|square|sine|sawtooth|ramp|paraboloid|output|cosine)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- LOGIC ----------------------------
  logic : context {

      : push {
         regex        \= (\[logic\])
         styles []       = .circuitheader;
         context []      = inside_logic;
      }   }   inside_logic : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (threshold|lowvalue|input8|input7|input6|input5|input4|input3|input2|input1|input|highvalue|countvalue)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (xor|or|nor|negated|nand|countlow|count|and)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- MATH ----------------------------
  math : context {

      : push {
         regex        \= (\[math\])
         styles []       = .circuitheader;
         context []      = inside_math;
      }   }   inside_math : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (input2|input1|input)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (sum|square|sine|round|root|reciprocal|quotient|product|power|negation|modulo|minimum|maximum|logarithm|log2|floor|difference|cosine|ceil|average|amount)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- MATRIXMIXER ----------------------------
  matrixmixer : context {

      : push {
         regex        \= (\[matrixmixer\])
         styles []       = .circuitheader;
         context []      = inside_matrixmixer;
      }   }   inside_matrixmixer : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (startvalue|selectat|select|savepreset|preset|mixmax|loadpreset|input4|input3|input2|input1|input|dontsave|clearall|clear|button44|button43|button42|button41|button4|button34|button33|button32|button31|button3|button24|button23|button22|button21|button2|button14|button13|button12|button11|button1|auxin4|auxin3|auxin2|auxin1|auxin)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output4|output3|output2|output1|output|led44|led43|led42|led41|led4|led34|led33|led32|led31|led3|led24|led23|led22|led21|led2|led14|led13|led12|led11|led1)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- MIDIFILEPLAYER ----------------------------
  midifileplayer : context {

      : push {
         regex        \= (\[midifileplayer\])
         styles []       = .circuitheader;
         context []      = inside_midifileplayer;
      }   }   inside_midifileplayer : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (voiceallocation|tuningpitch|tuningmode|transpose|track|speed|roundrobin|reset|pitchbendrange|notegap|note9|note8|note7|note6|note5|note4|note3|note2|note16|note15|note14|note13|note12|note11|note10|note1|note|lowestnote|loop|holdvelocity|highestnote|file|end|clock|channel|ccnumber4|ccnumber3|ccnumber2|ccnumber1|ccnumber|bendpitch)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (volume|velocity8|velocity7|velocity6|velocity5|velocity4|velocity3|velocity2|velocity1|velocity|trigger8|trigger7|trigger6|trigger5|trigger4|trigger3|trigger2|trigger1|trigger|soft|programchange|program|pressure8|pressure7|pressure6|pressure5|pressure4|pressure3|pressure2|pressure1|pressure|portamento|pitchbend|pitch8|pitch7|pitch6|pitch5|pitch4|pitch3|pitch2|pitch1|pitch|notegatevelocity9|notegatevelocity8|notegatevelocity7|notegatevelocity6|notegatevelocity5|notegatevelocity4|notegatevelocity3|notegatevelocity2|notegatevelocity16|notegatevelocity15|notegatevelocity14|notegatevelocity13|notegatevelocity12|notegatevelocity11|notegatevelocity10|notegatevelocity1|notegatevelocity|notegate9|notegate8|notegate7|notegate6|notegate5|notegate4|notegate3|notegate2|notegate16|notegate15|notegate14|notegate13|notegate12|notegate11|notegate10|notegate1|notegate|modwheel|midiclock|gate8|gate7|gate6|gate5|gate4|gate3|gate2|gate1|gate|error|endoftrack|clockout|cctrigger4|cctrigger3|cctrigger2|cctrigger1|cctrigger|cc4|cc3|cc2|cc1|cc|bank)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- MIDIIN ----------------------------
  midiin : context {

      : push {
         regex        \= (\[midiin\])
         styles []       = .circuitheader;
         context []      = inside_midiin;
      }   }   inside_midiin : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (voiceallocation|usb|tuningpitch|tuningmode|trs|transpose|systemreset|roundrobin|pitchbendrange|notegap|note9|note8|note7|note6|note5|note4|note3|note2|note16|note15|note14|note13|note12|note11|note10|note1|note|lowestnote|initialrunning|holdvelocity|highestnote|channel|ccnumber4|ccnumber3|ccnumber2|ccnumber1|ccnumber|bendpitch)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (volume|velocity8|velocity7|velocity6|velocity5|velocity4|velocity3|velocity2|velocity1|velocity|trigger8|trigger7|trigger6|trigger5|trigger4|trigger3|trigger2|trigger1|trigger|stop|start|soft|running|programchange|program|pressure8|pressure7|pressure6|pressure5|pressure4|pressure3|pressure2|pressure1|pressure|portamento|pitchbend|pitch8|pitch7|pitch6|pitch5|pitch4|pitch3|pitch2|pitch1|pitch|notegatevelocity9|notegatevelocity8|notegatevelocity7|notegatevelocity6|notegatevelocity5|notegatevelocity4|notegatevelocity3|notegatevelocity2|notegatevelocity16|notegatevelocity15|notegatevelocity14|notegatevelocity13|notegatevelocity12|notegatevelocity11|notegatevelocity10|notegatevelocity1|notegatevelocity|notegate9|notegate8|notegate7|notegate6|notegate5|notegate4|notegate3|notegate2|notegate16|notegate15|notegate14|notegate13|notegate12|notegate11|notegate10|notegate1|notegate|modwheel|midiclock|gate8|gate7|gate6|gate5|gate4|gate3|gate2|gate1|gate|continue|clock8t|clock8|clock4|clock16|clock|cctrigger4|cctrigger3|cctrigger2|cctrigger1|cctrigger|cc4|cc3|cc2|cc1|cc|bank|active)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- MIDIOUT ----------------------------
  midiout : context {

      : push {
         regex        \= (\[midiout\])
         styles []       = .circuitheader;
         context []      = inside_midiout;
      }   }   inside_midiout : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (volume|velocity8|velocity7|velocity6|velocity5|velocity4|velocity3|velocity2|velocity1|velocity|usb|updaterate|updateccs|trs|triggerdelay|systemreset|stop|start|sostenuto|soft|selectat|select|running|programchange|program|pressure8|pressure7|pressure6|pressure5|pressure4|pressure3|pressure2|pressure1|pressure|portamento|pitchtracking|pitchstabilization|pitchbendrange|pitchbend|pitch8|pitch7|pitch6|pitch5|pitch4|pitch3|pitch2|pitch1|pitch|noteoffvelocity8|noteoffvelocity7|noteoffvelocity6|noteoffvelocity5|noteoffvelocity4|noteoffvelocity3|noteoffvelocity2|noteoffvelocity1|noteoffvelocity|notegatevelocity9|notegatevelocity8|notegatevelocity7|notegatevelocity6|notegatevelocity5|notegatevelocity4|notegatevelocity3|notegatevelocity2|notegatevelocity16|notegatevelocity15|notegatevelocity14|notegatevelocity13|notegatevelocity12|notegatevelocity11|notegatevelocity10|notegatevelocity1|notegatevelocity|notegate9|notegate8|notegate7|notegate6|notegate5|notegate4|notegate3|notegate2|notegate16|notegate15|notegate14|notegate13|notegate12|notegate11|notegate10|notegate1|notegate|note9|note8|note7|note6|note5|note4|note3|note2|note16|note15|note14|note13|note12|note11|note10|note1|note|modwheel|midiclock|lowestnote|legato|highestnote|gate8|gate7|gate6|gate5|gate4|gate3|gate2|gate1|gate|delayinitialccs|damper|clock|channelpressure|channel|cctrigger8|cctrigger7|cctrigger6|cctrigger5|cctrigger4|cctrigger3|cctrigger2|cctrigger1|cctrigger|ccnumber8|ccnumber7|ccnumber6|ccnumber5|ccnumber4|ccnumber3|ccnumber2|ccnumber1|ccnumber|cc8|cc7|cc6|cc5|cc4|cc3|cc2|cc1|cc|bank|allsoundoff|allnotesoff|activesensing)
         styles []    = .inputparameter;
      }
      : include "basics";
   }
  # ---------------------------- MIDITHROUGH ----------------------------
  midithrough : context {

      : push {
         regex        \= (\[midithrough\])
         styles []       = .circuitheader;
         context []      = inside_midithrough;
      }   }   inside_midithrough : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (tousb|totrs|fromusb|fromtrs)
         styles []    = .inputparameter;
      }
      : include "basics";
   }
  # ---------------------------- MINIFONION ----------------------------
  minifonion : context {

      : push {
         regex        \= (\[minifonion\])
         styles []       = .circuitheader;
         context []      = inside_minifonion;
      }   }   inside_minifonion : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (tuningpitch|tuningmode|trigger|transpose|selectnoteshift|selectfill5|selectfill4|selectfill3|selectfill2|selectfill1|select9|select7|select5|select3|select13|select11|select1|root|noteshift|input|harmonicshift|direction|degree|bypass)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output|notechange)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- MIXER ----------------------------
  mixer : context {

      : push {
         regex        \= (\[mixer\])
         styles []       = .circuitheader;
         context []      = inside_mixer;
      }   }   inside_mixer : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (input8|input7|input6|input5|input4|input3|input2|input1|input)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output|minimum|maximum|average)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- MOTOQUENCER ----------------------------
  motoquencer : context {

      : push {
         regex        \= (\[motoquencer\])
         styles []       = .circuitheader;
         context []      = inside_motoquencer;
      }   }   inside_motoquencer : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (tuningpitch|tuningmode|transpose|taptempo|stepcopy|startstep|shiftsteps|setendstep|selectnoteshift|selectfill5|selectfill4|selectfill3|selectfill2|selectfill1|selectat|select9|select7|select5|select3|select13|select11|select1|select|savepreset|run|root|reset|repeatshift|recordsilence|recordmode|ratchetshift|quantize|preset|pingpong|pattern|pastefaders|pastebuttons|paste|page|numsteps|numfaders|noteshift|mute|metricsaver|luckyties|luckyspread|luckyskips|luckyshuffle|luckyscope|luckyreverse|luckyrepeats|luckyratchets|luckyrandomizecv|luckyinvert|luckygates|luckygateprob|luckygatepattern|luckyfaders|luckycvs|luckycvdrift|luckycvbase|luckychance|luckybuttons|luckyamount|loadpreset|linktonext|keyboardmode|keyboardgate|keyboardcv|invert|holdcv|harmonicshift|gatename|gatelength|form|firstfader|fadermode|endstep|doublerange|dontsave|display|direction|degree|defaultgate|defaultcv|cvrange|cvnotches|cvname|cvbase|copy|constantlength|composemode|clock|clearstartend|clearskips|clearrepeats|clearall|clear|buttonmode|buttoncolor|bulkedit|autoreset|accumulatorrange)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (startstepout|startofsequence|startofpart|gate|endstepout|cv|currentstep|currentpage|accumulator)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- MOTORFADER ----------------------------
  motorfader : context {

      : push {
         regex        \= (\[motorfader\])
         styles []       = .circuitheader;
         context []      = inside_motorfader;
      }   }   inside_motorfader : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (startvalue|sharewithnext|selectat|select|savepreset|preset|outputscale|outputoffset|notches|loadpreset|ledvalue|ledcolor|header|fader|dontsave|display|clearall|clear)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output|button)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- MULTICOMPARE ----------------------------
  multicompare : context {

      : push {
         regex        \= (\[multicompare\])
         styles []       = .circuitheader;
         context []      = inside_multicompare;
      }   }   inside_multicompare : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (input|ifequal9|ifequal8|ifequal7|ifequal6|ifequal5|ifequal4|ifequal3|ifequal2|ifequal16|ifequal15|ifequal14|ifequal13|ifequal12|ifequal11|ifequal10|ifequal1|ifequal|else|compare9|compare8|compare7|compare6|compare5|compare4|compare3|compare2|compare16|compare15|compare14|compare13|compare12|compare11|compare10|compare1|compare)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- NOTCHEDPOT ----------------------------
  notchedpot : context {

      : push {
         regex        \= (\[notchedpot\])
         styles []       = .circuitheader;
         context []      = inside_notchedpot;
      }   }   inside_notchedpot : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (pot|notch)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (righthalfinv|righthalf|output|lefthalfinv|lefthalf|bipolar|absbipolar)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- NOTEBUTTONS ----------------------------
  notebuttons : context {

      : push {
         regex        \= (\[notebuttons\])
         styles []       = .circuitheader;
         context []      = inside_notebuttons;
      }   }   inside_notebuttons : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (startnote|selectat|select|savepreset|preset|loadpreset|header|dontsave|display|clock|clearall|clear|button9|button8|button7|button6|button5|button4|button3|button2|button12|button11|button10|button1|button)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (semitone|output|led9|led8|led7|led6|led5|led4|led3|led2|led12|led11|led10|led1|led|gate)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- NUDGE ----------------------------
  nudge : context {

      : push {
         regex        \= (\[nudge\])
         styles []       = .circuitheader;
         context []      = inside_nudge;
      }   }   inside_nudge : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (wrap|startvalue|selectat|select|savepreset|preset|offset|minimum|maximum|loadpreset|header|dontsave|display|clearall|clear|buttonup|buttondown|amount)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output|ledup|leddown|changed)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- OCTAVE ----------------------------
  octave : context {

      : push {
         regex        \= (\[octave\])
         styles []       = .circuitheader;
         context []      = inside_octave;
      }   }   inside_octave : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (spread|input|fifths|detune)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output3|output2|output1|output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- ONCE ----------------------------
  once : context {

      : push {
         regex        \= (\[once\])
         styles []       = .circuitheader;
         context []      = inside_once;
      }   }   inside_once : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (onlycoldstart|delay)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (trigger)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- OUTPUTCALIBRATOR ----------------------------
  outputcalibrator : context {

      : push {
         regex        \= (\[outputcalibrator\])
         styles []       = .circuitheader;
         context []      = inside_outputcalibrator;
      }   }   inside_outputcalibrator : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (save|referencepoint|output|nudgeup|nudgedown|loaddefaults|header|display|cancel)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (uncalibrated|dirty|calibration)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- POLYTOOL ----------------------------
  polytool : context {

      : push {
         regex        \= (\[polytool\])
         styles []       = .circuitheader;
         context []      = inside_polytool;
      }   }   inside_polytool : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (voiceallocation|roundrobin|pitchinput9|pitchinput8|pitchinput7|pitchinput6|pitchinput5|pitchinput4|pitchinput3|pitchinput2|pitchinput16|pitchinput15|pitchinput14|pitchinput13|pitchinput12|pitchinput11|pitchinput10|pitchinput1|pitchinput|gateinput9|gateinput8|gateinput7|gateinput6|gateinput5|gateinput4|gateinput3|gateinput2|gateinput16|gateinput15|gateinput14|gateinput13|gateinput12|gateinput11|gateinput10|gateinput1|gateinput)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (pitchoutput9|pitchoutput8|pitchoutput7|pitchoutput6|pitchoutput5|pitchoutput4|pitchoutput3|pitchoutput2|pitchoutput16|pitchoutput15|pitchoutput14|pitchoutput13|pitchoutput12|pitchoutput11|pitchoutput10|pitchoutput1|pitchoutput|gateoutput9|gateoutput8|gateoutput7|gateoutput6|gateoutput5|gateoutput4|gateoutput3|gateoutput2|gateoutput16|gateoutput15|gateoutput14|gateoutput13|gateoutput12|gateoutput11|gateoutput10|gateoutput1|gateoutput)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- POT ----------------------------
  pot : context {

      : push {
         regex        \= (\[pot\])
         styles []       = .circuitheader;
         context []      = inside_pot;
      }   }   inside_pot : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (startvalue|slope|selectat|select|savepreset|preset|pot|outputscale|outputoffset|notch|loadpreset|ledgauge|header|dontsave|display|discrete|clearall|clear)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (righthalfinv|righthalf|output|onchange|lefthalfinv|lefthalf|bipolar|absbipolar)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- QUANTIZER ----------------------------
  quantizer : context {

      : push {
         regex        \= (\[quantizer\])
         styles []       = .circuitheader;
         context []      = inside_quantizer;
      }   }   inside_quantizer : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (trigger|steps|input|histeresis|direction|bypass)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output|changed)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- QUEUE ----------------------------
  queue : context {

      : push {
         regex        \= (\[queue\])
         styles []       = .circuitheader;
         context []      = inside_queue;
      }   }   inside_queue : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (outputpos8|outputpos7|outputpos6|outputpos5|outputpos4|outputpos3|outputpos2|outputpos1|outputpos|input|clock)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output8|output7|output6|output5|output4|output3|output2|output1|output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- RANDOM ----------------------------
  random : context {

      : push {
         regex        \= (\[random\])
         styles []       = .circuitheader;
         context []      = inside_random;
      }   }   inside_random : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (steps|minimum|maximum|clock)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- RECORDER ----------------------------
  recorder : context {

      : push {
         regex        \= (\[recorder\])
         styles []       = .circuitheader;
         context []      = inside_recorder;
      }   }   inside_recorder : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (trimstart|trimend|timewindow|stopbutton|selectat|select|scrubposition|scrub|save|sample|recordbutton|playbutton|playbackspeed|pause|numberin|mode|loop|load|header|gatein8|gatein7|gatein6|gatein5|gatein4|gatein3|gatein2|gatein1|gatein|filenumber|display|cvin|clock|bypass)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (stopled|recordled|playled|overflow|numberout|gateout8|gateout7|gateout6|gateout5|gateout4|gateout3|gateout2|gateout1|gateout|cvout)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- SAMPLE ----------------------------
  sample : context {

      : push {
         regex        \= (\[sample\])
         styles []       = .circuitheader;
         context []      = inside_sample;
      }   }   inside_sample : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (timewindow|sample|input|gate|bypass)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- SELECT ----------------------------
  select : context {

      : push {
         regex        \= (\[select\])
         styles []       = .circuitheader;
         context []      = inside_select;
      }   }   inside_select : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (selectat|select|input)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- SEQUENCER ----------------------------
  sequencer : context {

      : push {
         regex        \= (\[sequencer\])
         styles []       = .circuitheader;
         context []      = inside_sequencer;
      }   }   inside_sequencer : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (transpose|steps|stages|slew8|slew7|slew6|slew5|slew4|slew3|slew2|slew1|slew|reset|repeat8|repeat7|repeat6|repeat5|repeat4|repeat3|repeat2|repeat1|repeat|pitch8|pitch7|pitch6|pitch5|pitch4|pitch3|pitch2|pitch1|pitch|outputscaling|gatelength|gate8|gate7|gate6|gate5|gate4|gate3|gate2|gate1|gate|cv8|cv7|cv6|cv5|cv4|cv3|cv2|cv1|cv|clock|chaintonext)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (pitchoutput|gateoutput|cvoutput)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- SINFONIONLINK ----------------------------
  sinfonionlink : context {

      : push {
         regex        \= (\[sinfonionlink\])
         styles []       = .circuitheader;
         context []      = inside_sinfonionlink;
      }   }   inside_sinfonionlink : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (transpose|step|root|reset|linkstate|harmonicshift|degree|clock|chaoticdetune|beat)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- SLEW ----------------------------
  slew : context {

      : push {
         regex        \= (\[slew\])
         styles []       = .circuitheader;
         context []      = inside_slew;
      }   }   inside_slew : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (slewup|slewdown|slew|input|gate)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (scurve|linear|exponential)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- SPRING ----------------------------
  spring : context {

      : push {
         regex        \= (\[spring\])
         styles []       = .circuitheader;
         context []      = inside_spring;
      }   }   inside_spring : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (startvelocity|startposition|springforce|speed|shoveforce|shove|reset|mass|gravity|friction|flowresistance)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (velocity|position)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- SUPERJUST ----------------------------
  superjust : context {

      : push {
         regex        \= (\[superjust\])
         styles []       = .circuitheader;
         context []      = inside_superjust;
      }   }   inside_superjust : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (tuningpitch|tuningmode|transpose|input8|input7|input6|input5|input4|input3|input2|input1|input|bypass)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output8|output7|output6|output5|output4|output3|output2|output1|output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- SWITCH ----------------------------
  switch : context {

      : push {
         regex        \= (\[switch\])
         styles []       = .circuitheader;
         context []      = inside_switch;
      }   }   inside_switch : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (sort|shuffle|reset|offset|input9|input8|input7|input6|input5|input4|input3|input2|input16|input15|input14|input13|input12|input11|input10|input1|input|forward|backward)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output9|output8|output7|output6|output5|output4|output3|output2|output16|output15|output14|output13|output12|output11|output10|output1|output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- SWITCHEDPOT ----------------------------
  switchedpot : context {

      : push {
         regex        \= (\[switchedpot\])
         styles []       = .circuitheader;
         context []      = inside_switchedpot;
      }   }   inside_switchedpot : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (switch8|switch7|switch6|switch5|switch4|switch3|switch2|switch1|switch|pot|bipolar)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output8|output7|output6|output5|output4|output3|output2|output1|output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- TIMING ----------------------------
  timing : context {

      : push {
         regex        \= (\[timing\])
         styles []       = .circuitheader;
         context []      = inside_timing;
      }   }   inside_timing : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (timing8|timing7|timing6|timing5|timing4|timing3|timing2|timing1|timing|reset|clock)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- TOGGLEBUTTON ----------------------------
  togglebutton : context {

      : push {
         regex        \= (\[togglebutton\])
         styles []       = .circuitheader;
         context []      = inside_togglebutton;
      }   }   inside_togglebutton : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (startvalue|reset|onvalue|offvalue|doubleclickmode|button)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (output|negated|led|inverted)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- TRANSIENT ----------------------------
  transient : context {

      : push {
         regex        \= (\[transient\])
         styles []       = .circuitheader;
         context []      = inside_transient;
      }   }   inside_transient : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (start|reset|pingpong|loop|freeze|end|duration|clock)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (phase|output|endoftransient)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- TRIGGERDELAY ----------------------------
  triggerdelay : context {

      : push {
         regex        \= (\[triggerdelay\])
         styles []       = .circuitheader;
         context []      = inside_triggerdelay;
      }   }   inside_triggerdelay : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (repeats|mute|input|gatelength|delay|clock)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (overflow|output)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- UNUSEDFADERS ----------------------------
  unusedfaders : context {

      : push {
         regex        \= (\[unusedfaders\])
         styles []       = .circuitheader;
         context []      = inside_unusedfaders;
      }   }   inside_unusedfaders : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (selectat|select|numfaders|firstfader)
         styles []    = .inputparameter;
      }
      : include "basics";
   }
  # ---------------------------- VCOTUNER ----------------------------
  vcotuner : context {

      : push {
         regex        \= (\[vcotuner\])
         styles []       = .circuitheader;
         context []      = inside_vcotuner;
      }   }   inside_vcotuner : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (tuningnote|smooth|selectat|select|precision|header|display|concertpitch|basepitch)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (vcofound|tuning|referencepitch|pitch|ledsharp|ledintune|ledflat|intune|hz|cents)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
  # ---------------------------- WATCH ----------------------------
  watch : context {

      : push {
         regex        \= (\[watch\])
         styles []       = .circuitheader;
         context []      = inside_watch;
      }   }   inside_watch : context {
      : pop {
         regex       \= (?=\[)
         styles []    = .circuitheader;
      }
      :pattern {
         regex       \= (threshold|taptempo|stepsize|response|input|histeresis|edgesize)
         styles []    = .inputparameter;
      }
      :pattern {
         regex       \= (stepup|stepdown|step|slope|movingup|movingdown|moving|edgeup|edgedown|edge|changedup|changeddown|changed)
         styles []    = .outputparameter;
      }
      : include "basics";
   }
}
