(PROCLAIM '(OPTIMIZE SPEED))
(DEFPACKAGE "BOOTTRAN")

(EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
  (PROGN
   (COND
    ((|%hasFeature| :COMMON-LISP)
     (USE-PACKAGE "COMMON-LISP" . #1=(#2="BOOTTRAN")))
    (T (USE-PACKAGE "LISP" . #1#)))
   (USE-PACKAGE "AxiomCore" #2#)))

(IN-PACKAGE "BOOTTRAN")

(PROVIDE "utility")

(EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
  (EXPORT
   '(|objectMember?| |symbolMember?| |stringMember?| |charMember?|
                     |scalarMember?| |listMember?| |reverse| |reverse!|
                     |lastNode| |append| |append!| |copyList| |substitute|
                     |substitute!| |listMap| |listMap!| |butLast| |butLast!|
                     |last| |setDifference| |setUnion| |setIntersection|
                     |symbolAssoc| |applySubst| |applySubst!| |applySubstNQ|
                     |objectAssoc| |invertSubst| |substTarget| |substSource|
                     |remove| |removeSymbol| |atomic?| |every?| |any?| |take|
                     |takeWhile| |drop| |copyTree| |finishLine| |stringPrefix?|
                     |stringSuffix?| |findChar| |charPosition|)))

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Thing| |%Thing|) |%Thing|) |substitute|))

(DECLAIM (FTYPE (FUNCTION (|%Thing| |%Thing| |%Thing|) |%Thing|) |substitute!|))

(DECLAIM
 (FTYPE (FUNCTION ((|%List| |%Thing|) (|%List| |%Thing|)) (|%List| |%Thing|))
  |append|))

(DECLAIM
 (FTYPE (FUNCTION ((|%List| |%Thing|) (|%List| |%Thing|)) (|%List| |%Thing|))
  |append!|))

(DECLAIM (FTYPE (FUNCTION ((|%List| |%Thing|)) (|%List| |%Thing|)) |copyList|))

(DECLAIM
 (FTYPE (FUNCTION ((|%List| |%Thing|)) (|%Maybe| (|%Node| |%Thing|)))
  |lastNode|))

(DECLAIM (FTYPE (FUNCTION ((|%List| |%Thing|)) |%Thing|) |last|))

(DECLAIM (FTYPE (FUNCTION ((|%List| |%Thing|)) (|%List| |%Thing|)) |butLast|))

(DECLAIM (FTYPE (FUNCTION ((|%List| |%Thing|)) (|%List| |%Thing|)) |butLast!|))

(DECLAIM
 (FTYPE (FUNCTION ((|%List| |%Thing|) |%Symbol|) (|%List| |%Thing|))
  |removeSymbol|))

(DECLAIM
 (FTYPE (FUNCTION ((|%List| |%Thing|) |%Thing|) (|%List| |%Thing|)) |remove|))

(DECLAIM
 (FTYPE
  (FUNCTION (|%Thing| (|%List| |%Thing|))
   (|%Maybe| (|%Pair| |%Thing| |%Thing|)))
  |objectAssoc|))

(DECLAIM
 (FTYPE
  (FUNCTION (|%Symbol| (|%List| |%Thing|))
   (|%Maybe| (|%Pair| |%Symbol| |%Thing|)))
  |symbolAssoc|))

(DECLAIM
 (FTYPE (FUNCTION ((|%List| |%Thing|) (|%List| |%Thing|)) (|%List| |%Thing|))
  |setDifference|))

(DECLAIM
 (FTYPE (FUNCTION ((|%List| |%Thing|) (|%List| |%Thing|)) (|%List| |%Thing|))
  |setUnion|))

(DECLAIM
 (FTYPE (FUNCTION ((|%List| |%Thing|) (|%List| |%Thing|)) (|%List| |%Thing|))
  |setIntersection|))

(DECLAIM (FTYPE (FUNCTION (|%Thing|) |%Boolean|) |atomic?|))

(DECLAIM
 (FTYPE (FUNCTION ((FUNCTION (|%Thing|) |%Thing|) (|%List| |%Thing|)) |%Thing|)
  |every?|))

(DECLAIM
 (FTYPE (FUNCTION ((FUNCTION (|%Thing|) |%Thing|) (|%List| |%Thing|)) |%Thing|)
  |any?|))

(DECLAIM
 (FTYPE (FUNCTION (|%Short| (|%List| |%Thing|)) (|%List| |%Thing|)) |take|))

(DECLAIM
 (FTYPE
  (FUNCTION ((FUNCTION (|%Thing|) |%Thing|) (|%List| |%Thing|))
   (|%List| |%Thing|))
  |takeWhile|))

(DECLAIM
 (FTYPE (FUNCTION (|%Short| (|%List| |%Thing|)) (|%List| |%Thing|)) |drop|))

(DECLAIM (FTYPE (FUNCTION (|%Thing|) |%Thing|) |copyTree|))

(DECLAIM (FTYPE (FUNCTION (|%Thing|) |%Void|) |finishLine|))

(DECLAIM
 (FTYPE (FUNCTION (|%String| |%Short|) (|%Maybe| |%Short|))
  |firstBlankPosition|))

(DECLAIM
 (FTYPE (FUNCTION (|%String| |%String|) (|%Maybe| |%Short|)) |stringSuffix?|))

(DECLAIM
 (FTYPE (FUNCTION (|%String| |%String|) (|%Maybe| |%Short|)) |stringPrefix?|))

(|%defaultReadAndLoadSettings|)

(DEFUN |atomic?| (|x|) (OR (NOT (CONSP |x|)) (EQ (CAR |x|) 'QUOTE)))

(DEFUN |every?| (|f| |l|)
  (LET ((|bfVar#2| T) (|bfVar#1| |l|) (|x| NIL))
    (LOOP
     (COND
      ((OR (NOT (CONSP |bfVar#1|)) (PROGN (SETQ |x| (CAR |bfVar#1|)) NIL))
       (RETURN |bfVar#2|))
      (T (SETQ |bfVar#2| (FUNCALL |f| |x|))
       (COND ((NOT |bfVar#2|) (RETURN NIL)))))
     (SETQ |bfVar#1| (CDR |bfVar#1|)))))

(DEFUN |any?| (|f| |l|)
  (LET ((|bfVar#2| NIL) (|bfVar#1| |l|) (|x| NIL))
    (LOOP
     (COND
      ((OR (NOT (CONSP |bfVar#1|)) (PROGN (SETQ |x| (CAR |bfVar#1|)) NIL))
       (RETURN |bfVar#2|))
      (T (SETQ |bfVar#2| (FUNCALL |f| |x|))
       (COND (|bfVar#2| (RETURN |bfVar#2|)))))
     (SETQ |bfVar#1| (CDR |bfVar#1|)))))

(DEFUN |take| (|n| |l|)
  (COND
   ((NOT (MINUSP |n|))
    (LET ((|bfVar#3| NIL)
          (|bfVar#4| NIL)
          (|bfVar#1| |l|)
          (|x| NIL)
          (|bfVar#2| 1))
      (LOOP
       (COND
        ((OR (NOT (CONSP |bfVar#1|)) (PROGN (SETQ |x| (CAR |bfVar#1|)) NIL)
             (> |bfVar#2| |n|))
         (RETURN |bfVar#3|))
        ((NULL |bfVar#3|) (SETQ |bfVar#3| #1=(CONS |x| NIL))
         (SETQ |bfVar#4| |bfVar#3|))
        (T (RPLACD |bfVar#4| #1#) (SETQ |bfVar#4| (CDR |bfVar#4|))))
       (SETQ |bfVar#1| (CDR |bfVar#1|))
       (SETQ |bfVar#2| (+ |bfVar#2| 1)))))
   (T (|drop| (+ (LENGTH |l|) |n|) |l|))))

(DEFUN |takeWhile| (|f| |l|)
  (LET ((|bfVar#2| NIL) (|bfVar#3| NIL) (|bfVar#1| |l|) (|x| NIL))
    (LOOP
     (COND
      ((OR (NOT (CONSP |bfVar#1|)) (PROGN (SETQ |x| (CAR |bfVar#1|)) NIL)
           (NOT (FUNCALL |f| |x|)))
       (RETURN |bfVar#2|))
      ((NULL |bfVar#2|) (SETQ |bfVar#2| #1=(CONS |x| NIL))
       (SETQ |bfVar#3| |bfVar#2|))
      (T (RPLACD |bfVar#3| #1#) (SETQ |bfVar#3| (CDR |bfVar#3|))))
     (SETQ |bfVar#1| (CDR |bfVar#1|)))))

(DEFUN |drop| (|n| |l|)
  (COND
   ((NOT (MINUSP |n|))
    (LET ((|bfVar#1| 1))
      (LOOP
       (COND
        ((OR (> |bfVar#1| |n|)
             (NOT (AND (CONSP |l|) (PROGN (SETQ |l| (CDR |l|)) T))))
         (RETURN NIL))
        (T NIL))
       (SETQ |bfVar#1| (+ |bfVar#1| 1))))
    (THE (|%List| |%Thing|) |l|))
   (T (|take| (+ (LENGTH |l|) |n|) |l|))))

(DEFUN |copyTree| (|t|)
  (COND ((CONSP |t|) (CONS (|copyTree| (CAR |t|)) (|copyTree| (CDR |t|))))
        (T |t|)))

(DEFUN |objectMember?| (|x| |l|)
  (LOOP
   (COND ((NULL |l|) (RETURN NIL))
         ((CONSP |l|)
          (COND ((EQ |x| (CAR |l|)) (RETURN T)) (T (SETQ |l| (CDR |l|)))))
         (T (RETURN (EQ |x| |l|))))))

(DEFUN |symbolMember?| (|s| |l|)
  (LOOP
   (COND ((NULL |l|) (RETURN NIL))
         ((CONSP |l|)
          (COND ((EQ |s| (CAR |l|)) (RETURN T)) (T (SETQ |l| (CDR |l|)))))
         (T (RETURN (EQ |s| |l|))))))

(DEFUN |stringMember?| (|s| |l|)
  (LOOP
   (COND ((NULL |l|) (RETURN NIL))
         ((CONSP |l|)
          (COND ((STRING= |s| (CAR |l|)) (RETURN T)) (T (SETQ |l| (CDR |l|)))))
         (T (RETURN (STRING= |s| |l|))))))

(DEFUN |charMember?| (|c| |l|)
  (LOOP
   (COND ((NULL |l|) (RETURN NIL))
         ((CONSP |l|)
          (COND ((CHAR= |c| (CAR |l|)) (RETURN T)) (T (SETQ |l| (CDR |l|)))))
         (T (RETURN (CHAR= |c| |l|))))))

(DEFUN |scalarMember?| (|s| |l|)
  (LOOP
   (COND ((NULL |l|) (RETURN NIL))
         ((CONSP |l|)
          (COND ((EQL |s| (CAR |l|)) (RETURN T)) (T (SETQ |l| (CDR |l|)))))
         (T (RETURN (EQL |s| |l|))))))

(DEFUN |listMember?| (|x| |l|)
  (LOOP
   (COND ((NULL |l|) (RETURN NIL))
         ((CONSP |l|)
          (COND ((EQUAL |x| (CAR |l|)) (RETURN T)) (T (SETQ |l| (CDR |l|)))))
         (T (RETURN (EQUAL |x| |l|))))))

(DEFUN |reverse| (|l|)
  (LET* (|r|)
    (PROGN
     (SETQ |r| NIL)
     (LOOP
      (COND ((CONSP |l|) (SETQ |r| (CONS (CAR |l|) |r|)) (SETQ |l| (CDR |l|)))
            (T (RETURN |r|)))))))

(DEFUN |reverse!| (|l|)
  (LET* (|l2| |l1|)
    (PROGN
     (SETQ |l1| NIL)
     (LOOP
      (COND
       ((CONSP |l|) (SETQ |l2| (CDR |l|)) (RPLACD |l| |l1|) (SETQ |l1| |l|)
        (SETQ |l| |l2|))
       (T (RETURN |l1|)))))))

(DEFUN |lastNode| (|l|)
  (LET* (|l'|)
    (PROGN
     (LOOP
      (COND
       ((NOT (AND (CONSP |l|) (PROGN (SETQ |l'| (CDR |l|)) T) (CONSP |l'|)))
        (RETURN NIL))
       (T (SETQ |l| |l'|))))
     |l|)))

(DEFUN |last| (|l|) (CAR (|lastNode| |l|)))

(DEFUN |butLast| (|l|)
  (LET* (|xs| |LETTMP#1|)
    (COND ((NOT (CONSP |l|)) NIL)
          (T (SETQ |LETTMP#1| (|reverse| |l|))
           (SETQ |xs| (|reverse!| (CDR |LETTMP#1|))) |xs|))))

(DEFUN |butLast!| (|l|)
  (LET* (|ISTMP#1|)
    (COND ((OR (NOT (CONSP |l|)) (NULL (CDR |l|))) NIL)
          (T
           (LET ((|xs| |l|))
             (LOOP
              (COND ((NOT (CONSP |xs|)) (RETURN NIL))
                    ((AND (CONSP |xs|)
                          (PROGN
                           (SETQ |ISTMP#1| (CDR |xs|))
                           (AND (CONSP |ISTMP#1|) (NULL (CDR |ISTMP#1|)))))
                     (IDENTITY (RETURN (RPLACD |xs| NIL)))))
              (SETQ |xs| (CDR |xs|))))
           |l|))))

(DEFUN |copyList| (|l|)
  (LET* (|l'| |t|)
    (COND ((NOT (CONSP |l|)) |l|)
          (T (SETQ |l'| (SETQ |t| (LIST (CAR |l|))))
           (LOOP
            (PROGN
             (SETQ |l| (CDR |l|))
             (COND
              ((CONSP |l|) (RPLACD |t| (LIST (CAR |l|))) (SETQ |t| (CDR |t|)))
              (T (RPLACD |t| |l|) (RETURN |l'|)))))))))

(DEFUN |append!| (|x| |y|)
  (COND ((NULL |x|) |y|) ((NULL |y|) |x|)
        (T (RPLACD (|lastNode| |x|) |y|) |x|)))

(DEFUN |append| (|x| |y|) (|append!| (|copyList| |x|) |y|))

(DEFUN |listMap| (|l| |fun|)
  (LET ((|bfVar#2| NIL) (|bfVar#3| NIL) (|bfVar#1| |l|) (|x| NIL))
    (LOOP
     (COND
      ((OR (NOT (CONSP |bfVar#1|)) (PROGN (SETQ |x| (CAR |bfVar#1|)) NIL))
       (RETURN |bfVar#2|))
      ((NULL |bfVar#2|) (SETQ |bfVar#2| #1=(CONS (FUNCALL |fun| |x|) NIL))
       (SETQ |bfVar#3| |bfVar#2|))
      (T (RPLACD |bfVar#3| #1#) (SETQ |bfVar#3| (CDR |bfVar#3|))))
     (SETQ |bfVar#1| (CDR |bfVar#1|)))))

(DEFUN |listMap!| (|l| |fun|)
  (PROGN
   (LET ((|xs| |l|))
     (LOOP
      (COND ((NOT (CONSP |xs|)) (RETURN NIL))
            (T (RPLACA |xs| (FUNCALL |fun| (CAR |xs|)))))
      (SETQ |xs| (CDR |xs|))))
   |l|))

(DEFUN |symbolAssoc| (|s| |l|)
  (LET* (|x|)
    (LOOP
     (COND
      ((NOT
        (AND (CONSP |l|) (PROGN (SETQ |x| (CAR |l|)) (SETQ |l| (CDR |l|)) T)))
       (RETURN NIL))
      ((AND (CONSP |x|) (EQ |s| (CAR |x|))) (RETURN |x|))))))

(DEFUN |objectAssoc| (|x| |l|)
  (LET* (|p|)
    (LOOP
     (COND
      ((NOT
        (AND (CONSP |l|) (PROGN (SETQ |p| (CAR |l|)) (SETQ |l| (CDR |l|)) T)))
       (RETURN NIL))
      ((AND (CONSP |p|) (EQ |x| (CAR |p|))) (RETURN |p|))))))

(DEFUN |substitute!| (|y| |x| |s|)
  (COND ((NULL |s|) NIL) ((EQ |x| |s|) |y|)
        (T
         (COND
          ((CONSP |s|) (RPLACA |s| (|substitute!| |y| |x| (CAR |s|)))
           (RPLACD |s| (|substitute!| |y| |x| (CDR |s|)))))
         |s|)))

(DEFUN |substitute| (|y| |x| |s|)
  (LET* (|t| |h|)
    (COND ((NULL |s|) NIL) ((EQ |x| |s|) |y|)
          ((CONSP |s|) (SETQ |h| (|substitute| |y| |x| (CAR |s|)))
           (SETQ |t| (|substitute| |y| |x| (CDR |s|)))
           (COND ((AND (EQ |h| (CAR |s|)) (EQ |t| (CDR |s|))) |s|)
                 (T (CONS |h| |t|))))
          (T |s|))))

(DEFUN |applySubst| (|sl| |t|)
  (LET* (|p| |tl| |hd|)
    (COND ((NULL |sl|) |t|)
          ((CONSP |t|) (SETQ |hd| (|applySubst| |sl| (CAR |t|)))
           (SETQ |tl| (|applySubst| |sl| (CDR |t|)))
           (COND ((AND (EQ |hd| (CAR |t|)) (EQ |tl| (CDR |t|))) |t|)
                 (T (CONS |hd| |tl|))))
          ((AND (SYMBOLP |t|) (SETQ |p| (|symbolAssoc| |t| |sl|))) (CDR |p|))
          (T |t|))))

(DEFUN |applySubst!| (|sl| |t|)
  (LET* (|p| |tl| |hd|)
    (COND ((NULL |sl|) |t|)
          ((CONSP |t|) (SETQ |hd| (|applySubst!| |sl| (CAR |t|)))
           (SETQ |tl| (|applySubst!| |sl| (CDR |t|))) (RPLACA |t| |hd|)
           (RPLACD |t| |tl|))
          ((AND (SYMBOLP |t|) (SETQ |p| (|symbolAssoc| |t| |sl|))) (CDR |p|))
          (T |t|))))

(DEFUN |applySubstNQ| (|sl| |t|)
  (LET* (|p| |tl| |hd|)
    (COND ((NULL |sl|) |t|)
          ((AND (CONSP |t|)
                (PROGN (SETQ |hd| (CAR |t|)) (SETQ |tl| (CDR |t|)) T))
           (COND ((EQ |hd| 'QUOTE) |t|)
                 (T (SETQ |hd| (|applySubstNQ| |sl| |hd|))
                  (SETQ |tl| (|applySubstNQ| |sl| |tl|))
                  (COND ((AND (EQ |hd| (CAR |t|)) (EQ |tl| (CDR |t|))) |t|)
                        (T (CONS |hd| |tl|))))))
          ((AND (SYMBOLP |t|) (SETQ |p| (|symbolAssoc| |t| |sl|))) (CDR |p|))
          (T |t|))))

(DEFUN |invertSubst| (|sl|)
  (LET ((|bfVar#2| NIL) (|bfVar#3| NIL) (|bfVar#1| |sl|) (|x| NIL))
    (LOOP
     (COND
      ((OR (NOT (CONSP |bfVar#1|)) (PROGN (SETQ |x| (CAR |bfVar#1|)) NIL))
       (RETURN |bfVar#2|))
      ((NULL |bfVar#2|)
       (SETQ |bfVar#2| #1=(CONS (CONS (CDR |x|) (CAR |x|)) NIL))
       (SETQ |bfVar#3| |bfVar#2|))
      (T (RPLACD |bfVar#3| #1#) (SETQ |bfVar#3| (CDR |bfVar#3|))))
     (SETQ |bfVar#1| (CDR |bfVar#1|)))))

(DEFUN |substSource| (|sl|)
  (LET ((|bfVar#2| NIL) (|bfVar#3| NIL) (|bfVar#1| |sl|) (|x| NIL))
    (LOOP
     (COND
      ((OR (NOT (CONSP |bfVar#1|)) (PROGN (SETQ |x| (CAR |bfVar#1|)) NIL))
       (RETURN |bfVar#2|))
      ((NULL |bfVar#2|) (SETQ |bfVar#2| #1=(CONS (CAR |x|) NIL))
       (SETQ |bfVar#3| |bfVar#2|))
      (T (RPLACD |bfVar#3| #1#) (SETQ |bfVar#3| (CDR |bfVar#3|))))
     (SETQ |bfVar#1| (CDR |bfVar#1|)))))

(DEFUN |substTarget| (|sl|)
  (LET ((|bfVar#2| NIL) (|bfVar#3| NIL) (|bfVar#1| |sl|) (|x| NIL))
    (LOOP
     (COND
      ((OR (NOT (CONSP |bfVar#1|)) (PROGN (SETQ |x| (CAR |bfVar#1|)) NIL))
       (RETURN |bfVar#2|))
      ((NULL |bfVar#2|) (SETQ |bfVar#2| #1=(CONS (CDR |x|) NIL))
       (SETQ |bfVar#3| |bfVar#2|))
      (T (RPLACD |bfVar#3| #1#) (SETQ |bfVar#3| (CDR |bfVar#3|))))
     (SETQ |bfVar#1| (CDR |bfVar#1|)))))

(DEFUN |setDifference| (|x| |y|)
  (LET* (|a| |l| |p|)
    (COND ((NULL |x|) NIL) ((NULL |y|) |x|)
          (T (SETQ |l| (SETQ |p| (LIST NIL)))
           (LET ((|bfVar#1| |x|))
             (LOOP
              (COND ((NOT (CONSP |bfVar#1|)) (RETURN NIL))
                    (T
                     (AND (CONSP |bfVar#1|)
                          (PROGN (SETQ |a| (CAR |bfVar#1|)) T)
                          (NOT (|objectMember?| |a| |y|))
                          (PROGN
                           (RPLACD |p| (LIST |a|))
                           (SETQ |p| (CDR |p|))))))
              (SETQ |bfVar#1| (CDR |bfVar#1|))))
           (CDR |l|)))))

(DEFUN |setUnion| (|x| |y|)
  (LET* (|z|)
    (PROGN
     (SETQ |z| NIL)
     (LET ((|bfVar#1| |x|) (|a| NIL))
       (LOOP
        (COND
         ((OR (NOT (CONSP |bfVar#1|)) (PROGN (SETQ |a| (CAR |bfVar#1|)) NIL))
          (RETURN NIL))
         (T (AND (NOT (|objectMember?| |a| |z|)) (SETQ |z| (CONS |a| |z|)))))
        (SETQ |bfVar#1| (CDR |bfVar#1|))))
     (LET ((|bfVar#2| |y|) (|a| NIL))
       (LOOP
        (COND
         ((OR (NOT (CONSP |bfVar#2|)) (PROGN (SETQ |a| (CAR |bfVar#2|)) NIL))
          (RETURN NIL))
         (T (AND (NOT (|objectMember?| |a| |z|)) (SETQ |z| (CONS |a| |z|)))))
        (SETQ |bfVar#2| (CDR |bfVar#2|))))
     (|reverse!| |z|))))

(DEFUN |setIntersection| (|x| |y|)
  (LET ((|bfVar#2| NIL) (|bfVar#3| NIL) (|bfVar#1| |x|) (|a| NIL))
    (LOOP
     (COND
      ((OR (NOT (CONSP |bfVar#1|)) (PROGN (SETQ |a| (CAR |bfVar#1|)) NIL))
       (RETURN |bfVar#2|))
      (T
       (AND (|objectMember?| |a| |y|)
            (COND
             ((NULL |bfVar#2|) (SETQ |bfVar#2| #1=(CONS |a| NIL))
              (SETQ |bfVar#3| |bfVar#2|))
             (T (RPLACD |bfVar#3| #1#) (SETQ |bfVar#3| (CDR |bfVar#3|)))))))
     (SETQ |bfVar#1| (CDR |bfVar#1|)))))

(DEFUN |removeSymbol| (|l| |x|)
  (LET* (|y| |LETTMP#1| |l'| |before|)
    (PROGN
     (SETQ |before| NIL)
     (SETQ |l'| |l|)
     (LOOP
      (COND ((NOT (CONSP |l'|)) (RETURN |l|))
            (T (SETQ |LETTMP#1| |l'|) (SETQ |y| (CAR |LETTMP#1|))
             (SETQ |l'| (CDR |LETTMP#1|))
             (COND
              ((EQ |x| |y|) (RETURN (|append!| (|reverse!| |before|) |l'|)))
              (T (SETQ |before| (CONS |y| |before|))))))))))

(DEFUN |removeScalar| (|l| |x|)
  (LET* (|y| |LETTMP#1| |l'| |before|)
    (PROGN
     (SETQ |before| NIL)
     (SETQ |l'| |l|)
     (LOOP
      (COND ((NOT (CONSP |l'|)) (RETURN |l|))
            (T (SETQ |LETTMP#1| |l'|) (SETQ |y| (CAR |LETTMP#1|))
             (SETQ |l'| (CDR |LETTMP#1|))
             (COND
              ((EQL |x| |y|) (RETURN (|append!| (|reverse!| |before|) |l'|)))
              (T (SETQ |before| (CONS |y| |before|))))))))))

(DEFUN |removeValue| (|l| |x|)
  (LET* (|y| |LETTMP#1| |l'| |before|)
    (PROGN
     (SETQ |before| NIL)
     (SETQ |l'| |l|)
     (LOOP
      (COND ((NOT (CONSP |l'|)) (RETURN |l|))
            (T (SETQ |LETTMP#1| |l'|) (SETQ |y| (CAR |LETTMP#1|))
             (SETQ |l'| (CDR |LETTMP#1|))
             (COND
              ((EQUAL |x| |y|) (RETURN (|append!| (|reverse!| |before|) |l'|)))
              (T (SETQ |before| (CONS |y| |before|))))))))))

(DEFUN |remove| (|l| |x|)
  (COND ((SYMBOLP |x|) (|removeSymbol| |l| |x|))
        ((OR (CHARACTERP |x|) (INTEGERP |x|)) (|removeScalar| |l| |x|))
        (T (|removeValue| |l| |x|))))

(DEFUN |findChar| (|c| |s| &OPTIONAL (|k| 0))
  (LET ((|bfVar#2| NIL) (|bfVar#1| (|maxIndex| |s|)) (|i| |k|))
    (LOOP
     (COND ((> |i| |bfVar#1|) (RETURN |bfVar#2|))
           (T
            (AND (CHAR= (SCHAR |s| |i|) |c|)
                 (PROGN
                  (SETQ |bfVar#2| |i|)
                  (COND (|bfVar#2| (RETURN |bfVar#2|)))))))
     (SETQ |i| (+ |i| 1)))))

(DEFUN |charPosition| (|c| |s| |k|)
  (LET* (|n|)
    (PROGN
     (SETQ |n| (LENGTH |s|))
     (COND ((MINUSP |k|) |n|)
           (T
            (LOOP
             (COND ((NOT (< |k| |n|)) (RETURN |k|))
                   ((CHAR= (SCHAR |s| |k|) |c|) (RETURN |k|))
                   (T (SETQ |k| (+ |k| 1))))))))))

(DEFUN |firstNonblankPosition| (|s| |k|)
  (LET ((|bfVar#2| NIL) (|bfVar#1| (- (LENGTH |s|) 1)) (|i| |k|))
    (LOOP
     (COND ((> |i| |bfVar#1|) (RETURN |bfVar#2|))
           (T
            (AND (NOT (CHAR= (SCHAR |s| |i|) (|char| '| |)))
                 (PROGN
                  (SETQ |bfVar#2| |i|)
                  (COND (|bfVar#2| (RETURN |bfVar#2|)))))))
     (SETQ |i| (+ |i| 1)))))

(DEFUN |firstBlankPosition| (|s| |k|)
  (LET ((|bfVar#2| NIL) (|bfVar#1| (- (LENGTH |s|) 1)) (|i| |k|))
    (LOOP
     (COND ((> |i| |bfVar#1|) (RETURN |bfVar#2|))
           (T
            (AND (CHAR= (SCHAR |s| |i|) (|char| '| |))
                 (PROGN
                  (SETQ |bfVar#2| |i|)
                  (COND (|bfVar#2| (RETURN |bfVar#2|)))))))
     (SETQ |i| (+ |i| 1)))))

(DEFUN |stringSuffix?| (|suf| |str|)
  (LET* (|n| |n2| |n1|)
    (PROGN
     (SETQ |n1| (LENGTH |suf|))
     (SETQ |n2| (LENGTH |str|))
     (COND ((< |n2| |n1|) NIL)
           (T (SETQ |n| (- |n2| |n1|))
            (COND
             ((LET ((|bfVar#2| T) (|bfVar#1| (- |n1| 1)) (|i| 0) (|j| |n|))
                (LOOP
                 (COND ((> |i| |bfVar#1|) (RETURN |bfVar#2|))
                       (T
                        (SETQ |bfVar#2|
                                (CHAR= (SCHAR |suf| |i|) (SCHAR |str| |j|)))
                        (COND ((NOT |bfVar#2|) (RETURN NIL)))))
                 (SETQ |i| (+ |i| 1))
                 (SETQ |j| (+ |j| 1))))
              |n|)
             (T NIL)))))))

(DEFUN |stringPrefix?| (|s1| |s2|)
  (LET* (|n1|)
    (PROGN
     (SETQ |n1| (LENGTH |s1|))
     (COND ((< (LENGTH |s2|) |n1|) NIL)
           ((LET ((|bfVar#2| T) (|bfVar#1| (- |n1| 1)) (|i| 0))
              (LOOP
               (COND ((> |i| |bfVar#1|) (RETURN |bfVar#2|))
                     (T (SETQ |bfVar#2| (EQUAL (ELT |s1| |i|) (ELT |s2| |i|)))
                      (COND ((NOT |bfVar#2|) (RETURN NIL)))))
               (SETQ |i| (+ |i| 1))))
            |n1|)
           (T NIL)))))

(DEFUN |finishLine| (|out|) (PROGN (TERPRI |out|) (FORCE-OUTPUT |out|)))