anchor.diff:     `(
        :extra (xml-loader :source-file ,(source-path "extra.xml"))
        :municipality (municipality-csv :source-file ,(source-path "jichitai.csv"))
  -     ;; (wards-csv :source-file ,(source-path "gyoseiku.csv"))
  +     :ward (ward-csv :source-file ,(source-path "gyoseiku.csv"))
        )))
   
   (defun load-custom-data (&optional keys silent-p)
  
positive.code:                               (subseq reading 0 (- (length reading) (length tpr)))))))
          (cons short-text short-reading))))
  
  (defun romanize-municipality (text reading)
    (let ((short-reading (cdr (municipality-short text reading)))
          (type (char text (1- (length text)))))
      (format nil "~a~@[ ~a~]"
              (ichiran:romanize-word-geo short-reading)
              (cdr (assoc type *municipality-types-description*)))))
  
  (defstruct municipality text reading definition type prefecture)
  
  
negative.code:   (query (:update 'gloss :set 'text (municipality-definition entry)
                    :from 'sense :where (:and (:= 'gloss.sense-id 'sense.id) (:= 'sense.seq seq) (:= 'gloss.text gloss)))))
  
  (defclass ward-csv (csv-loader)
    ((description :initform "wards")))
  
  (defstruct ward text reading definition city)
  
  (defmethod slurp ((loader ward-csv))
    (setf (entries loader)
          (loop
             with city-text and city-reading and city-romanized
             for (id text reading) in (apply 'cl-csv:read-csv (source-file loader) (csv-options loader))
             if (alexandria:ends-with #\区 text)
             collect
               (let* ((ward-text (subseq text (length city-text)))
                      (ward-reading (subseq reading (length city-reading)))
                      (definition (format nil "~a, ~a" (romanize-municipality ward-text ward-reading) city-romanized)))
                 (make-ward :text ward-text :reading ward-reading :definition definition :city city-romanized))
             else do (setf city-text text
                           city-reading reading
                           city-romanized (romanize-municipality text reading :include-type nil)))))
  
  (defmethod get-words ((entry ward))
    (let ((name (car (split-sequence #\Space (ward-definition entry)))))
      (list name "Ward" (ward-city entry))))
  
  (defmethod test-entry (loader (entry ward))
    (multiple-value-bind (seq match-p)
        (let ((words (get-words entry)))
          (ichiran/dict:match-glosses
           (ward-text entry)
           (ward-reading entry)
           words
           :normalize 'normalize-geo))
      (cond ((not seq) (values t nil))
            (match-p (values nil seq))
            (t (values t seq)))))
  
  (defmethod as-xml ((entry ward))
    (as-xml-simple (ward-text entry) (ward-reading entry) (ward-definition entry)))
  
  (defmethod insert-entry ((loader ward-csv) entry seq)
    (unless *silent-p*
      (format t "Inserting ~a[~a] ~a (seq=~a)~%" (ward-text entry) (ward-reading entry) (ward-definition entry) seq))
    (ichiran/dict::load-entry (as-xml entry) :seq seq))
  
  (defmethod update-entry ((loader ward-csv) entry seq)
    (unless *silent-p*
      (format t "Updating ~a[~a] ~a (seq=~a)~%" (ward-text entry) (ward-reading entry) (ward-definition entry) seq))
    (ichiran/dict::add-new-sense seq '("n") (list (ward-definition entry))))
  
  (defun source-path (file)
    (asdf:system-relative-pathname :ichiran (format nil "data/sources/~a" file)))
  