code.lsp

(DECLAIM
 (FTYPE (FUNCTION (|%Thing| |%Thing| |%Shell|) |%Thing|) |ABELGRP-;-;3$;1|)) 

(DECLAIM
 (FTYPE (FUNCTION (|%Thing| |%Thing| |%Shell|) |%Thing|)
  |ABELGRP-;subtractIfCan;2$M;2|)) 

(DECLAIM
 (FTYPE (FUNCTION ((|%IntegerSection| 0) |%Thing| |%Shell|) |%Thing|)
  |ABELGRP-;*;Nni2$;3|)) 

(DECLAIM
 (FTYPE (FUNCTION (|%Integer| |%Thing| |%Shell|) |%Thing|) |ABELGRP-;*;I2$;4|)) 

(DECLAIM
 (FTYPE (FUNCTION (|%Thing| |%Thing| |%Shell|) |%Boolean|)
  |ABELGRP-;opposite?;2$B;5|)) 

(DEFUN |ABELGRP-;-;3$;1| (|x| |y| $)
  (SPADCALL |x| (SPADCALL |y| (|shellEntry| $ 7)) (|shellEntry| $ 8))) 

(DEFUN |ABELGRP-;subtractIfCan;2$M;2| (|x| |y| $)
  (SPADCALL |x| |y| (|shellEntry| $ 10))) 

(DEFUN |ABELGRP-;*;Nni2$;3| (|n| |x| $) (SPADCALL |n| |x| (|shellEntry| $ 16))) 

(DEFUN |ABELGRP-;*;I2$;4| (|n| |x| $)
  (COND ((ZEROP |n|) (|spadConstant| $ 21))
        ((PLUSP |n|) (SPADCALL |n| |x| (|shellEntry| $ 25)))
        (T
         (SPADCALL (- |n|) (SPADCALL |x| (|shellEntry| $ 7))
                   (|shellEntry| $ 25))))) 

(DEFUN |ABELGRP-;opposite?;2$B;5| (|x| |y| $)
  (SPADCALL |x| (SPADCALL |y| (|shellEntry| $ 7)) (|shellEntry| $ 28))) 

