                       :length (Math/abs (* 4.0 length ppq))
                       :notes (rest notes)})
         (symbol? length)
-        (if-let [m (re-matches #"(-|)((?:[dwhqistxofjk]\.*)+)" (name length))]
-          (let [length-map {"d" 2 "w" 1 "h" 1/2 "q" 1/4 "i" 1/8 "s" 1/16 "t" 1/32
-                            "x" 1/64 "o" 1/128 "f" 1/256 "j" 1/512 "k" 1/1024}]
+        (if-let [m (re-matches #"(-|)((?:[xwhqistjlmno]\.*)+)" (name length))]
+          (let [length-map {"x" 2 "w" 1 "h" 1/2 "q" 1/4 "i" 1/8 "s" 1/16 "t" 1/32
+                            "j" 1/64 "l" 1/128 "m" 1/256 "n" 1/512 "o" 1/1024}]
             (merge state {:key (if (= "-" (get m 1)) nil (:key state))
                           :length (reduce +
                                           (map #(* 4.0
                                                    (get length-map (get % 1))
                                                    (- 2.0 (/ 1.0 (reduce * (repeat (count (get % 2)) 2))))
                                                    ppq)
-                                               (re-seq #"\G([dwhqistxofjk])(\.*)" (get m 2))))
+                                               (re-seq #"\G([xwhqistjlmno])(\.*)" (get m 2))))
                           :notes (rest notes)}))
           (if-let [m (re-matches #"([-=])[-=]*" (name length))]
             (merge state {:length (* (:length state) (count (name length)))

    (if (map? (first notes))
      (do
        (when (contains? (first notes) :tempo)
          (let [track (get (.getTracks (.getSequence (:sequencer state))) (:track state))]
            (.add (:track state)
                  (MidiEvent.
                   (MetaMessage. 0x51
                                 (.array (.putInt (ByteBuffer/allocate 3) (int (* (/ 1 (get (first notes) :tempo)) 60 1e6)))) 3)
                   (:position state))))
          (merge state (first notes) {:notes (rest notes)})))
      state)))

;; TODO: displacement syntax < >
(defn parse-length [notes state]
  (if (empty? notes)
    state

                             {:notes (rest notes)}
                             (if (vector? notes) {:position position} {}))
                      (map? (first notes))
                      (parse-state notes state)
                      (keyword? (first notes))
                      (parse-state (cons {(first notes) (first (rest notes))} (rest (rest notes))) state)
                      :else
                      (let [notes (:notes state)
                            state (parse-param (:notes state) state)
                            state (parse-length (:notes state) state)
                            state (parse-note (:notes state) state)
                            value (get {ShortMessage/NOTE_ON (:attack state)
                                        ShortMessage/CHANNEL_PRESSURE (:channel-pressure state)
                                        ShortMessage/CONTROL_CHANGE (:cc-change state)
                                        ShortMessage/PITCH_BEND (:pitch-bend state)
                                        ShortMessage/POLY_PRESSURE (:key-pressure state)}
                                       (:key-type state) 0)
                            track (aget (.getTracks (.getSequence (:sequencer state))) (:track state))]
                        (when (= (count notes) (count (:notes state)))
                          (throw (Exception. (format "Couldn't parse note: %s" (str (first notes))))))
                        (cond
