                             (fn[m]
                               { (keywordize (zip-xml/attr m :name))
                                 (zip-xml/xml1-> m :description zip-xml/text)
-                              }))))
-           nil)]
+                              })))))]
    {:descriptions all-descriptions
     :enum-to-value enum-to-value
     :enums-by-group enums-by-group

                                                   (map #(let [{:keys [fld-name type-key length]} %]
                                                           (str (if (= type-key :uint8_t_mavlink_version)
                                                                  "uint8_t"
                                                                  (name type-key))  " "
                                                                fld-name " "
                                                                (when length
                                                                  (char length))))

                      ext-encode-fns (mapv gen-encode-fn ext-fields)
                      ext-decode-fns (mapv #(gen-decode-fn % enums-by-group) ext-fields)
                      ]
                  {(keywordize msg-name)
                   {:msg-id msg-id
                    :msg-key (keywordize msg-name)
                    :payload-size payload-size
                    :extension-payload-size (+ payload-size payload-size-ext)
                    :fields fields
                    :encode-fns encode-fns
                    :decode-fns decode-fns
                    :extension-fields ext-fields
                    :extension-encode-fns ext-encode-fns
                    :extension-decode-fns ext-decode-fns
                    :crc-seed crc-seed
                    }
                  }))))
       all-descriptions
         (when descriptions
           (apply
             merge
             (concat