(DEFUN |AbelianGroup&| (|#1|)
  (LET* ((|dv$1| (|devaluate| |#1|))
         (|dv$| (LIST '|AbelianGroup&| |dv$1|))
         ($ (|newShell| 30))
         (|pv$| (|buildPredVector| 0 0 NIL)))
    (PROGN
     (SETF (|shellEntry| $ 0) |dv$|)
     (SETF (|shellEntry| $ 3) |pv$|)
     (|stuffDomainSlots| $)
     (SETF (|shellEntry| $ 6) |#1|)
     (COND ((|HasCategory| |#1| '(|Ring|)))
           (T (SETF (|shellEntry| $ 27) (CONS #'|ABELGRP-;*;I2$;4| $))))
     $))) 

(MAKEPROP '|AbelianGroup&| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (0 . -) (5 . +)
              |ABELGRP-;-;3$;1| (11 . -) (|Maybe| 6) (17 . |just|) (|Maybe| $)
              |ABELGRP-;subtractIfCan;2$M;2| (|Integer|) (22 . *)
              (|NonNegativeInteger|) |ABELGRP-;*;Nni2$;3| (|Boolean|)
              (28 . |zero?|) (33 . |Zero|) (37 . |positive?|)
              (|RepeatedDoubling| 6) (|PositiveInteger|) (42 . |double|)
              (48 . -) (53 . *) (59 . =) |ABELGRP-;opposite?;2$B;5|)
           '#(|subtractIfCan| 65 |opposite?| 71 - 77 * 83) 'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 29
                                                 '(1 6 0 0 7 2 6 0 0 0 8 2 6 0
                                                   0 0 10 1 11 0 6 12 2 6 0 15
                                                   0 16 1 15 19 0 20 0 6 0 21 1
                                                   15 19 0 22 2 23 6 24 6 25 1
                                                   15 0 0 26 2 0 0 15 0 27 2 6
                                                   19 0 0 28 2 0 13 0 0 14 2 0
                                                   19 0 0 29 2 0 0 0 0 9 2 0 0
                                                   15 0 27 2 0 0 17 0 18)))))
           '|lookupComplete|)) 

(SETF (|dbTemplate| (|constructorDB| '|AbelianGroup&|))
        #(NIL NIL NIL NIL NIL NIL (|local| |#1|) (0 . -) (5 . +)
          |ABELGRP-;-;3$;1| (11 . -) (|Maybe| 6) (17 . |just|) (|Maybe| $)
          |ABELGRP-;subtractIfCan;2$M;2| (|Integer|) (22 . *)
          (|NonNegativeInteger|) |ABELGRP-;*;Nni2$;3| (|Boolean|)
          (28 . |zero?|) (33 . |Zero|) (37 . |positive?|)
          (|RepeatedDoubling| 6) (|PositiveInteger|) (42 . |double|) (48 . -)
          (53 . *) (59 . =) |ABELGRP-;opposite?;2$B;5|)) 

(SETF (|dbLookupFunction| (|constructorDB| '|AbelianGroup&|)) '|lookupComplete|) 

(SETF (|dbConstructorForm| (|constructorDB| '|AbelianGroup&|))
        '(|AbelianGroup&| S)) 

(SETF (|dbConstructorKind| (|constructorDB| '|AbelianGroup&|)) '|package|) 

(SETF (|dbConstructorModemap| (|constructorDB| '|AbelianGroup&|))
        '(((|AbelianGroup&| |#1|)
           (CATEGORY |package| (SIGNATURE - (|#1| |#1| |#1|))
            (SIGNATURE - (|#1| |#1|)) (SIGNATURE * (|#1| (|Integer|) |#1|))
            (SIGNATURE |subtractIfCan| ((|Maybe| |#1|) |#1| |#1|))
            (SIGNATURE |opposite?| ((|Boolean|) |#1| |#1|))
            (SIGNATURE * (|#1| (|NonNegativeInteger|) |#1|))
            (SIGNATURE * (|#1| (|PositiveInteger|) |#1|)))
           (|AbelianGroup|))
          (T |AbelianGroup&|))) 

(SETF (|dbDualSignature| (|constructorDB| '|AbelianGroup&|)) '(NIL T)) 

(SETF (|dbSourceFile| (|constructorDB| '|AbelianGroup&|)) '"catdef.spad") 

(SETF (|dbOperations| (|constructorDB| '|AbelianGroup&|))
        '((|subtractIfCan| (((|Maybe| $) $ $) 14 T ELT))
          (|opposite?| (((|Boolean|) $ $) 29 T ELT))
          (- (($ $) NIL T ELT) (($ $ $) 9 T ELT))
          (* (($ (|PositiveInteger|) $) NIL T ELT)
             (($ (|NonNegativeInteger|) $) 18 T ELT)
             (($ (|Integer|) $) 27 T ELT)))) 

(SETF (|dbOperationTable| (|constructorDB| '|AbelianGroup&|))
        #(|subtractIfCan| 65 |opposite?| 71 - 77 * 83)) 

(SETF (|dbCapsuleDefinitions| (|constructorDB| '|AbelianGroup&|))
        '((|ABELGRP-;opposite?;2$B;5| ((|Boolean|) $ $))
          (|ABELGRP-;*;I2$;4| ($ (|Integer|) $))
          (|ABELGRP-;*;Nni2$;3| ($ (|NonNegativeInteger|) $))
          (|ABELGRP-;subtractIfCan;2$M;2| ((|Maybe| $) $ $))
          (|ABELGRP-;-;3$;1| ($ $ $)))) 

(SETF (|dbAbbreviation| (|constructorDB| '|AbelianGroup&|)) 'ABELGRP-)