(EXPT2*
 (24 24 (:TYPE-PRESCRIPTION FLOOR-TYPE-3 . 1))
 (24 24 (:TYPE-PRESCRIPTION FLOOR-TYPE-1 . 2))
 (24 24 (:TYPE-PRESCRIPTION FLOOR-TYPE-1 . 1))
 (21 3 (:REWRITE ZIP-OPEN))
 (19 15 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (18 18 (:TYPE-PRESCRIPTION |x < y  =>  0 < -x+y|))
 (16 1 (:REWRITE NORMALIZE-EQUAL-0))
 (14 10 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (13 1 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (9 8 (:REWRITE DEFAULT-+-2))
 (9 8 (:REWRITE DEFAULT-+-1))
 (8 1 (:REWRITE EQUAL-BIT-1))
 (6 6 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (5 5 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (5 5 (:REWRITE DEFAULT-<-2))
 (5 5 (:REWRITE DEFAULT-<-1))
 (5 2 (:REWRITE DEFAULT-*-2))
 (5 2 (:REWRITE DEFAULT-*-1))
 (5 1 (:REWRITE <-+-CONSTANT-CONSTANT))
 (4 1 (:REWRITE EQUAL-1-HACK))
 (3 1 (:REWRITE FOLD-CONSTS-IN-+))
 (3 1 (:REWRITE FLOOR-WHEN-I-IS-NOT-AN-ACL2-NUMBERP))
 (2 2 (:TYPE-PRESCRIPTION UNSIGNED-BYTE-P))
 (1 1 (:TYPE-PRESCRIPTION EXPT-TYPE-PRESCRIPTION-RATIONALP))
 (1 1 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (1 1 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (1 1 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (1 1 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (1 1 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (1 1 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (1 1 (:REWRITE FLOOR-WHEN-J-IS-NOT-AN-ACL2-NUMBERP))
 (1 1 (:REWRITE EXPONENTS-ADD-FOR-NONNEG-EXPONENTS))
 (1 1 (:REWRITE EXPONENTS-ADD))
 (1 1 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (1 1 (:REWRITE DEFAULT-UNARY-MINUS))
 )
(SIGNED-BYTE-P-LOGNOT
 (63 63 (:TYPE-PRESCRIPTION |x < y  =>  0 < -x+y|))
 (20 1 (:REWRITE FALSIFY-SIGNED-BYTE-P))
 (10 2 (:REWRITE <-+-CONSTANT-CONSTANT))
 (9 1 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (9 1 (:LINEAR EXPT->-1))
 (7 7 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (6 5 (:REWRITE DEFAULT-<-2))
 (6 5 (:REWRITE DEFAULT-<-1))
 (4 4 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (4 1 (:REWRITE LOGNOT-ZIP))
 (3 3 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (2 2 (:TYPE-PRESCRIPTION ZIP))
 (2 2 (:REWRITE SIGNED-BYTE-P-UNSIGNED-BYTE-P))
 (2 2 (:REWRITE SIGNED-BYTE-P-SUBTYPE))
 (2 2 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 (2 2 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (1 1 (:REWRITE ZIP-OPEN))
 (1 1 (:REWRITE BACKCHAIN-SIGNED-BYTE-P-TO-UNSIGNED-BYTE-P))
 )
(LOGNOT-NEG
 (4 4 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (4 4 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (2 2 (:REWRITE DEFAULT-<-2))
 (2 2 (:REWRITE DEFAULT-<-1))
 (2 2 (:REWRITE DEFAULT-+-2))
 (2 2 (:REWRITE DEFAULT-+-1))
 (1 1 (:REWRITE SBP-BOUND-1))
 (1 1 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (1 1 (:REWRITE DEFAULT-UNARY-MINUS))
 )
(LOGNOT-LOGIOR
 (52958 161 (:REWRITE LOGNOT-ZIP))
 (46885 1355 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (45508 2082 (:REWRITE LOGCAR-IDENTITY))
 (44698 32 (:DEFINITION LOGMASKP*))
 (41449 1149 (:REWRITE LOGCDR-EQUAL-0-REWRITE))
 (36759 1943 (:DEFINITION UNSIGNED-BYTE-P*))
 (27480 1786 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (14075 4044 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (13422 22 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (13375 13 (:REWRITE ASH-0))
 (12798 171 (:REWRITE B-NOT-OPEN-1))
 (11623 819 (:REWRITE EQUAL-BIT-1))
 (9039 2082 (:REWRITE LOGCAR-EVENP))
 (9028 79 (:REWRITE CANCEL-EQUAL-LOGNOT . 2))
 (5982 18 (:REWRITE LOGIOR-=-0))
 (5830 5830 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (4612 4612 (:TYPE-PRESCRIPTION EVENP))
 (4044 4044 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (4044 4044 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (4044 4044 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (4030 2670 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (3183 2082 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (3015 3015 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (2932 740 (:REWRITE LOGCAR-0-REWRITE))
 (2927 2753 (:REWRITE DEFAULT-<-1))
 (2924 787 (:REWRITE EQUAL-1-HACK))
 (2753 2753 (:REWRITE DEFAULT-<-2))
 (2505 2505 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (2426 2268 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (1668 12 (:REWRITE EQUAL-K-B-IOR))
 (1644 24 (:DEFINITION ZBP$INLINE))
 (1199 2 (:REWRITE LOGTAIL-LOGAND))
 (1187 2 (:REWRITE LOGTAIL-LOGNOT))
 (1175 84 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (1062 38 (:LINEAR LOGIOR-BND-ERIC-LINEAR))
 (950 217 (:REWRITE LOGCDR-<-0))
 (805 72 (:REWRITE LOGNOT-NEG))
 (664 8 (:REWRITE LOGCDR-LOGIOR))
 (540 8 (:REWRITE LOGCAR-LOGIOR))
 (274 18 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (206 9 (:REWRITE EVENP-OF-LOGCONS))
 (175 11 (:REWRITE LOGCONS-<-0))
 (84 84 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (72 40 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (72 38 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (70 40 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 (60 38 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (32 32 (:REWRITE UNSIGNED-BYTE-P-B-NOT))
 (17 13 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (13 13 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (13 13 (:REWRITE ASH-GOES-TO-0))
 (11 11 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (2 2 (:REWRITE LOGHEAD-SUBST2))
 (2 2 (:REWRITE LOGHEAD-SUBST))
 (1 1 (:INDUCTION LOGAND-INDUCTION))
 )
(LOGAND-LOGIOR-2
 (148 2 (:LINEAR LOGIOR-BND-ERIC-LINEAR))
 (44 4 (:REWRITE LOGAND-NON-NEGATIVE))
 (28 22 (:REWRITE DEFAULT-<-1))
 (26 26 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (24 24 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (22 22 (:REWRITE DEFAULT-<-2))
 (20 4 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (20 4 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (16 8 (:REWRITE LOGAND-WITH-MASK))
 (9 8 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (9 8 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (8 8 (:TYPE-PRESCRIPTION LOGMASKP))
 (5 3 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (5 3 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 (3 3 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 )
(LOGAND-ZIP
 (7 3 (:REWRITE LOGAND-WITH-MASK))
 (5 3 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (5 3 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (4 4 (:TYPE-PRESCRIPTION LOGMASKP))
 (4 4 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (1 1 (:REWRITE ZIP-OPEN))
 )
(SIGNED-BYTE-P-LOGAND
 (137 137 (:TYPE-PRESCRIPTION |x < y  =>  0 < -x+y|))
 (40 2 (:REWRITE FALSIFY-SIGNED-BYTE-P))
 (10 10 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (10 2 (:REWRITE <-+-CONSTANT-CONSTANT))
 (9 8 (:REWRITE DEFAULT-<-2))
 (9 8 (:REWRITE DEFAULT-<-1))
 (9 1 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (9 1 (:LINEAR EXPT->-1))
 (8 8 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (6 6 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (3 3 (:REWRITE SIGNED-BYTE-P-UNSIGNED-BYTE-P))
 (3 3 (:REWRITE SIGNED-BYTE-P-SUBTYPE))
 (3 1 (:REWRITE LOGAND-WITH-MASK))
 (2 2 (:TYPE-PRESCRIPTION LOGMASKP))
 (2 2 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 (2 2 (:REWRITE BACKCHAIN-SIGNED-BYTE-P-TO-UNSIGNED-BYTE-P))
 (2 2 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (1 1 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 )
(LOGAND-NEG
 (396 12 (:REWRITE FLOOR-BY-TWICE-HACK))
 (336 12 (:REWRITE FLOOR-OF-SHIFT-RIGHT-2))
 (146 50 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (82 16 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (82 16 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (73 67 (:REWRITE DEFAULT-*-2))
 (72 54 (:REWRITE DEFAULT-+-2))
 (72 54 (:REWRITE DEFAULT-+-1))
 (67 67 (:REWRITE DEFAULT-*-1))
 (60 60 (:TYPE-PRESCRIPTION |x < y  =>  0 < -x+y|))
 (60 60 (:REWRITE FLOOR-WHEN-J-IS-NOT-AN-ACL2-NUMBERP))
 (60 60 (:REWRITE FLOOR-WHEN-I-IS-NOT-AN-ACL2-NUMBERP))
 (46 16 (:REWRITE LOGAND-WITH-MASK))
 (38 31 (:REWRITE DEFAULT-<-1))
 (36 36 (:REWRITE FLOOR-OF-INTEGER-BY-1))
 (36 12 (:REWRITE FOLD-CONSTS-IN-*))
 (33 33 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (33 33 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (31 31 (:REWRITE DEFAULT-<-2))
 (30 30 (:TYPE-PRESCRIPTION LOGMASKP))
 (28 13 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (26 26 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (24 24 (:REWRITE INTEGERP-+-MINUS-*-4))
 (24 12 (:REWRITE EVENP-COLLAPSE))
 (13 13 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (12 12 (:TYPE-PRESCRIPTION FLOOR-TYPE-3 . 2))
 (12 12 (:TYPE-PRESCRIPTION FLOOR-TYPE-3 . 1))
 (12 12 (:TYPE-PRESCRIPTION FLOOR-TYPE-1 . 2))
 (12 7 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (5 5 (:REWRITE ZIP-OPEN))
 )
(IFIX-LOGAND
 (4 2 (:REWRITE LOGAND-WITH-MASK))
 (3 2 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (3 2 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (2 2 (:TYPE-PRESCRIPTION LOGMASKP))
 (2 2 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 )
(LOGAND-WITH-MASK-ERIC
 (68 4 (:REWRITE LOGHEAD-IDENTITY))
 (50 5 (:REWRITE LOGHEAD-WHEN-SIZE-IS-NOT-POSITIVE))
 (40 4 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (25 15 (:REWRITE DEFAULT-<-2))
 (20 15 (:REWRITE DEFAULT-<-1))
 (16 16 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (15 15 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (14 14 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (12 2 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (12 2 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (10 5 (:REWRITE LOGHEAD-WHEN-SIZE-IS-NOT-AN-INTEGERP))
 (9 1 (:LINEAR EXPT->-1))
 (8 4 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (6 3 (:REWRITE INTEGER-LENGTH-WHEN-I-IS-NOT-AN-INTEGERP))
 (6 1 (:LINEAR LOGHEAD-LEQ))
 (5 5 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 (5 5 (:REWRITE LOGHEAD-SUBST2))
 (5 5 (:REWRITE LOGHEAD-SUBST))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (3 2 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (2 2 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (2 1 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (2 1 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (1 1 (:REWRITE LOGHEAD-COMPARE-HACK))
 )
(MY-LOGEXTU-AS-LOGHEAD
 (116 10 (:REWRITE LOGHEAD-IDENTITY))
 (92 14 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (74 4 (:REWRITE LOGEXT-IDENTITY))
 (61 46 (:REWRITE DEFAULT-<-2))
 (54 4 (:REWRITE BACKCHAIN-SIGNED-BYTE-P-TO-UNSIGNED-BYTE-P))
 (52 46 (:REWRITE DEFAULT-<-1))
 (48 4 (:LINEAR LOGHEAD-LEQ))
 (46 46 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (42 42 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (38 38 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (34 2 (:LINEAR LOGCAR-RANGE-LINEAR))
 (27 27 (:TYPE-PRESCRIPTION UNSIGNED-BYTE-P))
 (24 3 (:REWRITE LOGCAR-IDENTITY))
 (19 19 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 (18 18 (:REWRITE LOGHEAD-SUBST2))
 (18 18 (:REWRITE LOGHEAD-SUBST))
 (16 4 (:LINEAR LOGEXT-BOUNDS))
 (15 15 (:TYPE-PRESCRIPTION LOGEXT-TYPE))
 (15 3 (:REWRITE LOGCAR-EVENP))
 (14 14 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (14 14 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (14 14 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (14 14 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (12 8 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (10 2 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (10 2 (:LINEAR EXPT->-1))
 (8 8 (:TYPE-PRESCRIPTION SIGNED-BYTE-P))
 (8 4 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (7 7 (:TYPE-PRESCRIPTION LOGCAR-TYPE))
 (7 7 (:TYPE-PRESCRIPTION EVENP))
 (7 4 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (6 6 (:TYPE-PRESCRIPTION EXPT-TYPE-PRESCRIPTION-INTEGERP))
 (6 3 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (6 1 (:REWRITE LOGCAR-0-REWRITE))
 (5 5 (:REWRITE LOGEXT-WHEN-SIZE-IS-NOT-AN-INTEGERP))
 (4 4 (:REWRITE SIGNED-BYTE-P-UNSIGNED-BYTE-P))
 (4 4 (:REWRITE SIGNED-BYTE-P-SUBTYPE))
 (4 4 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 )
(LOGAND-BIT-0
 (173 9 (:REWRITE LOGCAR-IDENTITY))
 (64 6 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (38 9 (:REWRITE LOGCAR-EVENP))
 (19 19 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (19 6 (:REWRITE EQUAL-BIT-1))
 (17 17 (:TYPE-PRESCRIPTION EVENP))
 (16 16 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (16 16 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (16 16 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (16 16 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (14 9 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (14 9 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (12 2 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (11 9 (:REWRITE DEFAULT-<-1))
 (9 9 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (9 9 (:REWRITE DEFAULT-<-2))
 (9 6 (:REWRITE EQUAL-1-HACK))
 (8 8 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (8 7 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (4 2 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (3 1 (:REWRITE LOGCAR-0-REWRITE))
 (2 2 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 (2 2 (:REWRITE LOGHEAD-SUBST2))
 (2 2 (:REWRITE LOGHEAD-SUBST))
 (1 1 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE LOGHEAD-WHEN-SIZE-IS-NOT-AN-INTEGERP))
 )
(LOGAND-BIT-1
 (373 3 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (364 3 (:DEFINITION LOGMASKP*))
 (329 17 (:REWRITE LOGCAR-IDENTITY))
 (139 14 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (101 15 (:REWRITE EQUAL-BIT-1))
 (85 4 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (83 3 (:REWRITE LOGAND-BIT-0))
 (70 17 (:REWRITE LOGCAR-EVENP))
 (43 43 (:TYPE-PRESCRIPTION EVENP))
 (41 41 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (36 36 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (36 36 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (36 36 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (35 25 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (28 28 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (26 24 (:REWRITE DEFAULT-<-1))
 (25 25 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (25 17 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (24 24 (:REWRITE DEFAULT-<-2))
 (23 7 (:REWRITE LOGCAR-0-REWRITE))
 (23 3 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (22 22 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (22 20 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (21 12 (:REWRITE EQUAL-1-HACK))
 (15 15 (:TYPE-PRESCRIPTION LOGMASKP))
 (12 2 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (5 1 (:REWRITE LOGCDR-<-0))
 (4 2 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (3 3 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (2 2 (:TYPE-PRESCRIPTION ZIP))
 (2 2 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 (1 1 (:REWRITE ZIP-OPEN))
 (1 1 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE UNSIGNED-BYTE-P-LOGCAR))
 )
(LOGAND-LOGNOT
 (5236 235 (:DEFINITION UNSIGNED-BYTE-P*))
 (5114 276 (:REWRITE LOGCAR-IDENTITY))
 (4964 176 (:LINEAR LOGCAR-RANGE-LINEAR))
 (3927 212 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (2683 465 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (2650 13 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (2619 14 (:DEFINITION LOGMASKP*))
 (1682 32 (:REWRITE B-NOT-OPEN-1))
 (1506 9 (:REWRITE LOGCDR-LOGNOT))
 (1261 59 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (1068 276 (:REWRITE LOGCAR-EVENP))
 (888 2 (:REWRITE LOGTAIL-LOGAND))
 (695 695 (:TYPE-PRESCRIPTION LOGCAR-TYPE))
 (594 594 (:TYPE-PRESCRIPTION EVENP))
 (537 537 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (465 465 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (465 465 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (465 465 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (440 337 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (405 405 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (376 357 (:REWRITE DEFAULT-<-1))
 (366 276 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (357 357 (:REWRITE DEFAULT-<-2))
 (344 344 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (324 36 (:REWRITE LOGNOT-NEG))
 (318 88 (:REWRITE LOGCAR-0-REWRITE))
 (305 270 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (297 30 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (286 6 (:REWRITE ASH-0))
 (285 126 (:REWRITE EQUAL-1-HACK))
 (270 13 (:REWRITE LOGAND-BIT-0))
 (255 19 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (225 41 (:REWRITE LOGCDR-<-0))
 (196 196 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (182 2 (:REWRITE LOGCAR-LOGNOT))
 (163 19 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (104 7 (:REWRITE LOGCONS-<-0))
 (57 57 (:TYPE-PRESCRIPTION LOGMASKP))
 (30 30 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (14 7 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (14 1 (:REWRITE UNSIGNED-BYTE-P-ASH-POS))
 (13 13 (:REWRITE UNSIGNED-BYTE-P-LOGCAR))
 (12 6 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (12 6 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (11 2 (:REWRITE EVENP-OF-LOGCONS))
 (9 1 (:REWRITE ASH-EQUAL-CONSTANT))
 (7 7 (:TYPE-PRESCRIPTION ASH))
 (7 7 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (7 7 (:REWRITE ASH-GOES-TO-0))
 (6 6 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 (4 2 (:DEFINITION IFIX))
 )
(LOGAND-COMMUTATIVE-2-HELPER
 (15106 744 (:DEFINITION UNSIGNED-BYTE-P*))
 (14596 683 (:REWRITE LOGCAR-IDENTITY))
 (10302 368 (:LINEAR LOGCAR-RANGE-LINEAR))
 (7613 1444 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (3291 165 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (1685 1685 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (1444 1444 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (1444 1444 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (1444 1444 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (1273 978 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (1196 1196 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (1120 1120 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (1094 10 (:REWRITE LOGCDR-LOGAND))
 (1065 1063 (:REWRITE DEFAULT-<-1))
 (1063 1063 (:REWRITE DEFAULT-<-2))
 (938 876 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (916 13 (:REWRITE ASH-0))
 (803 683 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (751 110 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (721 479 (:REWRITE EQUAL-1-HACK))
 (578 116 (:REWRITE LOGCDR-<-0))
 (535 110 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (134 2 (:REWRITE LOGCAR-LOGAND))
 (92 57 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (90 18 (:REWRITE EVENP-OF-LOGCONS))
 (83 57 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (67 67 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (36 2 (:REWRITE UNSIGNED-BYTE-P-ASH-POS))
 (34 18 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (33 33 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (24 8 (:REWRITE UNSIGNED-BYTE-P-LOGAND))
 (18 18 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (18 18 (:REWRITE ASH-GOES-TO-0))
 (1 1 (:REWRITE LOGHEAD-WHEN-SIZE-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE LOGHEAD-SUBST2))
 (1 1 (:REWRITE LOGHEAD-SUBST))
 (1 1 (:REWRITE INTEGER-LENGTH-WHEN-I-IS-NOT-AN-INTEGERP))
 )
(EQUAL-LOGAND-LOGCONS
 (10969 52 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (10845 38 (:DEFINITION LOGMASKP*))
 (7950 384 (:REWRITE LOGCAR-IDENTITY))
 (5213 283 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (3639 208 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (2178 222 (:REWRITE EQUAL-BIT-1))
 (1124 52 (:REWRITE LOGAND-BIT-1))
 (1054 1054 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (937 52 (:REWRITE LOGAND-BIT-0))
 (810 810 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (810 810 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (810 810 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (786 21 (:REWRITE ASH-0))
 (705 21 (:REWRITE ZIP-OPEN))
 (643 643 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (639 501 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (596 596 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (580 529 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (579 579 (:REWRITE DEFAULT-<-2))
 (579 579 (:REWRITE DEFAULT-<-1))
 (478 384 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (407 37 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (348 38 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (327 186 (:REWRITE EQUAL-1-HACK))
 (300 60 (:REWRITE LOGCDR-<-0))
 (185 37 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (183 183 (:TYPE-PRESCRIPTION LOGMASKP))
 (98 49 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (72 49 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (39 21 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (38 38 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (36 36 (:REWRITE UNSIGNED-BYTE-P-LOGCAR))
 (24 24 (:TYPE-PRESCRIPTION ZIP))
 (21 21 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (21 21 (:REWRITE ASH-GOES-TO-0))
 (20 4 (:REWRITE LOGCONS-<-0))
 (14 14 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (6 1 (:REWRITE UNSIGNED-BYTE-P-ASH-POS))
 (3 3 (:REWRITE ASH-EQUAL-CONSTANT))
 (2 2 (:REWRITE EVENP-OF-LOGCONS))
 (1 1 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE EQUAL-LOGCONS-0))
 )
(LOGAND-EXPT-HELPER
 (15322 53 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (15180 46 (:DEFINITION LOGMASKP*))
 (11489 72 (:REWRITE ASH-0))
 (11047 51 (:REWRITE ZIP-OPEN))
 (9798 345 (:DEFINITION UNSIGNED-BYTE-P*))
 (7960 247 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (7876 428 (:REWRITE LOGCAR-IDENTITY))
 (6166 389 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (6103 23 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (5318 217 (:REWRITE LOGCDR-EQUAL-0-REWRITE))
 (4435 852 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (1748 1748 (:TYPE-PRESCRIPTION |x < y  =>  0 < -x+y|))
 (1638 57 (:REWRITE LOGAND-BIT-1))
 (1563 83 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (1497 1497 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (1386 21 (:REWRITE NORMALIZE-EQUAL-0))
 (1340 38 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (1326 1326 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (1232 42 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (1103 1082 (:REWRITE DEFAULT-<-1))
 (1082 1082 (:REWRITE DEFAULT-<-2))
 (1000 1000 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (933 20 (:LINEAR EXPT->-1))
 (915 915 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (852 852 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (852 852 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (840 80 (:REWRITE INTEGERP-EXPT))
 (753 570 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (731 591 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (663 72 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (640 40 (:REWRITE INTEGERP-*-1/2-EXPT))
 (559 428 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (466 157 (:REWRITE EQUAL-1-HACK))
 (284 4 (:REWRITE EXPT-2-EQUAL-1-REWRITE))
 (276 4 (:DEFINITION =))
 (260 49 (:REWRITE LOGCDR-<-0))
 (218 218 (:TYPE-PRESCRIPTION LOGMASKP))
 (160 40 (:REWRITE DEFAULT-*-2))
 (152 48 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (112 66 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (110 48 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (92 46 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (89 68 (:REWRITE DEFAULT-+-2))
 (72 72 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (72 72 (:REWRITE ASH-GOES-TO-0))
 (68 68 (:REWRITE DEFAULT-+-1))
 (63 21 (:REWRITE FOLD-CONSTS-IN-+))
 (59 59 (:REWRITE SBP-BOUND-1))
 (51 51 (:TYPE-PRESCRIPTION ZIP))
 (40 40 (:REWRITE INTEGERP-+-MINUS-*-4))
 (40 40 (:REWRITE DEFAULT-*-1))
 (40 40 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (39 20 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (30 2 (:REWRITE UNSIGNED-BYTE-P-ASH-POS))
 (28 4 (:REWRITE ASH-EQUAL-CONSTANT))
 (22 22 (:REWRITE UNSIGNED-BYTE-P-LOGCAR))
 (21 21 (:REWRITE DEFAULT-UNARY-MINUS))
 (20 20 (:REWRITE EXPONENTS-ADD-FOR-NONNEG-EXPONENTS))
 (20 20 (:REWRITE EXPONENTS-ADD))
 (20 2 (:REWRITE LOGBITP-WHEN-I-IS-NON-POSITIVE))
 (4 2 (:REWRITE LOGBITP-WHEN-J-IS-NOT-AN-INTEGERP))
 (3 3 (:TYPE-PRESCRIPTION SUB1-LOGCDR-LOGCDR-INDUCTION))
 (2 1 (:REWRITE LOGBITP-WHEN-I-IS-NOT-AN-INTEGERP))
 )
(LOGAND-EXPT
 (119 7 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT))
 (103 8 (:REWRITE LOGAND-BIT-1))
 (89 12 (:REWRITE LOGCAR-IDENTITY))
 (44 44 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (36 31 (:REWRITE DEFAULT-<-2))
 (36 31 (:REWRITE DEFAULT-<-1))
 (32 32 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (28 14 (:DEFINITION IFIX))
 (26 26 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (26 26 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (24 8 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (21 7 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (20 20 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 (19 19 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (19 19 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (19 19 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (17 12 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (14 14 (:TYPE-PRESCRIPTION LOGMASKP))
 (14 14 (:REWRITE IFIX-INTEGERP))
 (13 6 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (6 1 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (4 1 (:LINEAR LOGAND-UPPER-BOUND . 1))
 )
(INTEGER-LENGTH-<-1-REWRITE
 (110 2 (:DEFINITION INTEGER-LENGTH))
 (66 2 (:REWRITE FLOOR-BY-TWICE-HACK))
 (56 2 (:REWRITE FLOOR-OF-SHIFT-RIGHT-2))
 (27 11 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (27 4 (:REWRITE INTEGER-LENGTH-WHEN-I-IS-NOT-AN-INTEGERP))
 (14 3 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (12 12 (:TYPE-PRESCRIPTION EVENP))
 (10 10 (:TYPE-PRESCRIPTION |x < y  =>  0 < -x+y|))
 (10 10 (:REWRITE FLOOR-WHEN-J-IS-NOT-AN-ACL2-NUMBERP))
 (10 10 (:REWRITE FLOOR-WHEN-I-IS-NOT-AN-ACL2-NUMBERP))
 (10 10 (:REWRITE DEFAULT-*-2))
 (10 10 (:REWRITE DEFAULT-*-1))
 (6 6 (:REWRITE FLOOR-OF-INTEGER-BY-1))
 (6 4 (:REWRITE DEFAULT-+-2))
 (6 2 (:REWRITE FOLD-CONSTS-IN-*))
 (4 4 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (4 4 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (4 4 (:REWRITE INTEGERP-+-MINUS-*-4))
 (4 4 (:REWRITE DEFAULT-+-1))
 (4 3 (:REWRITE DEFAULT-<-1))
 (4 2 (:REWRITE EVENP-COLLAPSE))
 (3 3 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (3 3 (:REWRITE DEFAULT-<-2))
 (2 2 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (1 1 (:REWRITE ZIP-OPEN))
 )
(LOGAND-EXPT-CONSTANT-VERSION
 (34 2 (:REWRITE LOGBITP-WHEN-I-IS-NON-POSITIVE))
 (30 4 (:REWRITE <-+-CONSTANT-CONSTANT))
 (16 8 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (16 2 (:REWRITE LOGAND-BIT-1))
 (16 2 (:REWRITE LOGAND-BIT-0))
 (15 1 (:LINEAR EXPT->-1))
 (12 6 (:REWRITE DEFAULT-+-2))
 (12 4 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (11 1 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (8 8 (:TYPE-PRESCRIPTION UNSIGNED-BYTE-P))
 (8 8 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (7 7 (:REWRITE INTEGER-LENGTH-WHEN-I-IS-NOT-AN-INTEGERP))
 (7 4 (:REWRITE DEFAULT-<-2))
 (6 6 (:REWRITE DEFAULT-+-1))
 (6 2 (:REWRITE LOGBITP-WHEN-I-IS-NOT-AN-INTEGERP))
 (6 2 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (6 1 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (5 5 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (5 5 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (5 4 (:REWRITE DEFAULT-<-1))
 (4 4 (:TYPE-PRESCRIPTION LOGMASKP))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (4 4 (:REWRITE EXPONENTS-ADD-FOR-NONNEG-EXPONENTS))
 (4 4 (:REWRITE EXPONENTS-ADD))
 (4 2 (:REWRITE LOGBITP-WHEN-J-IS-NOT-AN-INTEGERP))
 (4 2 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (2 2 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (2 2 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (2 1 (:REWRITE ODD-EQUAL-EXPT-CHEAP))
 (2 1 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (1 1 (:TYPE-PRESCRIPTION EVENP))
 (1 1 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 )
(EQUAL-LOGAND-EXPT
 (9 6 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (8 8 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (7 2 (:REWRITE LOGBITP-WHEN-I-IS-NON-POSITIVE))
 (6 3 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (3 2 (:REWRITE LOGBITP-WHEN-J-IS-NOT-AN-INTEGERP))
 (3 2 (:REWRITE LOGBITP-WHEN-I-IS-NOT-AN-INTEGERP))
 (3 2 (:REWRITE DEFAULT-<-2))
 (3 2 (:REWRITE DEFAULT-<-1))
 (2 2 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (2 2 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (2 2 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 (2 1 (:REWRITE ODD-EQUAL-EXPT-CHEAP))
 (1 1 (:TYPE-PRESCRIPTION EVENP))
 (1 1 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 )
(EQUAL-LOGAND-EXPT-REWRITE
 (450 1 (:DEFINITION LOGAND*-BETTER))
 (446 2 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (440 2 (:DEFINITION LOGMASKP*))
 (380 20 (:DEFINITION UNSIGNED-BYTE-P*))
 (332 18 (:REWRITE LOGCAR-IDENTITY))
 (260 10 (:LINEAR LOGCAR-RANGE-LINEAR))
 (242 40 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (222 18 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (202 1 (:DEFINITION LOGBITP*-BETTER))
 (169 17 (:REWRITE EQUAL-BIT-1))
 (107 1 (:REWRITE NORMALIZE-EQUAL-0))
 (100 1 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (99 17 (:REWRITE LOGCDR-EQUAL-0-REWRITE))
 (90 90 (:TYPE-PRESCRIPTION LOGCDR-TYPE))
 (90 5 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (77 18 (:REWRITE LOGCAR-EVENP))
 (58 58 (:TYPE-PRESCRIPTION UNSIGNED-BYTE-P))
 (54 2 (:REWRITE LOGAND-BIT-1))
 (48 48 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (47 47 (:TYPE-PRESCRIPTION LOGCAR-TYPE))
 (44 44 (:TYPE-PRESCRIPTION EVENP))
 (44 2 (:REWRITE LOGAND-BIT-0))
 (40 40 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (40 40 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (40 40 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (38 14 (:REWRITE EQUAL-1-HACK))
 (36 25 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (34 5 (:REWRITE <-+-CONSTANT-CONSTANT))
 (34 2 (:REWRITE LOGBITP-WHEN-I-IS-NON-POSITIVE))
 (33 29 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (28 4 (:DEFINITION INTEGER-LENGTH*))
 (26 18 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (21 6 (:REWRITE LOGCAR-0-REWRITE))
 (19 9 (:REWRITE DEFAULT-+-2))
 (19 2 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (18 18 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (15 12 (:REWRITE DEFAULT-<-2))
 (15 1 (:LINEAR EXPT->-1))
 (14 12 (:REWRITE DEFAULT-<-1))
 (13 13 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (12 8 (:REWRITE INTEGER-LENGTH-WHEN-I-IS-NOT-AN-INTEGERP))
 (11 11 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (11 1 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (10 10 (:TYPE-PRESCRIPTION LOGMASKP))
 (9 9 (:REWRITE DEFAULT-+-1))
 (8 4 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (6 2 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (5 1 (:REWRITE LOGCDR-<-0))
 (4 2 (:REWRITE LOGBITP-WHEN-J-IS-NOT-AN-INTEGERP))
 (4 2 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (4 1 (:REWRITE FOLD-CONSTS-IN-+))
 (3 3 (:REWRITE UNSIGNED-BYTE-P-LOGCAR))
 (3 2 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (3 1 (:REWRITE LOGBITP-WHEN-I-IS-NOT-AN-INTEGERP))
 (2 2 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (2 2 (:REWRITE EXPONENTS-ADD-FOR-NONNEG-EXPONENTS))
 (2 2 (:REWRITE EXPONENTS-ADD))
 (2 2 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (2 1 (:REWRITE DEFAULT-UNARY-MINUS))
 (1 1 (:REWRITE SBP-BOUND-1))
 (1 1 (:REWRITE EQUAL-INTEGER-LENGTH-0))
 )
(LOGAND---EXPT
 (10232 61 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (10105 38 (:DEFINITION LOGMASKP*))
 (7099 250 (:DEFINITION UNSIGNED-BYTE-P*))
 (5753 319 (:REWRITE LOGCAR-IDENTITY))
 (4920 182 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (3923 202 (:REWRITE EQUAL-BIT-1))
 (3558 531 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (2869 154 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (2504 162 (:REWRITE LOGCDR-EQUAL-0-REWRITE))
 (2010 85 (:REWRITE ASH-0))
 (2004 238 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (1842 552 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (1550 32 (:REWRITE ZIP-OPEN))
 (1288 170 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (1243 10 (:REWRITE EQUAL-MINUS-MINUS))
 (1090 1090 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (1070 100 (:REWRITE INTEGERP-EXPT))
 (970 61 (:REWRITE LOGAND-BIT-0))
 (845 801 (:REWRITE DEFAULT-<-2))
 (824 801 (:REWRITE DEFAULT-<-1))
 (819 819 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (814 456 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (769 769 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (639 9 (:REWRITE EXPT-2-EQUAL-1-REWRITE))
 (621 9 (:DEFINITION =))
 (561 561 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (532 94 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (531 531 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (502 167 (:REWRITE EQUAL-1-HACK))
 (458 199 (:REWRITE DEFAULT-*-2))
 (444 199 (:REWRITE DEFAULT-*-1))
 (425 328 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (395 319 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (386 346 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (343 236 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (327 29 (:REWRITE UNSIGNED-BYTE-P--OF-MINUS))
 (313 98 (:REWRITE LOGCAR-0-REWRITE))
 (296 94 (:REWRITE FLOOR-WHEN-I-IS-NOT-AN-ACL2-NUMBERP))
 (288 17 (:REWRITE EVENP-COLLAPSE))
 (283 59 (:REWRITE INTEGERP-+-MINUS-*-4))
 (259 201 (:REWRITE DEFAULT-+-2))
 (223 99 (:REWRITE DEFAULT-UNARY-MINUS))
 (205 201 (:REWRITE DEFAULT-+-1))
 (198 9 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT))
 (184 52 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (184 30 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (175 52 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (170 170 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (170 170 (:REWRITE ASH-GOES-TO-0))
 (141 141 (:TYPE-PRESCRIPTION LOGMASKP))
 (127 26 (:REWRITE LOGCDR-<-0))
 (122 30 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (112 6 (:REWRITE <-*-0))
 (107 5 (:REWRITE 0-<-*))
 (94 94 (:REWRITE FLOOR-WHEN-J-IS-NOT-AN-ACL2-NUMBERP))
 (88 4 (:LINEAR FLOOR-BOUNDED-BY-/-BETTER))
 (87 63 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (72 8 (:LINEAR X*Y>1-POSITIVE))
 (70 2 (:LINEAR FLOOR-TYPE-2 . 2))
 (70 2 (:LINEAR FLOOR-TYPE-2 . 1))
 (68 34 (:TYPE-PRESCRIPTION |x < y  =>  0 < y-x|))
 (66 66 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (64 2 (:LINEAR FLOOR-TYPE-1 . 2))
 (64 2 (:LINEAR FLOOR-TYPE-1 . 1))
 (62 33 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (60 2 (:REWRITE LOGAND-NEG))
 (59 10 (:REWRITE LOGBITP-WHEN-I-IS-NON-POSITIVE))
 (54 3 (:REWRITE LOGCDR--))
 (47 9 (:DEFINITION IFF))
 (46 14 (:REWRITE MOVE-NEGATED-TERM-TO-OTHER-SIDE-OF-<-TERM-1-ON-LHS))
 (38 38 (:TYPE-PRESCRIPTION ZIP))
 (38 2 (:REWRITE <-1-EXPT))
 (38 2 (:LINEAR FLOOR-BOUNDED-BY-/-BETTER-2-ALT))
 (32 15 (:REWRITE BACKCHAIN-SIGNED-BYTE-P-TO-UNSIGNED-BYTE-P))
 (32 2 (:LINEAR FLOOR-BOUNDED-BY-/-BETTER-1-ALT))
 (28 28 (:REWRITE EXPT-2-POSITIVE-RATIONAL-TYPE))
 (27 27 (:TYPE-PRESCRIPTION FLOOR-TYPE-3 . 1))
 (27 27 (:TYPE-PRESCRIPTION FLOOR-TYPE-1 . 2))
 (27 27 (:TYPE-PRESCRIPTION FLOOR-TYPE-1 . 1))
 (25 25 (:REWRITE UNSIGNED-BYTE-P-LOGCAR))
 (23 23 (:REWRITE SIGNED-BYTE-P-UNSIGNED-BYTE-P))
 (21 21 (:REWRITE SBP-BOUND-1))
 (20 20 (:REWRITE EXPONENTS-ADD-FOR-NONNEG-EXPONENTS))
 (18 2 (:REWRITE COMMUTATIVITY-OF-+))
 (18 1 (:REWRITE LOGCDR-EVENP-*))
 (15 10 (:REWRITE LOGBITP-WHEN-J-IS-NOT-AN-INTEGERP))
 (14 14 (:REWRITE EQUAL-LOGAND-EXPT-REWRITE))
 (12 2 (:REWRITE LOGCDR-GREATER-THAN-0-REWRITE))
 (6 6 (:TYPE-PRESCRIPTION INTEGER-LENGTH))
 (5 5 (:REWRITE LOGBITP-WHEN-I-IS-NOT-AN-INTEGERP))
 (2 1 (:REWRITE EVENP-*))
 (1 1 (:INDUCTION SBP-INDUCTION))
 (1 1 (:INDUCTION LOGAND-INDUCTION))
 )
(LOGAND---EXPT-REWRITE
 (21 3 (:REWRITE <-+-CONSTANT-CONSTANT))
 (17 1 (:REWRITE LOGBITP-WHEN-I-IS-NON-POSITIVE))
 (16 8 (:REWRITE DEFAULT-UNARY-MINUS))
 (15 1 (:LINEAR EXPT->-1))
 (14 1 (:REWRITE LOGAND-BIT-1))
 (11 1 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (8 4 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (8 4 (:REWRITE DEFAULT-+-2))
 (8 2 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (8 1 (:REWRITE LOGAND-BIT-0))
 (6 6 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (6 6 (:REWRITE INTEGER-LENGTH-WHEN-I-IS-NOT-AN-INTEGERP))
 (6 2 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (5 3 (:REWRITE DEFAULT-<-2))
 (5 1 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (4 4 (:TYPE-PRESCRIPTION UNSIGNED-BYTE-P))
 (4 4 (:REWRITE DEFAULT-+-1))
 (3 3 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (3 3 (:REWRITE DEFAULT-<-1))
 (3 1 (:REWRITE LOGBITP-WHEN-I-IS-NOT-AN-INTEGERP))
 (3 1 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (2 2 (:TYPE-PRESCRIPTION LOGMASKP))
 (2 2 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (2 2 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (2 2 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (2 2 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (2 2 (:REWRITE EXPONENTS-ADD-FOR-NONNEG-EXPONENTS))
 (2 2 (:REWRITE EXPONENTS-ADD))
 (2 2 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (1 1 (:REWRITE LOGBITP-WHEN-J-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (1 1 (:LINEAR LOGAND-UPPER-BOUND . 1))
 )
(EQUAL-0-LOGAND-BIT
 (143 11 (:REWRITE LOGCAR-IDENTITY))
 (64 6 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (32 11 (:REWRITE LOGCAR-EVENP))
 (16 16 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (16 16 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (16 16 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (16 16 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (12 12 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (12 4 (:REWRITE LOGAND---EXPT-REWRITE))
 (11 11 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (9 6 (:REWRITE EQUAL-1-HACK))
 (7 7 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (7 7 (:REWRITE DEFAULT-<-2))
 (7 7 (:REWRITE DEFAULT-<-1))
 (6 6 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (6 6 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (3 3 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (1 1 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NOT-AN-INTEGERP))
 )
(EQUAL-BIT-LOGAND-BIT
 (149 14 (:REWRITE LOGCAR-IDENTITY))
 (105 7 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (47 14 (:REWRITE LOGCAR-EVENP))
 (20 16 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (18 18 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (18 18 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (18 18 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (18 18 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (17 14 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (12 4 (:REWRITE LOGAND---EXPT-REWRITE))
 (9 6 (:REWRITE EQUAL-1-HACK))
 (8 7 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (7 7 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (7 7 (:REWRITE DEFAULT-<-2))
 (7 7 (:REWRITE DEFAULT-<-1))
 (6 6 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (2 2 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (1 1 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NOT-AN-INTEGERP))
 )
(LOGAND-LOGAND-CONST)
(EQUAL-LOGAND-ASH-0
 (7618 24 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (7549 27 (:DEFINITION LOGMASKP*))
 (4503 270 (:REWRITE LOGCAR-IDENTITY))
 (3900 164 (:LINEAR LOGCAR-RANGE-LINEAR))
 (3606 196 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (3335 504 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (2761 26 (:REWRITE LOGAND-BIT-1))
 (2459 200 (:REWRITE EQUAL-BIT-1))
 (1639 504 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (1540 10 (:REWRITE EQUAL-0-LOGAND-BIT))
 (1532 180 (:REWRITE LOGCDR-EQUAL-0-REWRITE))
 (1264 97 (:REWRITE ZIP-OPEN))
 (1255 55 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (1032 270 (:REWRITE LOGCAR-EVENP))
 (830 36 (:REWRITE NORMALIZE-EQUAL-0))
 (818 818 (:TYPE-PRESCRIPTION |x < y  =>  0 < -x+y|))
 (724 38 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (695 9 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (676 676 (:TYPE-PRESCRIPTION LOGCAR-TYPE))
 (672 127 (:REWRITE ASH-0))
 (614 614 (:TYPE-PRESCRIPTION EVENP))
 (528 40 (:REWRITE ASH-BOUND4))
 (504 504 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (504 504 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (496 40 (:REWRITE ASH-BOUND3A))
 (489 489 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (489 98 (:REWRITE <-+-CONSTANT-CONSTANT))
 (429 360 (:REWRITE DEFAULT-<-1))
 (421 360 (:REWRITE DEFAULT-<-2))
 (418 348 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (349 47 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (347 173 (:REWRITE EQUAL-1-HACK))
 (335 302 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (318 270 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (302 29 (:REWRITE UNSIGNED-BYTE-P-ASH))
 (293 40 (:REWRITE ASH-NEGATIVE-REWRITE))
 (273 273 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (273 54 (:REWRITE EQUAL-ASH-POS-0))
 (272 200 (:REWRITE DEFAULT-+-2))
 (245 82 (:REWRITE LOGCAR-0-REWRITE))
 (228 72 (:REWRITE FOLD-CONSTS-IN-+))
 (208 11 (:DEFINITION LOGTAIL*))
 (207 127 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (206 127 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (206 123 (:REWRITE IFIX-INTEGERP))
 (200 200 (:REWRITE DEFAULT-+-1))
 (188 94 (:DEFINITION IFIX))
 (130 26 (:LINEAR X*Y>1-POSITIVE))
 (127 127 (:REWRITE ASH-GOES-TO-0))
 (126 126 (:TYPE-PRESCRIPTION LOGMASKP))
 (125 11 (:REWRITE LOGTAIL-OF-LOGCDR))
 (121 40 (:REWRITE ASH-BOUND2))
 (117 40 (:REWRITE ASH-BOUND1A))
 (94 94 (:TYPE-PRESCRIPTION |x < y  =>  0 < y-x|))
 (94 34 (:REWRITE DEFAULT-*-2))
 (72 60 (:REWRITE DEFAULT-UNARY-MINUS))
 (71 31 (:REWRITE UNSIGNED-BYTE-P-ASH-POS))
 (66 6 (:REWRITE ARITH-MOVE-NEGATED-TERM))
 (64 30 (:REWRITE UNSIGNED-BYTE-P-ASH-NEG))
 (60 54 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (55 40 (:REWRITE <=-0-ASH))
 (53 4 (:REWRITE LOGTAIL-IDENTITY))
 (49 49 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 (49 34 (:REWRITE DEFAULT-*-1))
 (48 12 (:REWRITE DISTRIBUTIVITY-OF-MINUS-OVER-+))
 (44 18 (:REWRITE LOGTAIL-WHEN-POS-IS-NOT-POSITIVE))
 (40 8 (:REWRITE COMMUTATIVITY-OF-+))
 (40 4 (:REWRITE <-1-EXPT))
 (33 27 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (33 17 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (30 18 (:REWRITE LOGTAIL-WHEN-POS-IS-NOT-AN-INTEGERP))
 (29 29 (:TYPE-PRESCRIPTION LOGBIT-TYPE))
 (28 14 (:REWRITE UNICITY-OF-0))
 (27 27 (:REWRITE SBP-BOUND-1))
 (27 17 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (27 9 (:REWRITE LOGCDR-<-0))
 (26 26 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (26 26 (:REWRITE LOGAND---EXPT-REWRITE))
 (26 26 (:REWRITE <-*-0))
 (26 4 (:REWRITE COMMUTATIVITY-OF-*))
 (25 25 (:REWRITE UNSIGNED-BYTE-P-LOGCAR))
 (24 2 (:REWRITE MOVE-NEGATED-TERM-TO-OTHER-SIDE-OF-<-TERM-2-ON-RHS))
 (22 22 (:REWRITE MINUS-CANCELLATION-ON-LEFT))
 (22 18 (:DEFINITION FIX))
 (22 11 (:REWRITE LOGTAIL-WHEN-I-IS-NOT-AN-INTEGERP))
 (21 3 (:REWRITE FALSIFY-UNSIGNED-BYTE-P))
 (12 12 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (12 4 (:REWRITE UNICITY-OF-1))
 (7 6 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (6 6 (:REWRITE EXPONENTS-ADD-FOR-NONNEG-EXPONENTS))
 (6 6 (:REWRITE EXPONENTS-ADD))
 (6 2 (:REWRITE ARITHHACK))
 (5 5 (:REWRITE EQUAL-LOGAND-EXPT-REWRITE))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NOT-AN-INTEGERP))
 (4 1 (:REWRITE *ARK*-ASH-ASH-LEFT))
 (2 1 (:REWRITE LOGBIT-WHEN-I-IS-NOT-AN-INTEGERP))
 )
(LOGAND-BFIX
 (204 12 (:LINEAR LOGCAR-RANGE-LINEAR))
 (148 22 (:REWRITE LOGCAR-IDENTITY))
 (94 22 (:REWRITE LOGCAR-EVENP))
 (66 12 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (57 57 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (48 6 (:REWRITE EQUAL-BIT-1))
 (40 22 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (36 36 (:TYPE-PRESCRIPTION EVENP))
 (36 18 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (34 12 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (30 30 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (30 30 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (30 30 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (30 30 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (30 30 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (24 12 (:REWRITE DEFAULT-<-1))
 (24 3 (:REWRITE LOGAND-BIT-0))
 (12 12 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (12 12 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (12 12 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 (12 12 (:REWRITE DEFAULT-<-2))
 (12 6 (:REWRITE EQUAL-1-HACK))
 (9 3 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (7 7 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (7 7 (:REWRITE LOGAND---EXPT-REWRITE))
 (6 6 (:TYPE-PRESCRIPTION LOGMASKP))
 (5 3 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (4 4 (:TYPE-PRESCRIPTION BITP))
 (4 4 (:TYPE-PRESCRIPTION BFIX$INLINE))
 (4 3 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (2 2 (:REWRITE EQUAL-LOGAND-EXPT-REWRITE))
 )
(*ASH*-EQUAL-LOGAND-ASH-POS-0
 (13865 39 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (13763 36 (:DEFINITION LOGMASKP*))
 (13489 455 (:DEFINITION UNSIGNED-BYTE-P*))
 (8061 396 (:REWRITE LOGCAR-IDENTITY))
 (7246 272 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (6928 246 (:LINEAR LOGCAR-RANGE-LINEAR))
 (6198 349 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (5345 1079 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (3426 238 (:REWRITE LOGCDR-EQUAL-0-REWRITE))
 (2704 222 (:REWRITE EQUAL-BIT-1))
 (2361 141 (:REWRITE LOGTAIL-IDENTITY))
 (2028 39 (:REWRITE LOGAND-BIT-1))
 (1774 1774 (:TYPE-PRESCRIPTION UNSIGNED-BYTE-P))
 (1748 39 (:REWRITE LOGAND-BIT-0))
 (1563 396 (:REWRITE LOGCAR-EVENP))
 (1458 1458 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (1317 53 (:REWRITE ZIP-OPEN))
 (1079 1079 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (1079 1079 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (1079 1079 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (996 996 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (947 947 (:TYPE-PRESCRIPTION LOGCAR-TYPE))
 (908 71 (:REWRITE ASH-0))
 (904 898 (:REWRITE DEFAULT-<-1))
 (903 16 (:REWRITE EQUAL-0-LOGAND-BIT))
 (900 898 (:REWRITE DEFAULT-<-2))
 (897 897 (:TYPE-PRESCRIPTION EVENP))
 (825 57 (:LINEAR LOGTAIL-LEQ))
 (790 15 (:REWRITE EQUAL-LOGAND-ASH-0))
 (773 742 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (671 510 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (552 14 (:REWRITE NORMALIZE-EQUAL-0))
 (546 50 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (522 482 (:REWRITE DEFAULT-+-2))
 (515 105 (:REWRITE <-+-CONSTANT-CONSTANT))
 (507 396 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (484 482 (:REWRITE DEFAULT-+-1))
 (441 186 (:REWRITE EQUAL-1-HACK))
 (424 50 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (413 19 (:REWRITE LOGTAIL-EQUAL-0))
 (407 123 (:REWRITE LOGCAR-0-REWRITE))
 (357 7 (:REWRITE LOGTAIL-UNSIGNED-BYTE-P))
 (356 356 (:TYPE-PRESCRIPTION |x < y  =>  0 < -x+y|))
 (296 12 (:REWRITE UNSIGNED-BYTE-P-ASH-POS))
 (234 19 (:REWRITE LOGTAIL-LESSP))
 (226 226 (:TYPE-PRESCRIPTION LOGTAIL-TYPE))
 (199 145 (:REWRITE LOGTAIL-WHEN-I-IS-NOT-AN-INTEGERP))
 (171 171 (:TYPE-PRESCRIPTION LOGMASKP))
 (161 150 (:REWRITE LOGTAIL-WHEN-POS-IS-NOT-AN-INTEGERP))
 (159 33 (:REWRITE LOGCDR-<-0))
 (152 16 (:REWRITE LOGBIT-WHEN-I-IS-NON-POSITIVE))
 (109 72 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (108 36 (:REWRITE ARITHHACK))
 (105 7 (:DEFINITION MAX))
 (95 72 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (84 7 (:REWRITE MOVE-NEGATED-TERM-TO-OTHER-SIDE-OF-<-TERM-2-ON-LHS))
 (83 83 (:TYPE-PRESCRIPTION |x < y  =>  0 < y-x|))
 (76 17 (:REWRITE EQUAL-ASH-POS-0))
 (74 74 (:TYPE-PRESCRIPTION ZIP))
 (72 72 (:REWRITE ASH-GOES-TO-0))
 (72 9 (:REWRITE EXPONENTS-ADD-FOR-NONNEG-EXPONENTS))
 (64 8 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (64 8 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (63 34 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (61 47 (:REWRITE DEFAULT-UNARY-MINUS))
 (61 34 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (60 60 (:TYPE-PRESCRIPTION LOGBIT-TYPE))
 (44 44 (:REWRITE SBP-BOUND-1))
 (39 39 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (39 39 (:REWRITE LOGAND---EXPT-REWRITE))
 (38 38 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (30 30 (:REWRITE UNSIGNED-BYTE-P-LOGCAR))
 (28 28 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (27 9 (:REWRITE DEFAULT-*-2))
 (24 4 (:REWRITE <=-0-ASH))
 (19 19 (:REWRITE TIMES-ZERO))
 (12 12 (:REWRITE LOGBIT-WHEN-I-IS-NOT-AN-INTEGERP))
 (9 9 (:TYPE-PRESCRIPTION EXPT-TYPE-PRESCRIPTION-INTEGERP))
 (9 9 (:TYPE-PRESCRIPTION EXPT-2-POSITIVE-RATIONAL-TYPE))
 (9 9 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (9 9 (:REWRITE EXPONENTS-ADD))
 (9 9 (:REWRITE DEFAULT-*-1))
 (8 8 (:REWRITE EQUAL-LOGAND-EXPT-REWRITE))
 (8 4 (:REWRITE UNSIGNED-BYTE-P-ASH-NEG))
 (8 4 (:REWRITE UNSIGNED-BYTE-P-ASH))
 (6 6 (:REWRITE UNSIGNED-BYTE-P-LOGBIT))
 (3 3 (:TYPE-PRESCRIPTION SUB1-LOGCDR-INDUCTION))
 (3 3 (:REWRITE MOVE-NEGATED-TERM-TO-OTHER-SIDE-OF-<-TERM-1-ON-RHS))
 )
(*ASH*-EQUAL-LOGAND---EXPT---EXPT-HELPER
 (8779 30 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (8697 30 (:DEFINITION LOGMASKP*))
 (7123 268 (:DEFINITION UNSIGNED-BYTE-P*))
 (4953 288 (:REWRITE LOGCAR-IDENTITY))
 (4526 182 (:LINEAR LOGCAR-RANGE-LINEAR))
 (4506 186 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (3521 581 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (3093 194 (:REWRITE EQUAL-BIT-1))
 (2956 168 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (2139 171 (:REWRITE LOGCDR-EQUAL-0-REWRITE))
 (1174 101 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (1030 30 (:REWRITE LOGAND-BIT-0))
 (833 833 (:TYPE-PRESCRIPTION |x < y  =>  0 < -x+y|))
 (823 19 (:REWRITE LOGTAIL-IDENTITY))
 (803 803 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (766 8 (:REWRITE EQUAL-MINUS-MINUS))
 (762 30 (:REWRITE LOGAND-BIT-1))
 (748 748 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (685 685 (:TYPE-PRESCRIPTION LOGCAR-TYPE))
 (658 596 (:REWRITE DEFAULT-<-1))
 (602 596 (:REWRITE DEFAULT-<-2))
 (589 589 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (581 581 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (581 581 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (575 575 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (515 395 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (445 166 (:REWRITE EQUAL-1-HACK))
 (431 24 (:REWRITE UNSIGNED-BYTE-P--OF-MINUS))
 (431 12 (:DEFINITION SIGNED-BYTE-P*))
 (429 390 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (357 288 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (357 6 (:REWRITE EXPT-2-EQUAL-1-REWRITE))
 (346 6 (:DEFINITION =))
 (293 91 (:REWRITE LOGCAR-0-REWRITE))
 (290 6 (:REWRITE LOGAND---EXPT))
 (264 205 (:REWRITE DEFAULT-+-2))
 (256 8 (:REWRITE LOGAND-NEG))
 (228 205 (:REWRITE DEFAULT-+-1))
 (226 143 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (220 10 (:REWRITE SIGNED-BYTE-P-OF-LOGCDR))
 (198 7 (:REWRITE LOGTAIL-LESSP))
 (196 107 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (194 11 (:REWRITE MOVE-NEGATED-TERM-TO-OTHER-SIDE-OF-<-TERM-1-ON-LHS))
 (168 32 (:REWRITE EVENP-OF-EXPT2-BETTER))
 (157 77 (:REWRITE DEFAULT-UNARY-MINUS))
 (136 8 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT))
 (130 8 (:REWRITE LOGCONS-<-0))
 (126 21 (:REWRITE LOGTAIL-WHEN-POS-IS-NOT-POSITIVE))
 (118 118 (:TYPE-PRESCRIPTION LOGMASKP))
 (111 36 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (101 11 (:REWRITE COMMUTATIVITY-OF-+))
 (100 15 (:LINEAR EXPT->-1))
 (90 27 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (82 17 (:REWRITE LOGCDR-<-0))
 (76 27 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (65 7 (:REWRITE EQUAL-BIT-LOGAND-BIT))
 (57 17 (:REWRITE UNICITY-OF-0))
 (54 54 (:TYPE-PRESCRIPTION SIGNED-BYTE-P))
 (39 39 (:REWRITE SIGNED-BYTE-P-UNSIGNED-BYTE-P))
 (39 39 (:REWRITE SIGNED-BYTE-P-SUBTYPE))
 (35 7 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (32 4 (:REWRITE EQUAL-LOGCONS-0))
 (31 31 (:REWRITE EXPT-2-POSITIVE-RATIONAL-TYPE))
 (30 30 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (30 30 (:REWRITE LOGAND---EXPT-REWRITE))
 (30 30 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (30 21 (:REWRITE LOGTAIL-WHEN-POS-IS-NOT-AN-INTEGERP))
 (30 21 (:REWRITE LOGTAIL-WHEN-I-IS-NOT-AN-INTEGERP))
 (30 6 (:LINEAR LOGTAIL-LEQ))
 (28 22 (:REWRITE BACKCHAIN-SIGNED-BYTE-P-TO-UNSIGNED-BYTE-P))
 (27 3 (:REWRITE EVENP-COLLAPSE))
 (25 15 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (24 24 (:REWRITE EXPONENTS-ADD-FOR-NONNEG-EXPONENTS))
 (22 22 (:REWRITE UNSIGNED-BYTE-P-LOGCAR))
 (21 21 (:REWRITE SBP-BOUND-1))
 (21 7 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (18 9 (:REWRITE DEFAULT-*-2))
 (12 4 (:REWRITE LOGCDR-EXPT))
 (9 9 (:REWRITE DEFAULT-*-1))
 (7 7 (:REWRITE TIMES-ZERO))
 (7 7 (:REWRITE EQUAL-LOGAND-EXPT-REWRITE))
 (3 3 (:REWRITE INTEGERP-+-MINUS-*-4))
 (2 2 (:TYPE-PRESCRIPTION |x < y  =>  0 < y-x|))
 (1 1 (:REWRITE ZIP-OPEN))
 (1 1 (:INDUCTION LOGAND-INDUCTION))
 )
(EQUAL-LOGAND---EXPT---EXPT
 (169 7 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (154 11 (:REWRITE <-+-CONSTANT-CONSTANT))
 (98 2 (:REWRITE INTEGERP-EXPT))
 (72 3 (:REWRITE LOGTAIL-IDENTITY))
 (60 12 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (51 3 (:REWRITE LOGTAIL-WHEN-POS-IS-NOT-POSITIVE))
 (44 19 (:REWRITE DEFAULT-UNARY-MINUS))
 (35 21 (:REWRITE DEFAULT-+-2))
 (31 31 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (29 7 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (29 1 (:REWRITE LOGTAIL-LESSP))
 (28 2 (:REWRITE EQUAL-MINUS-MINUS))
 (26 26 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (24 24 (:TYPE-PRESCRIPTION UNSIGNED-BYTE-P))
 (24 21 (:REWRITE DEFAULT-+-1))
 (24 3 (:REWRITE LOGAND-BIT-1))
 (24 3 (:REWRITE LOGAND-BIT-0))
 (24 2 (:REWRITE MOVE-NEGATED-TERM-TO-OTHER-SIDE-OF-<-TERM-1-ON-LHS))
 (21 14 (:REWRITE DEFAULT-<-2))
 (20 10 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (18 4 (:REWRITE EQUAL-BIT-1))
 (15 5 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (15 1 (:LINEAR EXPT->-1))
 (14 14 (:REWRITE DEFAULT-<-1))
 (12 12 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (12 12 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (12 12 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (12 12 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (11 1 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (10 4 (:REWRITE EQUAL-1-HACK))
 (9 9 (:REWRITE INTEGER-LENGTH-WHEN-I-IS-NOT-AN-INTEGERP))
 (9 3 (:REWRITE LOGTAIL-WHEN-POS-IS-NOT-AN-INTEGERP))
 (9 3 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (8 1 (:REWRITE EQUAL-BIT-LOGAND-BIT))
 (7 7 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (6 6 (:TYPE-PRESCRIPTION LOGMASKP))
 (5 5 (:REWRITE EXPONENTS-ADD-FOR-NONNEG-EXPONENTS))
 (5 5 (:REWRITE EXPONENTS-ADD))
 (4 1 (:REWRITE EVENP-COLLAPSE))
 (3 3 (:REWRITE SBP-BOUND-1))
 (3 3 (:REWRITE LOGTAIL-WHEN-I-IS-NOT-AN-INTEGERP))
 (3 3 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (3 3 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (3 3 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (3 3 (:REWRITE LOGAND---EXPT-REWRITE))
 (2 2 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (2 1 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (1 1 (:TYPE-PRESCRIPTION EVENP))
 (1 1 (:REWRITE TIMES-ZERO))
 (1 1 (:REWRITE INTEGERP-+-MINUS-*-4))
 (1 1 (:REWRITE EQUAL-LOGAND-EXPT-REWRITE))
 (1 1 (:REWRITE DEFAULT-*-2))
 (1 1 (:REWRITE DEFAULT-*-1))
 )
(LOGAND---EXPT-V2
 (26859 90 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (26633 83 (:DEFINITION LOGMASKP*))
 (23468 342 (:REWRITE ASH-0))
 (21733 160 (:REWRITE ZIP-OPEN))
 (13628 794 (:REWRITE LOGCAR-IDENTITY))
 (13074 521 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (12534 504 (:LINEAR LOGCAR-RANGE-LINEAR))
 (6455 409 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (5787 1511 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (3789 28 (:REWRITE EQUAL-MINUS-MINUS))
 (3170 296 (:REWRITE INTEGERP-EXPT))
 (3029 342 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (2368 148 (:REWRITE INTEGERP-*-1/2-EXPT))
 (2262 2262 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (2043 90 (:REWRITE LOGAND-BIT-0))
 (1781 28 (:REWRITE EXPT-2-EQUAL-1-REWRITE))
 (1728 28 (:DEFINITION =))
 (1673 154 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (1539 1539 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (1521 1399 (:REWRITE DEFAULT-<-2))
 (1511 1511 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (1487 1399 (:REWRITE DEFAULT-<-1))
 (1451 1089 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (1432 1432 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (1387 35 (:REWRITE LOGAND---EXPT))
 (1146 425 (:REWRITE EQUAL-1-HACK))
 (1021 985 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (965 51 (:REWRITE SIGNED-BYTE-P-OF-LOGCDR))
 (931 26 (:REWRITE EQUAL-0-LOGAND-BIT))
 (899 787 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (775 252 (:REWRITE LOGCAR-0-REWRITE))
 (704 29 (:DEFINITION SIGNED-BYTE-P*))
 (666 175 (:REWRITE DEFAULT-*-2))
 (571 28 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT))
 (570 479 (:REWRITE DEFAULT-+-2))
 (504 308 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (479 479 (:REWRITE DEFAULT-+-1))
 (478 66 (:REWRITE UNSIGNED-BYTE-P--OF-MINUS))
 (460 10 (:DEFINITION IFIX))
 (457 135 (:REWRITE SIGNED-BYTE-P-UNSIGNED-BYTE-P))
 (448 239 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (342 342 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (342 342 (:REWRITE ASH-GOES-TO-0))
 (295 295 (:TYPE-PRESCRIPTION LOGMASKP))
 (261 85 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (245 139 (:REWRITE DEFAULT-UNARY-MINUS))
 (236 85 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (226 14 (:REWRITE EVENP-COLLAPSE))
 (208 26 (:REWRITE COLLECT-CONSTANTS-+-LEMMA))
 (175 175 (:REWRITE DEFAULT-*-1))
 (173 14 (:REWRITE <-1-EXPT))
 (162 162 (:REWRITE INTEGERP-+-MINUS-*-4))
 (160 160 (:TYPE-PRESCRIPTION ZIP))
 (145 145 (:TYPE-PRESCRIPTION SIGNED-BYTE-P))
 (135 135 (:REWRITE SIGNED-BYTE-P-SUBTYPE))
 (132 132 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (117 66 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (98 40 (:REWRITE LOGCDR-<-0))
 (91 91 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (91 91 (:REWRITE LOGAND---EXPT-REWRITE))
 (76 58 (:REWRITE BACKCHAIN-SIGNED-BYTE-P-TO-UNSIGNED-BYTE-P))
 (75 10 (:REWRITE LOGBITP-WHEN-I-IS-NON-POSITIVE))
 (66 14 (:REWRITE FALSIFY-UNSIGNED-BYTE-P))
 (64 64 (:REWRITE EXPT-2-POSITIVE-RATIONAL-TYPE))
 (64 64 (:REWRITE EXPONENTS-ADD-FOR-NONNEG-EXPONENTS))
 (53 53 (:REWRITE UNSIGNED-BYTE-P-LOGCAR))
 (32 32 (:REWRITE SBP-BOUND-1))
 (22 2 (:REWRITE <=-0-ASH))
 (21 3 (:REWRITE ASH-EQUAL-CONSTANT))
 (17 17 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NOT-AN-INTEGERP))
 (17 17 (:REWRITE EQUAL-LOGAND-EXPT-REWRITE))
 (15 10 (:REWRITE LOGBITP-WHEN-J-IS-NOT-AN-INTEGERP))
 (12 2 (:REWRITE ASH-BOUND4A))
 (12 2 (:REWRITE ASH-BOUND3))
 (7 7 (:REWRITE MOVE-NEGATED-TERM-TO-OTHER-SIDE-OF-<-TERM-1-ON-RHS))
 (5 5 (:REWRITE LOGBITP-WHEN-I-IS-NOT-AN-INTEGERP))
 (4 2 (:REWRITE ODD-EQUAL-EXPT-CHEAP))
 (3 1 (:REWRITE BFIX-BITP))
 (2 2 (:TYPE-PRESCRIPTION BITP))
 (2 2 (:REWRITE ASH-BOUND2A))
 (2 2 (:REWRITE ASH-BOUND1))
 (1 1 (:INDUCTION UBP-INDUCTION))
 (1 1 (:INDUCTION LOGAND-INDUCTION))
 )
(LOGAND---EXPT-REWRITE-V2
 (28 2 (:REWRITE LOGAND-BIT-1))
 (24 2 (:LINEAR EXPT->-1))
 (21 3 (:REWRITE <-+-CONSTANT-CONSTANT))
 (17 1 (:REWRITE LOGBITP-WHEN-I-IS-NON-POSITIVE))
 (16 2 (:REWRITE LOGAND-BIT-0))
 (14 4 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (13 2 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (11 7 (:REWRITE DEFAULT-UNARY-MINUS))
 (8 4 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (8 4 (:REWRITE DEFAULT-+-2))
 (6 6 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (6 6 (:REWRITE INTEGER-LENGTH-WHEN-I-IS-NOT-AN-INTEGERP))
 (6 3 (:REWRITE DEFAULT-<-2))
 (6 2 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (6 2 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (4 4 (:TYPE-PRESCRIPTION LOGMASKP))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (4 4 (:REWRITE DEFAULT-+-1))
 (4 4 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (3 3 (:REWRITE DEFAULT-<-1))
 (3 1 (:REWRITE LOGBITP-WHEN-I-IS-NOT-AN-INTEGERP))
 (2 2 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (2 2 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (2 2 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (2 2 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (2 2 (:REWRITE LOGAND---EXPT-REWRITE))
 (2 2 (:REWRITE EXPONENTS-ADD-FOR-NONNEG-EXPONENTS))
 (2 2 (:REWRITE EXPONENTS-ADD))
 (1 1 (:REWRITE LOGBITP-WHEN-J-IS-NOT-AN-INTEGERP))
 (1 1 (:LINEAR LOGAND-UPPER-BOUND . 1))
 )
(EQUAL-LOGAND---EXPT-0
 (14151 54 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (14007 49 (:DEFINITION LOGMASKP*))
 (8080 445 (:REWRITE LOGCAR-IDENTITY))
 (7366 280 (:LINEAR LOGCAR-RANGE-LINEAR))
 (6951 290 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (4243 811 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (3531 262 (:REWRITE LOGCDR-EQUAL-0-REWRITE))
 (3347 246 (:REWRITE EQUAL-BIT-1))
 (1498 1203 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (1190 54 (:REWRITE LOGAND-BIT-0))
 (1088 54 (:REWRITE LOGAND-BIT-1))
 (1059 1059 (:TYPE-PRESCRIPTION LOGCAR-TYPE))
 (980 30 (:REWRITE EQUAL-0-LOGAND-BIT))
 (863 863 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (811 811 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (803 610 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (777 777 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (676 621 (:REWRITE DEFAULT-<-1))
 (646 6 (:REWRITE EQUAL-MINUS-MINUS))
 (645 621 (:REWRITE DEFAULT-<-2))
 (643 643 (:TYPE-PRESCRIPTION |x < y  =>  0 < -x+y|))
 (611 8 (:REWRITE ASH-0))
 (585 6 (:REWRITE ZIP-OPEN))
 (578 578 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (551 445 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (526 494 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (470 50 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (468 199 (:REWRITE EQUAL-1-HACK))
 (445 140 (:REWRITE LOGCAR-0-REWRITE))
 (357 6 (:REWRITE EXPT-2-EQUAL-1-REWRITE))
 (346 6 (:DEFINITION =))
 (264 41 (:REWRITE UNSIGNED-BYTE-P--OF-MINUS))
 (213 213 (:TYPE-PRESCRIPTION LOGMASKP))
 (206 50 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (203 47 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (164 38 (:REWRITE LOGCDR-<-0))
 (163 22 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (156 54 (:REWRITE DEFAULT-UNARY-MINUS))
 (137 50 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (120 18 (:LINEAR EXPT->-1))
 (118 6 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT))
 (106 84 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (82 51 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (54 54 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (54 54 (:REWRITE LOGAND---EXPT-REWRITE))
 (51 42 (:REWRITE DEFAULT-+-2))
 (42 42 (:REWRITE DEFAULT-+-1))
 (42 3 (:REWRITE EVENP-COLLAPSE))
 (41 41 (:REWRITE UNSIGNED-BYTE-P-LOGCAR))
 (41 41 (:REWRITE EXPT-2-POSITIVE-RATIONAL-TYPE))
 (36 36 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (36 12 (:REWRITE DEFAULT-*-2))
 (29 18 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (26 8 (:REWRITE FALSIFY-UNSIGNED-BYTE-P))
 (22 22 (:REWRITE EXPONENTS-ADD-FOR-NONNEG-EXPONENTS))
 (15 15 (:REWRITE EQUAL-LOGAND-EXPT-REWRITE))
 (14 8 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (12 12 (:REWRITE DEFAULT-*-1))
 (10 10 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NOT-AN-INTEGERP))
 (8 8 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (8 8 (:REWRITE ASH-GOES-TO-0))
 (6 6 (:TYPE-PRESCRIPTION ZIP))
 (6 6 (:REWRITE SBP-BOUND-1))
 (3 3 (:REWRITE INTEGERP-+-MINUS-*-4))
 (1 1 (:INDUCTION LOGAND-INDUCTION))
 )
(EQUAL-LOGAND---EXPT-0-REWRITE
 (21 5 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (21 3 (:REWRITE <-+-CONSTANT-CONSTANT))
 (16 2 (:REWRITE EQUAL-0-LOGAND-BIT))
 (15 1 (:LINEAR EXPT->-1))
 (11 1 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (9 5 (:REWRITE DEFAULT-UNARY-MINUS))
 (8 1 (:REWRITE LOGAND-BIT-1))
 (8 1 (:REWRITE LOGAND-BIT-0))
 (6 3 (:REWRITE DEFAULT-+-2))
 (5 5 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (5 5 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (5 5 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (5 5 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (5 5 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (4 4 (:REWRITE INTEGER-LENGTH-WHEN-I-IS-NOT-AN-INTEGERP))
 (4 2 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (4 2 (:REWRITE DEFAULT-<-2))
 (3 3 (:REWRITE DEFAULT-+-1))
 (3 1 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NOT-AN-INTEGERP))
 (3 1 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (3 1 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (2 2 (:TYPE-PRESCRIPTION LOGMASKP))
 (2 2 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (2 2 (:REWRITE DEFAULT-<-1))
 (2 2 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (1 1 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (1 1 (:REWRITE LOGAND---EXPT-REWRITE-V2))
 (1 1 (:REWRITE LOGAND---EXPT-REWRITE))
 (1 1 (:REWRITE EXPONENTS-ADD-FOR-NONNEG-EXPONENTS))
 (1 1 (:REWRITE EXPONENTS-ADD))
 (1 1 (:REWRITE EQUAL-LOGAND-EXPT-REWRITE))
 )
(LOGAND-LOGNOT-1)
(LOGAND-DUPLICATE-1
 (118 8 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (77 8 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (63 3 (:REWRITE LOGAND-NON-NEGATIVE))
 (54 5 (:REWRITE ZIP-OPEN))
 (48 27 (:REWRITE DEFAULT-<-1))
 (30 30 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (30 30 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (27 27 (:REWRITE DEFAULT-<-2))
 (27 6 (:REWRITE LOGAND-BIT-0))
 (20 20 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 (16 2 (:REWRITE EQUAL-0-LOGAND-BIT))
 (12 6 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (10 10 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (10 10 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (10 10 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (10 10 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (10 10 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (8 8 (:TYPE-PRESCRIPTION ZIP))
 (8 8 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (8 1 (:REWRITE LOGCAR-IDENTITY))
 (7 7 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (7 7 (:REWRITE LOGAND---EXPT-REWRITE-V2))
 (7 7 (:REWRITE LOGAND---EXPT-REWRITE))
 (7 4 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (6 6 (:TYPE-PRESCRIPTION LOGMASKP))
 (6 3 (:REWRITE LOGAND-NEG))
 (6 1 (:REWRITE LOGCAR-EVENP))
 (5 4 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (4 1 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (3 1 (:REWRITE UNSIGNED-BYTE-P-LOGAND))
 (2 2 (:REWRITE EQUAL-LOGAND-EXPT-REWRITE))
 (2 1 (:REWRITE EQUAL-LOGAND---EXPT-0-REWRITE))
 (1 1 (:TYPE-PRESCRIPTION EVENP))
 (1 1 (:REWRITE LOGAND-LOGAND-CONST))
 )
(LOGIOR-NEG-HELPER
 (90 3 (:REWRITE LOGNOT-ZIP))
 (80 3 (:REWRITE ZIP-OPEN))
 (26 2 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (26 2 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (16 2 (:REWRITE EQUAL-0-LOGAND-BIT))
 (13 13 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (13 13 (:REWRITE DEFAULT-<-2))
 (13 13 (:REWRITE DEFAULT-<-1))
 (9 9 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (8 8 (:TYPE-PRESCRIPTION UNSIGNED-BYTE-P))
 (8 1 (:REWRITE LOGAND-BIT-1))
 (8 1 (:REWRITE LOGAND-BIT-0))
 (5 5 (:TYPE-PRESCRIPTION ZIP))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (3 1 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (2 2 (:TYPE-PRESCRIPTION LOGMASKP))
 (2 2 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (2 1 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (2 1 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (2 1 (:REWRITE EQUAL-LOGAND---EXPT-0-REWRITE))
 (1 1 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (1 1 (:REWRITE LOGAND---EXPT-REWRITE-V2))
 (1 1 (:REWRITE LOGAND---EXPT-REWRITE))
 (1 1 (:REWRITE EQUAL-LOGAND-EXPT-REWRITE))
 )
(LOGIOR-NEG
 (33 25 (:REWRITE DEFAULT-<-1))
 (30 30 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (25 25 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (25 25 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (25 25 (:REWRITE DEFAULT-<-2))
 (25 15 (:REWRITE IFIX-INTEGERP))
 (6 6 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 )
(IFIX-LOGIOR
 (3 2 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (3 2 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 (2 2 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 )
(SIGNED-BYTE-P-LOGIOR
 (137 137 (:TYPE-PRESCRIPTION |x < y  =>  0 < -x+y|))
 (40 2 (:REWRITE FALSIFY-SIGNED-BYTE-P))
 (10 10 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (10 2 (:REWRITE <-+-CONSTANT-CONSTANT))
 (9 8 (:REWRITE DEFAULT-<-2))
 (9 8 (:REWRITE DEFAULT-<-1))
 (9 1 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (9 1 (:LINEAR EXPT->-1))
 (8 8 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (6 6 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (3 3 (:REWRITE SIGNED-BYTE-P-UNSIGNED-BYTE-P))
 (3 3 (:REWRITE SIGNED-BYTE-P-SUBTYPE))
 (2 2 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 (2 2 (:REWRITE BACKCHAIN-SIGNED-BYTE-P-TO-UNSIGNED-BYTE-P))
 (2 2 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (1 1 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 )
(LOGIOR-AS-B-IOR
 (162 3 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (96 6 (:LINEAR LOGCAR-RANGE-LINEAR))
 (85 13 (:REWRITE LOGCAR-IDENTITY))
 (52 13 (:REWRITE LOGCAR-EVENP))
 (34 2 (:DEFINITION LOGIOR*-BETTER))
 (29 29 (:TYPE-PRESCRIPTION EVENP))
 (27 3 (:REWRITE EQUAL-BIT-1))
 (18 18 (:TYPE-PRESCRIPTION LOGCAR-TYPE))
 (18 18 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (18 18 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (18 18 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (18 18 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (16 16 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (12 3 (:REWRITE EQUAL-1-HACK))
 (9 9 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (9 3 (:REWRITE LOGCAR-0-REWRITE))
 (7 7 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (6 6 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (6 6 (:REWRITE DEFAULT-<-2))
 (6 6 (:REWRITE DEFAULT-<-1))
 (6 4 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (6 4 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 (3 3 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NOT-AN-INTEGERP))
 (3 3 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (3 3 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 )
(LOGCONS-0-EXPT-HACK
 (9 3 (:REWRITE DEFAULT-*-2))
 (8 8 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (8 8 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (7 7 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (4 4 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (3 3 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (3 3 (:REWRITE EXPONENTS-ADD))
 (3 3 (:REWRITE DEFAULT-<-2))
 (3 3 (:REWRITE DEFAULT-<-1))
 (3 3 (:REWRITE DEFAULT-*-1))
 (3 1 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (3 1 (:REWRITE ASH-0))
 (1 1 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (1 1 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (1 1 (:REWRITE DEFAULT-+-2))
 (1 1 (:REWRITE DEFAULT-+-1))
 (1 1 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE ASH-GOES-TO-0))
 (1 1 (:REWRITE ASH-AS-LOGTAIL))
 )
(TWICE-LOGCDR-HACK
 (16 2 (:REWRITE EQUAL-BIT-1))
 (14 8 (:REWRITE DEFAULT-*-2))
 (11 11 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (10 6 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (8 8 (:REWRITE DEFAULT-*-1))
 (8 2 (:REWRITE ASH-0))
 (7 7 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (7 7 (:REWRITE COMBINE-CONSTANTS-IN-EQUAL-OF-TIMES))
 (4 4 (:TYPE-PRESCRIPTION ZIP))
 (4 4 (:TYPE-PRESCRIPTION UNSIGNED-BYTE-P))
 (4 2 (:REWRITE EQUAL-1-HACK))
 (2 2 (:REWRITE ZIP-OPEN))
 (2 2 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (2 2 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (2 2 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (2 2 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (2 2 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (2 2 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (2 2 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (2 2 (:REWRITE ASH-GOES-TO-0))
 (2 2 (:REWRITE ASH-AS-LOGTAIL))
 )
(LOGBITP-OF-LOGCDR
 (520 19 (:REWRITE FLOOR-SIMPLE-CASES))
 (497 19 (:REWRITE RTL1))
 (497 19 (:REWRITE FLOOR-DETERMINED-1))
 (404 18 (:REWRITE FLOOR-=-X/Y . 3))
 (345 3 (:LINEAR FLOOR-BOUNDED-BY-/-BETTER-2-ALT))
 (324 3 (:LINEAR FLOOR-BOUNDED-BY-/-BETTER-1-ALT))
 (315 6 (:LINEAR FLOOR-BOUNDED-BY-/-BETTER))
 (306 65 (:REWRITE <-*-/-LEFT-COMMUTED))
 (204 30 (:REWRITE EVENP-COLLAPSE))
 (180 180 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (141 75 (:REWRITE DEFAULT-*-2))
 (137 48 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (133 18 (:REWRITE FLOOR-=-X/Y . 2))
 (112 95 (:REWRITE DEFAULT-<-1))
 (109 95 (:REWRITE DEFAULT-<-2))
 (108 30 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (106 36 (:REWRITE FOLD-CONSTS-IN-*))
 (104 22 (:REWRITE COMMUTATIVITY-OF-*))
 (98 4 (:REWRITE INTEGERP-/))
 (83 18 (:REWRITE FLOOR-TYPE-4 . 3))
 (81 16 (:REWRITE FLOOR-OF-INTEGER-BY-1))
 (81 3 (:LINEAR FLOOR-TYPE-2 . 1))
 (79 75 (:REWRITE DEFAULT-*-1))
 (78 17 (:REWRITE <-*-/-RIGHT-COMMUTED))
 (74 40 (:REWRITE INTEGERP-+-MINUS-*-4))
 (68 3 (:REWRITE INTEGERP-PROD-OF-3-FIRST-TWO))
 (67 18 (:REWRITE FLOOR-TYPE-3 . 3))
 (67 18 (:REWRITE FLOOR-TYPE-3 . 2))
 (65 18 (:REWRITE FLOOR-TYPE-4 . 2))
 (56 56 (:TYPE-PRESCRIPTION FLOOR-TYPE-3 . 1))
 (56 56 (:TYPE-PRESCRIPTION FLOOR-TYPE-1 . 2))
 (56 56 (:TYPE-PRESCRIPTION FLOOR-TYPE-1 . 1))
 (42 4 (:REWRITE /R-WHEN-ABS-NUMERATOR=1))
 (37 3 (:REWRITE INTEGERP-*-1/2*X*EXPT-BRIDGE))
 (36 2 (:REWRITE EVENP-*))
 (30 30 (:TYPE-PRESCRIPTION EVENP))
 (29 21 (:REWRITE FLOOR-WHEN-J-IS-NOT-AN-ACL2-NUMBERP))
 (26 21 (:REWRITE FLOOR-WHEN-I-IS-NOT-AN-ACL2-NUMBERP))
 (24 3 (:LINEAR FLOOR-TYPE-2 . 2))
 (22 7 (:REWRITE DEFAULT-+-2))
 (20 5 (:LINEAR EXPT->-1))
 (20 2 (:REWRITE COMMUTATIVITY-2-OF-*))
 (18 3 (:LINEAR FLOOR-TYPE-1 . 1))
 (16 5 (:REWRITE EQUAL-BIT-1))
 (15 3 (:REWRITE *-PRESERVES->-FOR-NONNEGATIVES-1))
 (14 3 (:REWRITE X*Y>1-POSITIVE-LEMMA))
 (10 10 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (10 5 (:REWRITE EXPT-2-EQUAL-1-REWRITE))
 (10 2 (:REWRITE DEFAULT-UNARY-/))
 (8 1 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT))
 (7 7 (:REWRITE DEFAULT-+-1))
 (5 5 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (5 5 (:DEFINITION =))
 (4 4 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (3 3 (:TYPE-PRESCRIPTION |x < y  =>  0 < -x+y|))
 (3 3 (:REWRITE INTEGERP-PROD-3))
 (3 3 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (3 3 (:LINEAR FLOOR-TYPE-1 . 2))
 (3 1 (:REWRITE NUMERATOR-WHEN-INTEGERP))
 (1 1 (:TYPE-PRESCRIPTION UNSIGNED-BYTE-P))
 (1 1 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (1 1 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (1 1 (:REWRITE SBP-BOUND-1))
 )
(LOGBIT-OF-LOGCDR
 (6 2 (:REWRITE LOGBIT-WHEN-I-IS-NON-POSITIVE))
 (5 5 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (4 2 (:REWRITE LOGBITP-WHEN-J-IS-NOT-AN-INTEGERP))
 (4 2 (:REWRITE LOGBIT-WHEN-I-IS-NOT-AN-INTEGERP))
 (2 2 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (2 2 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (2 2 (:REWRITE LOGBITP-WHEN-I-IS-NOT-AN-INTEGERP))
 (2 2 (:REWRITE LOGBITP-WHEN-I-IS-NON-POSITIVE))
 (2 2 (:REWRITE DEFAULT-<-2))
 (2 2 (:REWRITE DEFAULT-<-1))
 (2 2 (:REWRITE DEFAULT-+-2))
 (2 2 (:REWRITE DEFAULT-+-1))
 (2 1 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (1 1 (:TYPE-PRESCRIPTION LOGCDR-TYPE))
 )
(LOGBITP-OF-LOGCDR2
 (101 11 (:REWRITE LOGCAR-IDENTITY))
 (72 9 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (60 55 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (40 2 (:LINEAR LOGCAR-RANGE-LINEAR))
 (36 19 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (36 18 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (35 5 (:REWRITE <-+-CONSTANT-CONSTANT))
 (26 10 (:REWRITE INTEGERP-SUM-TAKE-OUT-KNOWN-INTEGER))
 (24 17 (:REWRITE DEFAULT-<-2))
 (22 22 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (22 22 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (22 11 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (19 17 (:REWRITE DEFAULT-<-1))
 (18 18 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (18 10 (:REWRITE LOGBITP-WHEN-J-IS-NOT-AN-INTEGERP))
 (15 15 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 (9 9 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (9 9 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (9 9 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (9 9 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (9 6 (:REWRITE DEFAULT-+-2))
 (8 5 (:REWRITE INTEGERP-+-MINUS-*-2))
 (8 5 (:DEFINITION FIX))
 (6 6 (:REWRITE DEFAULT-+-1))
 (5 5 (:REWRITE SBP-BOUND-1))
 (5 5 (:REWRITE RATIONALP-+))
 (5 5 (:REWRITE MOVE-NEGATED-TERM-TO-OTHER-SIDE-OF-<-TERM-1-ON-LHS))
 (5 5 (:REWRITE INTEGERP-SUM-OF-ODDS-OVER-2-LEADING-CONSTANT))
 )
(EQUAL-LOGIOR-SINGLE-BIT
 (119153 274 (:REWRITE LOGCDR-LOGNOT))
 (115652 186 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (115140 171 (:DEFINITION LOGMASKP*))
 (80256 6955 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (78848 28 (:REWRITE LOGCDR-LOGAND))
 (38413 186 (:REWRITE LOGIOR-AS-B-IOR))
 (27051 342 (:REWRITE CANCEL-EQUAL-LOGNOT . 2))
 (19296 64 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (18962 18962 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (17760 268 (:REWRITE LOGCAR-LOGNOT))
 (11963 11963 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (11958 11958 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (11499 367 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (10371 6162 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (9404 5526 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (8357 7455 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (8294 187 (:REWRITE LOGAND---EXPT-REWRITE))
 (7065 10 (:DEFINITION SIGNED-BYTE-P*))
 (4815 186 (:REWRITE LOGAND-BIT-1))
 (4423 982 (:REWRITE LOGCDR-<-0))
 (3770 3770 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (3730 295 (:REWRITE LOGNOT-NEG))
 (3424 24 (:REWRITE BACKCHAIN-SIGNED-BYTE-P-TO-UNSIGNED-BYTE-P))
 (3155 2584 (:REWRITE DEFAULT-<-1))
 (2810 186 (:REWRITE LOGAND-BIT-0))
 (2614 2584 (:REWRITE DEFAULT-<-2))
 (1944 101 (:LINEAR LOGIOR-BND-ERIC-LINEAR))
 (1432 8 (:REWRITE LOGCDR-LOGIOR))
 (1295 74 (:REWRITE EQUAL-0-LOGAND-BIT))
 (1162 14 (:REWRITE LOGCAR-LOGAND))
 (1092 64 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (928 10 (:REWRITE SIGNED-BYTE-P-LOGOPS))
 (927 39 (:REWRITE LOGCONS-<-0))
 (920 17 (:REWRITE UNSIGNED-BYTE-P-LOGIOR))
 (819 187 (:REWRITE LOGAND---EXPT-REWRITE-V2))
 (815 815 (:TYPE-PRESCRIPTION LOGMASKP))
 (749 14 (:REWRITE UNSIGNED-BYTE-P-LOGAND))
 (688 4 (:REWRITE SIGNED-BYTE-P-OF-LOGCDR))
 (585 27 (:REWRITE LOGIOR-NEG))
 (494 42 (:REWRITE EVENP-OF-LOGCONS))
 (406 14 (:REWRITE LOGAND-NEG))
 (360 180 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (358 180 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (314 158 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (314 158 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 (257 150 (:REWRITE DEFAULT-+-2))
 (203 187 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (160 32 (:REWRITE EVENP-+-ALT))
 (150 150 (:REWRITE DEFAULT-+-1))
 (140 16 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (114 59 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (102 43 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (91 57 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (72 37 (:REWRITE EQUAL-LOGAND---EXPT-0-REWRITE))
 (62 62 (:TYPE-PRESCRIPTION SIGNED-BYTE-P))
 (56 54 (:REWRITE INTEGER-LENGTH-WHEN-I-IS-NOT-AN-INTEGERP))
 (37 37 (:REWRITE EQUAL-LOGAND-EXPT-REWRITE))
 (35 20 (:REWRITE LOGBITP-WHEN-J-IS-NOT-AN-INTEGERP))
 (32 32 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (32 16 (:REWRITE DEFAULT-UNARY-MINUS))
 (32 8 (:REWRITE EVENP-OF-LOGCAR))
 (30 30 (:REWRITE SIGNED-BYTE-P-UNSIGNED-BYTE-P))
 (30 30 (:REWRITE SIGNED-BYTE-P-SUBTYPE))
 (22 9 (:REWRITE LOGBITP-WHEN-I-IS-NOT-AN-INTEGERP))
 (20 5 (:REWRITE EVENP-COLLAPSE))
 (19 11 (:REWRITE DEFAULT-*-2))
 (16 16 (:REWRITE SBP-BOUND-1))
 (16 16 (:REWRITE EXPONENTS-ADD-FOR-NONNEG-EXPONENTS))
 (11 11 (:REWRITE DEFAULT-*-1))
 (7 7 (:REWRITE INTEGERP-+-MINUS-*-4))
 (3 3 (:TYPE-PRESCRIPTION LOGCDR-LOGCDR-LOGCDR-INDUCTION))
 (2 2 (:REWRITE COMBINE-CONSTANTS-IN-EQUAL-OF-TIMES))
 )
(LOGIOR-LOGIOR-CONST)
(EQUAL-LOGIOR-CONST-CONST
 (3243 137 (:REWRITE LOGCAR-IDENTITY))
 (3053 182 (:DEFINITION UNSIGNED-BYTE-P*))
 (2445 155 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (1413 56 (:REWRITE LOGIOR-AS-B-IOR))
 (1109 358 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (592 141 (:REWRITE LOGCAR-EVENP))
 (513 513 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (453 90 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (384 326 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (358 358 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (358 358 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (358 358 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (303 25 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (250 250 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (235 235 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (229 229 (:REWRITE DEFAULT-<-2))
 (229 229 (:REWRITE DEFAULT-<-1))
 (217 152 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (203 137 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (133 7 (:REWRITE LOGIOR-NEG))
 (115 70 (:REWRITE EQUAL-1-HACK))
 (106 56 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (100 56 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 (100 20 (:REWRITE LOGCDR-<-0))
 (44 12 (:REWRITE EQUAL-LOGIOR-SINGLE-BIT))
 (25 25 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (24 8 (:TYPE-PRESCRIPTION EXPT-TYPE-PRESCRIPTION-INTEGERP))
 (21 1 (:REWRITE LOGCONS-<-0))
 (19 19 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (16 8 (:TYPE-PRESCRIPTION |x < y  =>  0 < -x+y|))
 (8 8 (:TYPE-PRESCRIPTION INTEGER-LENGTH))
 (8 8 (:TYPE-PRESCRIPTION EXPT-2-POSITIVE-RATIONAL-TYPE))
 (4 4 (:REWRITE ZIP-OPEN))
 (3 3 (:TYPE-PRESCRIPTION LOGCDR-LOGCDR-LOGCDR-INDUCTION))
 )
(EQUAL-LOGIOR-*2
 (495 27 (:DEFINITION UNSIGNED-BYTE-P*))
 (474 19 (:REWRITE LOGCAR-IDENTITY))
 (372 22 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (271 10 (:REWRITE LOGIOR-AS-B-IOR))
 (180 56 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (90 90 (:TYPE-PRESCRIPTION LOGCDR-TYPE))
 (82 19 (:REWRITE LOGCAR-EVENP))
 (78 78 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (56 56 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (56 56 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (56 56 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (55 47 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (47 11 (:REWRITE LOGCDR-EQUAL-0-REWRITE))
 (33 25 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (33 11 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (30 30 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (30 30 (:REWRITE DEFAULT-<-2))
 (30 30 (:REWRITE DEFAULT-<-1))
 (29 29 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (27 19 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (22 11 (:REWRITE EQUAL-BIT-1))
 (18 9 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (18 9 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 (14 11 (:REWRITE EQUAL-1-HACK))
 (6 6 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (4 4 (:REWRITE EQUAL-LOGIOR-SINGLE-BIT))
 (4 4 (:REWRITE DEFAULT-*-2))
 (4 4 (:REWRITE DEFAULT-*-1))
 (1 1 (:REWRITE COMBINE-CONSTANTS-IN-EQUAL-OF-TIMES))
 )
(LOGIOR-EXPT-ASH-LOGHEAD-BRIDGE-HELPER
 (14896 350 (:DEFINITION UNSIGNED-BYTE-P*))
 (13151 612 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (10390 170 (:REWRITE LOGHEAD-IDENTITY))
 (7150 54 (:DEFINITION LOGHEAD*))
 (5377 951 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (5043 239 (:REWRITE LOGCAR-IDENTITY))
 (4908 44 (:REWRITE LOGIOR-AS-B-IOR))
 (3105 140 (:REWRITE SIGNED-BYTE-P-OF-LOGCDR))
 (2484 40 (:REWRITE ASH-0))
 (2353 86 (:DEFINITION SIGNED-BYTE-P*))
 (2076 2076 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (2017 65 (:REWRITE LOGCDR-EQUAL-0-REWRITE))
 (1977 45 (:REWRITE EQUAL-LOGHEAD-0-SBP))
 (1687 1599 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (1566 45 (:REWRITE EQUAL-LOGHEAD-0-SBP-V2))
 (1380 1343 (:REWRITE DEFAULT-<-2))
 (1347 1343 (:REWRITE DEFAULT-<-1))
 (1337 1293 (:REWRITE DEFAULT-+-2))
 (1311 175 (:REWRITE LOGHEAD-WHEN-SIZE-IS-NOT-POSITIVE))
 (1303 1293 (:REWRITE DEFAULT-+-1))
 (1300 951 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (1205 926 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (1038 65 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (1035 987 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (988 988 (:TYPE-PRESCRIPTION LOGCDR-TYPE))
 (951 951 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (710 49 (:REWRITE INTEGERP-*-1/4-EXPT))
 (609 273 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (518 158 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (434 434 (:TYPE-PRESCRIPTION SIGNED-BYTE-P))
 (424 239 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (422 24 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT))
 (366 366 (:REWRITE SIGNED-BYTE-P-UNSIGNED-BYTE-P))
 (366 366 (:REWRITE SIGNED-BYTE-P-SUBTYPE))
 (360 8 (:REWRITE COMBINE-CONSTANTS-IN-EQUAL-OF-TIMES))
 (338 170 (:REWRITE LOGHEAD-WHEN-I-IS-NOT-AN-INTEGERP))
 (324 6 (:REWRITE UNSIGNED-BYTE-P-+))
 (320 112 (:REWRITE EQUAL-1-HACK))
 (306 18 (:REWRITE UNSIGNED-BYTE-P-1+))
 (294 34 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 (293 49 (:REWRITE ASH-GOES-TO-0))
 (291 5 (:REWRITE LOGHEAD-OF-SUM-WITH-CONSTANT))
 (279 175 (:REWRITE LOGHEAD-WHEN-SIZE-IS-NOT-AN-INTEGERP))
 (272 80 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (254 1 (:REWRITE LOGCDR-ASH))
 (208 104 (:REWRITE MINUS-CANCELLATION-ON-LEFT))
 (205 200 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (181 12 (:REWRITE LOGCAR-LOGHEAD-BETTER))
 (172 172 (:REWRITE BACKCHAIN-SIGNED-BYTE-P-TO-UNSIGNED-BYTE-P))
 (144 144 (:REWRITE SBP-BOUND-1))
 (138 11 (:REWRITE LOGCAR-EXPT))
 (132 44 (:REWRITE ARITHHACK))
 (130 122 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (121 14 (:REWRITE LOGCDR-EVENP-*))
 (114 6 (:REWRITE UNSIGNED-BYTE-P-+-EASY))
 (112 24 (:REWRITE UNSIGNED-BYTE-P-LOGHEAD-BETTER))
 (112 21 (:REWRITE LOGHEAD-<))
 (105 35 (:REWRITE DEFAULT-*-2))
 (105 11 (:REWRITE ZP-OPEN))
 (98 49 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (95 49 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (92 9 (:LINEAR LOGHEAD-LEQ))
 (90 18 (:REWRITE EQUAL-LOGCONS-0))
 (90 6 (:REWRITE UNSIGNED-BYTE-P-WHEN-ADDING-BIG-POWER-OF-2-CONSTANT-VERSION))
 (75 17 (:REWRITE LOGCDR-<-0))
 (75 5 (:REWRITE LOGHEAD-+-EXPT-CONSTANT-VERSION))
 (70 34 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (68 4 (:REWRITE B-XOR-REWRITE))
 (67 67 (:REWRITE LOGHEAD-SUBST2))
 (67 67 (:REWRITE LOGHEAD-SUBST))
 (66 1 (:REWRITE LOGCAR-ASH-BOTH))
 (55 11 (:REWRITE <-1-EXPT))
 (51 1 (:REWRITE LOGBIT-WHEN-I-IS-NON-POSITIVE))
 (50 28 (:REWRITE SIMPLIFY-BIT-FUNCTIONS))
 (49 49 (:REWRITE INTEGERP-+-MINUS-*-4))
 (49 13 (:REWRITE LOGCDR-LOGHEAD))
 (46 31 (:TYPE-PRESCRIPTION |x < y  =>  0 < y-x|))
 (45 36 (:REWRITE DEFAULT-UNARY-MINUS))
 (40 40 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (40 12 (:REWRITE B-NOT-OPEN-1))
 (39 39 (:TYPE-PRESCRIPTION ZIP))
 (35 35 (:REWRITE DEFAULT-*-1))
 (33 1 (:REWRITE LOGTAIL-OF-LOGCDR))
 (28 17 (:REWRITE BFIX-BITP))
 (25 5 (:REWRITE COMMUTATIVITY-OF-+))
 (23 23 (:TYPE-PRESCRIPTION POWER2P))
 (23 23 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (22 11 (:REWRITE UNSIGNED-BYTE-P-SHIFT-BY-CONSTANT-POWER-OF-2))
 (19 19 (:REWRITE EVENP-*))
 (18 18 (:REWRITE LOGCAR-OF-TIMES))
 (18 9 (:REWRITE LOGTAIL-WHEN-POS-IS-NOT-AN-INTEGERP))
 (18 7 (:REWRITE EVENP-+-ALT))
 (17 1 (:DEFINITION LOGTAIL*))
 (16 8 (:REWRITE ODD-EQUAL-EXPT-CHEAP))
 (16 8 (:REWRITE BFIX-B-FUNCTIONS))
 (15 15 (:REWRITE LOGHEAD-OF-SUM-INTEGER-AND-NON-INTEGER))
 (14 14 (:REWRITE LOGCDR-*-X-EXPT-BRIDGE))
 (8 2 (:REWRITE EVENP-OF-LOGCAR))
 (7 7 (:REWRITE MOVE-NEGATED-TERM-TO-OTHER-SIDE-OF-<-TERM-1-ON-RHS))
 (6 6 (:REWRITE EQUAL-LOGIOR-SINGLE-BIT))
 (5 5 (:REWRITE LOGHEAD-WHEN-I-IS-0))
 (5 5 (:REWRITE LOGHEAD-SUM-SUBST-HELPER))
 (5 5 (:REWRITE LOGHEAD-SUM-SUBST-ALT))
 (5 5 (:REWRITE LOGHEAD-SUM-SUBST))
 (5 5 (:REWRITE LOGHEAD-SUM-CHOP-FIRST-ARG-WHEN-CONSTANT))
 (5 5 (:REWRITE LOGHEAD-+-REDUCE))
 (2 1 (:REWRITE LOGTAIL-WHEN-I-IS-NOT-AN-INTEGERP))
 )
(LOGIOR-EXPT-ASH-LOGHEAD-BRIDGE
 (501 9 (:REWRITE ASH-0))
 (435 8 (:REWRITE ZIP-OPEN))
 (146 1 (:REWRITE NORMALIZE-EQUAL-0))
 (125 9 (:REWRITE ASH-AS-LOGTAIL))
 (120 17 (:REWRITE <-+-CONSTANT-CONSTANT))
 (115 67 (:REWRITE DEFAULT-+-2))
 (95 1 (:REWRITE EQUAL-BIT-1))
 (86 6 (:REWRITE EQUAL-LOGHEAD-0-SBP-V2))
 (85 9 (:REWRITE ASH-GOES-TO-0))
 (83 33 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (82 67 (:REWRITE DEFAULT-+-1))
 (80 8 (:REWRITE SIGNED-BYTE-P-OF-LOGCDR))
 (77 49 (:REWRITE DEFAULT-<-2))
 (73 5 (:REWRITE LOGHEAD-+-EXPT-CONSTANT-VERSION))
 (69 69 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (68 6 (:REWRITE EQUAL-LOGHEAD-0-SBP))
 (66 6 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (60 36 (:REWRITE LOGHEAD-WHEN-SIZE-IS-NOT-POSITIVE))
 (57 49 (:REWRITE DEFAULT-<-1))
 (55 21 (:REWRITE DEFAULT-*-2))
 (53 53 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (52 44 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (47 39 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (44 20 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (44 1 (:REWRITE UNSIGNED-BYTE-P-+))
 (42 36 (:REWRITE LOGHEAD-WHEN-I-IS-NOT-AN-INTEGERP))
 (41 41 (:REWRITE LOGHEAD-SUBST2))
 (41 41 (:REWRITE LOGHEAD-SUBST))
 (36 36 (:REWRITE LOGHEAD-WHEN-SIZE-IS-NOT-AN-INTEGERP))
 (35 35 (:REWRITE LOGHEAD-OF-SUM-INTEGER-AND-NON-INTEGER))
 (35 33 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (34 9 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (33 33 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (33 1 (:REWRITE UNSIGNED-BYTE-P-+-EASY))
 (32 4 (:REWRITE LOGIOR-AS-B-IOR))
 (32 4 (:REWRITE LOGCAR-IDENTITY))
 (26 3 (:LINEAR LOGHEAD-LEQ))
 (24 24 (:TYPE-PRESCRIPTION SIGNED-BYTE-P))
 (23 9 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (22 10 (:REWRITE FOLD-CONSTS-IN-+))
 (22 1 (:REWRITE ARITH-MOVE-NEGATED-TERM))
 (21 21 (:REWRITE EXPONENTS-ADD))
 (21 21 (:REWRITE DEFAULT-*-1))
 (20 20 (:REWRITE SIGNED-BYTE-P-UNSIGNED-BYTE-P))
 (20 20 (:REWRITE SIGNED-BYTE-P-SUBTYPE))
 (20 20 (:REWRITE INTEGER-LENGTH-WHEN-I-IS-NOT-AN-INTEGERP))
 (19 6 (:REWRITE DEFAULT-UNARY-MINUS))
 (16 4 (:REWRITE EVENP-COLLAPSE))
 (13 13 (:REWRITE UNSIGNED-BYTE-P-1+))
 (13 9 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (13 3 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (12 12 (:REWRITE BACKCHAIN-SIGNED-BYTE-P-TO-UNSIGNED-BYTE-P))
 (12 2 (:REWRITE LOGHEAD-<=))
 (12 1 (:REWRITE DISTRIBUTIVITY-OF-MINUS-OVER-+))
 (11 2 (:REWRITE UNSIGNED-BYTE-P-SHIFT-BY-CONSTANT-POWER-OF-2))
 (9 9 (:TYPE-PRESCRIPTION LOGCDR-TYPE))
 (9 1 (:REWRITE DIFFERENCE-UNSIGNED-BYTE-P))
 (8 8 (:TYPE-PRESCRIPTION ZIP))
 (8 4 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (8 2 (:TYPE-PRESCRIPTION |x < y  =>  0 < y-x|))
 (6 6 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (6 3 (:REWRITE ODD-EQUAL-EXPT-CHEAP))
 (5 5 (:REWRITE LOGHEAD-SUM-CHOP-FIRST-ARG-WHEN-CONSTANT))
 (5 1 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT))
 (5 1 (:REWRITE LOGCDR-<-0))
 (4 4 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 (4 4 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (4 4 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (4 4 (:REWRITE INTEGERP-+-MINUS-*-4))
 (4 1 (:REWRITE FUNCTIONAL-SELF-INVERSION-OF-MINUS))
 (3 3 (:REWRITE SBP-BOUND-1))
 (3 1 (:DEFINITION FIX))
 (2 2 (:REWRITE MOVE-NEGATED-TERM-TO-OTHER-SIDE-OF-<-TERM-1-ON-LHS))
 (1 1 (:REWRITE UNSIGNED-BYTE-P-WHEN-ADDING-BIG-POWER-OF-2-CONSTANT-VERSION))
 (1 1 (:REWRITE MOVE-NEGATED-TERM-TO-OTHER-SIDE-OF-<-TERM-1-ON-RHS))
 (1 1 (:REWRITE INTEGER-LENGTH-<-1-REWRITE))
 (1 1 (:REWRITE IFIX-INTEGERP))
 (1 1 (:REWRITE EQUAL-LOGIOR-SINGLE-BIT))
 (1 1 (:REWRITE EQUAL-CONSTANT-+))
 (1 1 (:REWRITE COMBINE-CONSTANTS-IN-EQUAL-OF-TIMES))
 )
(LOGIOR-EXPT-ASH-LOGHEAD-BRIDGE-BRIDGE
 (302 5 (:REWRITE ASH-0))
 (230 5 (:REWRITE ZIP-OPEN))
 (116 17 (:REWRITE <-+-CONSTANT-CONSTANT))
 (85 43 (:REWRITE DEFAULT-+-2))
 (78 5 (:REWRITE ASH-AS-LOGTAIL))
 (60 4 (:REWRITE LOGHEAD-+-EXPT-CONSTANT-VERSION))
 (55 43 (:REWRITE DEFAULT-+-1))
 (51 5 (:REWRITE ASH-GOES-TO-0))
 (50 5 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (46 27 (:REWRITE DEFAULT-<-2))
 (46 16 (:REWRITE DEFAULT-*-2))
 (44 44 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (43 31 (:REWRITE LOGHEAD-WHEN-SIZE-IS-NOT-POSITIVE))
 (41 41 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (40 36 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (38 3 (:REWRITE EQUAL-LOGHEAD-0-SBP-V2))
 (37 33 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (36 5 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (35 35 (:REWRITE LOGHEAD-SUBST2))
 (35 35 (:REWRITE LOGHEAD-SUBST))
 (34 31 (:REWRITE LOGHEAD-WHEN-I-IS-NOT-AN-INTEGERP))
 (33 33 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (33 5 (:REWRITE LOGIOR-AS-B-IOR))
 (33 3 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (32 32 (:REWRITE LOGHEAD-OF-SUM-INTEGER-AND-NON-INTEGER))
 (32 27 (:REWRITE DEFAULT-<-1))
 (31 31 (:REWRITE LOGHEAD-WHEN-SIZE-IS-NOT-AN-INTEGERP))
 (26 26 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (26 26 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (26 26 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (26 3 (:REWRITE EQUAL-LOGHEAD-0-SBP))
 (26 3 (:LINEAR LOGHEAD-LEQ))
 (25 4 (:REWRITE LOGCAR-IDENTITY))
 (20 2 (:REWRITE SIGNED-BYTE-P-OF-LOGCDR))
 (18 3 (:REWRITE INTEGER-LENGTH-<-1-REWRITE))
 (17 17 (:REWRITE EXPONENTS-ADD))
 (16 16 (:REWRITE DEFAULT-*-1))
 (14 5 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (13 7 (:REWRITE FOLD-CONSTS-IN-+))
 (13 4 (:REWRITE LOGCAR-EVENP))
 (13 3 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (12 12 (:TYPE-PRESCRIPTION SIGNED-BYTE-P))
 (12 12 (:REWRITE UNSIGNED-BYTE-P-1+))
 (12 6 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (12 5 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (12 4 (:REWRITE DEFAULT-UNARY-MINUS))
 (10 10 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (8 8 (:REWRITE SIGNED-BYTE-P-UNSIGNED-BYTE-P))
 (8 8 (:REWRITE SIGNED-BYTE-P-SUBTYPE))
 (7 6 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (6 6 (:TYPE-PRESCRIPTION LOGCDR-TYPE))
 (6 6 (:REWRITE INTEGER-LENGTH-WHEN-I-IS-NOT-AN-INTEGERP))
 (6 6 (:REWRITE BACKCHAIN-SIGNED-BYTE-P-TO-UNSIGNED-BYTE-P))
 (5 5 (:TYPE-PRESCRIPTION ZIP))
 (5 5 (:TYPE-PRESCRIPTION ASH))
 (5 5 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 (5 1 (:REWRITE LOGCDR-<-0))
 (4 4 (:REWRITE LOGHEAD-SUM-CHOP-FIRST-ARG-WHEN-CONSTANT))
 (4 4 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (4 2 (:REWRITE ODD-EQUAL-EXPT-CHEAP))
 (4 1 (:REWRITE EVENP-COLLAPSE))
 (2 2 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (1 1 (:REWRITE SBP-BOUND-1))
 (1 1 (:REWRITE MOVE-NEGATED-TERM-TO-OTHER-SIDE-OF-<-TERM-1-ON-RHS))
 (1 1 (:REWRITE LOGIOR-LOGIOR-CONST))
 (1 1 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE INTEGERP-+-MINUS-*-4))
 (1 1 (:REWRITE EQUAL-LOGIOR-SINGLE-BIT))
 )
(LOGIOR-AS-+
 (10296 32 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (10208 30 (:DEFINITION LOGMASKP*))
 (9260 423 (:DEFINITION UNSIGNED-BYTE-P*))
 (7766 398 (:REWRITE LOGCAR-IDENTITY))
 (5878 224 (:LINEAR LOGCAR-RANGE-LINEAR))
 (5798 271 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (5452 311 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (4195 917 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (2762 232 (:REWRITE LOGCDR-EQUAL-0-REWRITE))
 (2207 227 (:REWRITE EQUAL-BIT-1))
 (1259 1259 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (1125 32 (:REWRITE LOGIOR-AS-B-IOR))
 (917 917 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (917 917 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (917 917 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (830 22 (:REWRITE EQUAL-0-LOGAND-BIT))
 (766 766 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (693 686 (:REWRITE DEFAULT-<-1))
 (689 502 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (686 686 (:REWRITE DEFAULT-<-2))
 (673 623 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (664 664 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (534 398 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (468 196 (:REWRITE EQUAL-1-HACK))
 (442 34 (:REWRITE LOGAND---EXPT-REWRITE))
 (433 50 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (367 19 (:LINEAR LOGIOR-BND-ERIC-LINEAR))
 (339 11 (:REWRITE BACKCHAIN-SIGNED-BYTE-P-TO-UNSIGNED-BYTE-P))
 (337 2 (:REWRITE SIGNED-BYTE-P-OF-LOGCDR))
 (279 6 (:DEFINITION SIGNED-BYTE-P*))
 (278 34 (:REWRITE LOGAND---EXPT-REWRITE-V2))
 (266 58 (:REWRITE LOGCDR-<-0))
 (156 2 (:REWRITE B-NOT-OPEN-1))
 (146 146 (:TYPE-PRESCRIPTION LOGMASKP))
 (118 14 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (106 14 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (80 1 (:REWRITE UNSIGNED-BYTE-P--OF-MINUS))
 (73 55 (:REWRITE DEFAULT-+-2))
 (73 55 (:REWRITE DEFAULT-+-1))
 (54 34 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (49 28 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (49 28 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (48 28 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 (48 28 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (45 15 (:TYPE-PRESCRIPTION EXPT-TYPE-PRESCRIPTION-INTEGERP))
 (34 19 (:TYPE-PRESCRIPTION |x < y  =>  0 < -x+y|))
 (30 30 (:REWRITE UNSIGNED-BYTE-P-LOGCAR))
 (27 27 (:TYPE-PRESCRIPTION SIGNED-BYTE-P))
 (20 11 (:REWRITE EQUAL-LOGAND---EXPT-0-REWRITE))
 (15 15 (:TYPE-PRESCRIPTION INTEGER-LENGTH))
 (15 15 (:TYPE-PRESCRIPTION EXPT-2-POSITIVE-RATIONAL-TYPE))
 (15 15 (:REWRITE DEFAULT-*-2))
 (15 15 (:REWRITE DEFAULT-*-1))
 (14 14 (:REWRITE SIGNED-BYTE-P-UNSIGNED-BYTE-P))
 (14 14 (:REWRITE SIGNED-BYTE-P-SUBTYPE))
 (14 14 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (12 1 (:REWRITE LOGCDR-EVENP-*))
 (11 11 (:REWRITE EQUAL-LOGAND-EXPT-REWRITE))
 (11 1 (:REWRITE 0-<-*))
 (10 10 (:REWRITE EQUAL-LOGIOR-SINGLE-BIT))
 (7 1 (:REWRITE <-+-CONSTANT-CONSTANT))
 (7 1 (:REWRITE <-*-0))
 (6 2 (:DEFINITION IFF))
 (5 1 (:REWRITE FOLD-CONSTS-IN-*))
 (4 4 (:TYPE-PRESCRIPTION |x < y  =>  0 < y-x|))
 (2 2 (:REWRITE FOLD-CONSTS-IN-+))
 (2 1 (:REWRITE UNICITY-OF-1))
 (1 1 (:REWRITE SBP-BOUND-1))
 (1 1 (:REWRITE MOVE-NEGATED-TERM-TO-OTHER-SIDE-OF-<-TERM-1-ON-RHS))
 (1 1 (:REWRITE LOGCAR-OF-TIMES))
 (1 1 (:REWRITE DEFAULT-UNARY-MINUS))
 )
(+-LOGIOR-ASH
 (88 1 (:REWRITE UNSIGNED-BYTE-P-+-EASY))
 (63 4 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (45 28 (:REWRITE DEFAULT-+-2))
 (34 28 (:REWRITE DEFAULT-+-1))
 (22 22 (:TYPE-PRESCRIPTION |x < y  =>  0 < -x+y|))
 (21 4 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (17 17 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (15 5 (:REWRITE <-+-CONSTANT-CONSTANT))
 (14 4 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (13 11 (:REWRITE DEFAULT-<-1))
 (12 2 (:LINEAR EXPT->-1))
 (12 1 (:REWRITE UNSIGNED-BYTE-P-+))
 (11 11 (:REWRITE DEFAULT-<-2))
 (11 1 (:REWRITE EXPT-IS-WEAKLY-INCREASING-FOR-BASE>1))
 (10 10 (:REWRITE FOLD-CONSTS-IN-+))
 (9 2 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (6 2 (:REWRITE ASH-AS-LOGTAIL))
 (5 2 (:REWRITE ASH-0))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (4 4 (:REWRITE LOGAND---EXPT-REWRITE-V2))
 (4 4 (:LINEAR EXPT-IS-INCREASING-FOR-BASE>1))
 (4 1 (:REWRITE EXPT-IS-INCREASING-FOR-BASE>1))
 (3 3 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (3 2 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (2 2 (:TYPE-PRESCRIPTION ZIP))
 (2 2 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NOT-AN-INTEGERP))
 (2 2 (:REWRITE SBP-BOUND-1))
 (2 2 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (2 2 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (2 2 (:REWRITE ASH-GOES-TO-0))
 (2 1 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE ZIP-OPEN))
 (1 1 (:REWRITE UNSIGNED-BYTE-P-WHEN-ADDING-BIG-POWER-OF-2-CONSTANT-VERSION))
 (1 1 (:REWRITE EXPT-IS-WEAKLY-DECREASING-FOR-POS-BASE<1))
 (1 1 (:REWRITE EXPT-IS-DECREASING-FOR-POS-BASE<1))
 (1 1 (:REWRITE EXPONENTS-ADD-FOR-NONNEG-EXPONENTS))
 (1 1 (:REWRITE EXPONENTS-ADD))
 )
(+-LOGIOR-ASH-V2
 (139 74 (:REWRITE DEFAULT-+-2))
 (112 11 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (101 74 (:REWRITE DEFAULT-+-1))
 (82 1 (:REWRITE UNSIGNED-BYTE-P-+-EASY))
 (32 12 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (29 28 (:REWRITE EXPT-WITH-VIOLATED-GUARDS))
 (25 25 (:REWRITE FOLD-CONSTS-IN-+))
 (24 24 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (24 15 (:REWRITE ASH-0))
 (23 3 (:REWRITE EXPT-IS-WEAKLY-INCREASING-FOR-BASE>1))
 (20 11 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (18 17 (:REWRITE EXPT-WHEN-I-IS-NOT-AN-INTEGERP))
 (17 15 (:REWRITE DEFAULT-<-1))
 (16 16 (:REWRITE ASH-AS-LOGTAIL))
 (16 8 (:REWRITE DEFAULT-UNARY-MINUS))
 (15 15 (:REWRITE DEFAULT-<-2))
 (15 15 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (15 15 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (15 15 (:REWRITE ASH-GOES-TO-0))
 (11 11 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (11 11 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (9 9 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NOT-AN-INTEGERP))
 (9 9 (:REWRITE ASH-1-WHEN-C-IS-NEGATIVE))
 (9 3 (:REWRITE DEFAULT-*-2))
 (8 8 (:REWRITE LOGHEAD-SUM-SPLIT-INTO-2-WHEN-I-IS-A-CONSTANT))
 (8 8 (:REWRITE LOGHEAD-SUM-CHOP-FIRST-ARG-WHEN-CONSTANT))
 (8 8 (:REWRITE LOGHEAD-SUBST2))
 (8 8 (:REWRITE LOGHEAD-SUBST))
 (8 8 (:REWRITE LOGHEAD-+-EXPT-CONSTANT-VERSION))
 (8 7 (:LINEAR EXPT-LESS-THAN-1-HACK))
 (6 6 (:TYPE-PRESCRIPTION ZIP))
 (6 6 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (6 3 (:REWRITE EXPT-IS-INCREASING-FOR-BASE>1))
 (4 4 (:REWRITE UNSIGNED-BYTE-P-WHEN-ADDING-BIG-POWER-OF-2-CONSTANT-VERSION))
 (4 4 (:REWRITE SBP-BOUND-1))
 (4 4 (:REWRITE LOGAND---EXPT-REWRITE-V2))
 (4 4 (:REWRITE EXPONENTS-ADD))
 (4 4 (:REWRITE EQUAL-CONSTANT-+))
 (3 3 (:REWRITE ZIP-OPEN))
 (3 3 (:REWRITE EXPT-IS-WEAKLY-DECREASING-FOR-POS-BASE<1))
 (3 3 (:REWRITE EXPT-IS-DECREASING-FOR-POS-BASE<1))
 (3 3 (:REWRITE DEFAULT-*-1))
 (1 1 (:REWRITE LOGHEAD-WHEN-SIZE-IS-NOT-POSITIVE))
 (1 1 (:REWRITE LOGHEAD-WHEN-SIZE-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE LOGHEAD-WHEN-I-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE LOGHEAD-SUM-SUBST-HELPER))
 (1 1 (:REWRITE LOGHEAD-SUM-SUBST-ALT))
 (1 1 (:REWRITE LOGHEAD-SUM-SUBST))
 (1 1 (:REWRITE LOGHEAD-OF-SUM-WITH-CONSTANT))
 (1 1 (:REWRITE LOGHEAD-IDENTITY))
 (1 1 (:REWRITE LOGHEAD-+-REDUCE))
 )
(LOGIOR-LOGNOT
 (3143 140 (:DEFINITION UNSIGNED-BYTE-P*))
 (3089 178 (:REWRITE LOGCAR-IDENTITY))
 (3038 118 (:LINEAR LOGCAR-RANGE-LINEAR))
 (2514 126 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (1809 271 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (1510 21 (:REWRITE B-NOT-OPEN-1))
 (1368 2 (:REWRITE LOGCDR-LOGNOT))
 (497 24 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (424 15 (:REWRITE LOGIOR-AS-B-IOR))
 (334 22 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (297 297 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (271 271 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (271 271 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (271 271 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (258 207 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (254 254 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (228 223 (:REWRITE DEFAULT-<-1))
 (227 178 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (223 223 (:REWRITE DEFAULT-<-2))
 (204 96 (:REWRITE EQUAL-1-HACK))
 (196 196 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (182 2 (:REWRITE LOGCAR-LOGNOT))
 (165 152 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (164 164 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (155 19 (:REWRITE LOGNOT-NEG))
 (153 2 (:REWRITE EVENP-OF-LOGCONS))
 (142 12 (:LINEAR LOGIOR-BND-ERIC-LINEAR))
 (97 21 (:REWRITE LOGCDR-<-0))
 (93 5 (:REWRITE LOGIOR-NEG))
 (72 7 (:REWRITE LOGCONS-<-0))
 (26 2 (:REWRITE ASH-0))
 (25 5 (:REWRITE EQUAL-LOGIOR-SINGLE-BIT))
 (22 22 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (15 5 (:TYPE-PRESCRIPTION EXPT-TYPE-PRESCRIPTION-INTEGERP))
 (13 7 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 (12 7 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (10 5 (:TYPE-PRESCRIPTION |x < y  =>  0 < -x+y|))
 (6 3 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (5 5 (:TYPE-PRESCRIPTION INTEGER-LENGTH))
 (5 5 (:TYPE-PRESCRIPTION EXPT-2-POSITIVE-RATIONAL-TYPE))
 (4 2 (:DEFINITION IFIX))
 (3 3 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (3 3 (:REWRITE ASH-GOES-TO-0))
 )
(LOGOR-LOGNOT-1)
(LOGIOR-DUPLICATE
 (350 11 (:REWRITE LOGIOR-AS-B-IOR))
 (338 17 (:DEFINITION UNSIGNED-BYTE-P*))
 (195 11 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (176 32 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (164 21 (:REWRITE LOGCAR-IDENTITY))
 (88 7 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (68 68 (:TYPE-PRESCRIPTION UNSIGNED-BYTE-P))
 (52 21 (:REWRITE LOGCAR-EVENP))
 (43 43 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (42 6 (:LINEAR LOGCAR-RANGE-LINEAR))
 (33 6 (:REWRITE LOGCDR-EQUAL-0-REWRITE))
 (32 32 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (32 32 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (32 32 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (23 23 (:TYPE-PRESCRIPTION EVENP))
 (18 18 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (18 18 (:REWRITE DEFAULT-<-2))
 (18 18 (:REWRITE DEFAULT-<-1))
 (15 15 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (15 6 (:REWRITE EQUAL-1-HACK))
 (14 9 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (12 6 (:REWRITE EQUAL-BIT-1))
 (9 3 (:REWRITE LOGCAR-0-REWRITE))
 (6 6 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (6 3 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (6 3 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 (4 2 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (2 2 (:REWRITE ZIP-OPEN))
 (2 2 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 (2 2 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (1 1 (:REWRITE EQUAL-LOGIOR-SINGLE-BIT))
 )
(LOGIOR-DUPLICATE-1
 (81 6 (:LINEAR LOGIOR-BND-ERIC-LINEAR))
 (80 17 (:REWRITE LOGIOR-AS-B-IOR))
 (25 17 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (24 2 (:REWRITE LOGIOR-NEG))
 (22 22 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (18 18 (:TYPE-PRESCRIPTION UNSIGNED-BYTE-P))
 (13 13 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (13 9 (:REWRITE DEFAULT-<-1))
 (12 12 (:TYPE-PRESCRIPTION IFIX))
 (10 10 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (9 9 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (9 9 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (9 9 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (9 9 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (9 9 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (9 9 (:REWRITE DEFAULT-<-2))
 (3 3 (:REWRITE LOGIOR-LOGIOR-CONST))
 (3 3 (:REWRITE EQUAL-LOGIOR-SINGLE-BIT))
 (2 2 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 )
(LOGNOT-LOGAND
 (32013 1295 (:DEFINITION UNSIGNED-BYTE-P*))
 (28086 1536 (:REWRITE LOGCAR-IDENTITY))
 (26143 1110 (:REWRITE EQUAL-LOGCDR-CONSTANT-BRIDGE))
 (24725 149 (:REWRITE LOGNOT-ZIP))
 (22728 866 (:REWRITE LOGCDR-EQUAL-0-REWRITE))
 (16867 1041 (:REWRITE UNSIGNED-BYTE-P-OF-LOGCDR))
 (16494 39 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (16384 36 (:DEFINITION LOGMASKP*))
 (12543 2730 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (11524 8 (:REWRITE LOGCDR-LOGAND))
 (8128 133 (:REWRITE B-NOT-OPEN-1))
 (7896 695 (:REWRITE EQUAL-BIT-1))
 (6802 36 (:REWRITE LOGIOR-AS-B-IOR))
 (6129 1536 (:REWRITE LOGCAR-EVENP))
 (3807 3807 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (3259 3259 (:TYPE-PRESCRIPTION EVENP))
 (2730 2730 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (2730 2730 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (2730 2730 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (2680 1824 (:REWRITE EVENP-WHEN-NOT-INTEGERP))
 (2319 1536 (:REWRITE LOGCAR-WHEN-I-IS-NOT-AN-INTEGERP))
 (2140 2140 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (2123 553 (:REWRITE LOGCAR-0-REWRITE))
 (2062 659 (:REWRITE EQUAL-1-HACK))
 (1960 1881 (:REWRITE DEFAULT-<-1))
 (1881 1881 (:REWRITE DEFAULT-<-2))
 (1868 47 (:REWRITE CANCEL-EQUAL-LOGNOT . 2))
 (1839 1839 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (1770 1588 (:REWRITE LOGCDR-WHEN-I-IS-NOT-AN-INTEGERP))
 (1668 12 (:REWRITE EQUAL-K-B-AND))
 (1644 24 (:DEFINITION ZBP$INLINE))
 (1179 244 (:REWRITE LOGCDR-<-0))
 (1102 36 (:REWRITE EQUAL-0-LOGAND-BIT))
 (990 89 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (799 68 (:REWRITE LOGNOT-NEG))
 (540 8 (:REWRITE LOGCAR-LOGAND))
 (449 41 (:REWRITE LOGAND---EXPT-REWRITE))
 (432 39 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (406 14 (:LINEAR LOGIOR-BND-ERIC-LINEAR))
 (384 39 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (337 2 (:REWRITE SIGNED-BYTE-P-OF-LOGCDR))
 (324 8 (:REWRITE BACKCHAIN-SIGNED-BYTE-P-TO-UNSIGNED-BYTE-P))
 (285 41 (:REWRITE LOGAND---EXPT-REWRITE-V2))
 (255 15 (:REWRITE LOGCONS-<-0))
 (228 4 (:DEFINITION SIGNED-BYTE-P*))
 (206 9 (:REWRITE EVENP-OF-LOGCONS))
 (179 179 (:TYPE-PRESCRIPTION LOGMASKP))
 (89 89 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (66 36 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (65 36 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (61 41 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (52 28 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 (50 28 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (45 15 (:TYPE-PRESCRIPTION EXPT-TYPE-PRESCRIPTION-INTEGERP))
 (38 2 (:REWRITE LOGAND-NEG))
 (36 36 (:REWRITE UNSIGNED-BYTE-P-LOGCAR))
 (34 18 (:REWRITE EQUAL-LOGAND---EXPT-0-REWRITE))
 (30 15 (:TYPE-PRESCRIPTION |x < y  =>  0 < -x+y|))
 (27 9 (:REWRITE ASH-0))
 (24 1 (:REWRITE LOGAND-=-MINUS-1))
 (20 20 (:TYPE-PRESCRIPTION SIGNED-BYTE-P))
 (19 19 (:REWRITE EQUAL-LOGAND-EXPT-REWRITE))
 (15 15 (:TYPE-PRESCRIPTION INTEGER-LENGTH))
 (15 15 (:TYPE-PRESCRIPTION EXPT-2-POSITIVE-RATIONAL-TYPE))
 (11 11 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (10 10 (:REWRITE SIGNED-BYTE-P-UNSIGNED-BYTE-P))
 (10 10 (:REWRITE SIGNED-BYTE-P-SUBTYPE))
 (9 9 (:REWRITE ASH-WHEN-I-IS-NOT-AN-INTEGERP))
 (9 9 (:REWRITE ASH-WHEN-C-IS-NOT-AN-INTEGERP))
 (9 9 (:REWRITE ASH-GOES-TO-0))
 (7 7 (:REWRITE EQUAL-LOGIOR-SINGLE-BIT))
 (1 1 (:REWRITE IFIX-LOGAND))
 (1 1 (:INDUCTION LOGIOR-INDUCTION))
 )
(LOGNAND-REWRITE
 (54 2 (:LINEAR LOGIOR-BND-ERIC-LINEAR))
 (32 4 (:REWRITE LOGNOT-NEG))
 (10 4 (:REWRITE LOGNOT-ZIP))
 (9 2 (:REWRITE LOGIOR-AS-B-IOR))
 (8 8 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (8 8 (:REWRITE DEFAULT-<-2))
 (8 8 (:REWRITE DEFAULT-<-1))
 (8 1 (:REWRITE LOGAND-BIT-1))
 (8 1 (:REWRITE LOGAND-BIT-0))
 (6 6 (:TYPE-PRESCRIPTION UNSIGNED-BYTE-P))
 (6 6 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (4 4 (:TYPE-PRESCRIPTION ZIP))
 (4 2 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (4 2 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 (3 3 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (3 3 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (3 3 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (3 3 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (3 3 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (3 1 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (2 2 (:TYPE-PRESCRIPTION LOGMASKP))
 (2 2 (:REWRITE ZIP-OPEN))
 (2 2 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (1 1 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (1 1 (:REWRITE LOGAND---EXPT-REWRITE-V2))
 (1 1 (:REWRITE LOGAND---EXPT-REWRITE))
 )
(LOGNOR-REWRITE
 (36 4 (:REWRITE LOGNOT-NEG))
 (26 2 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (26 2 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (10 4 (:REWRITE LOGNOT-ZIP))
 (9 2 (:REWRITE LOGAND-BIT-1))
 (9 2 (:REWRITE LOGAND-BIT-0))
 (8 8 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (8 8 (:REWRITE DEFAULT-<-2))
 (8 8 (:REWRITE DEFAULT-<-1))
 (8 1 (:REWRITE LOGIOR-AS-B-IOR))
 (6 6 (:TYPE-PRESCRIPTION UNSIGNED-BYTE-P))
 (4 4 (:TYPE-PRESCRIPTION ZIP))
 (4 4 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (4 2 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (4 2 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (4 2 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (3 3 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (3 3 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (3 3 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (3 3 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (3 3 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (2 2 (:TYPE-PRESCRIPTION LOGMASKP))
 (2 2 (:REWRITE ZIP-OPEN))
 (2 2 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (2 2 (:REWRITE LOGAND---EXPT-REWRITE-V2))
 (2 2 (:REWRITE LOGAND---EXPT-REWRITE))
 (2 2 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (1 1 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (1 1 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 )
(LOGEQV-REWRITE
 (192 2 (:LINEAR LOGIOR-BND-ERIC-LINEAR))
 (124 9 (:REWRITE LOGIOR-AS-B-IOR))
 (99 15 (:REWRITE LOGAND-BIT-1))
 (99 15 (:REWRITE LOGAND-BIT-0))
 (80 80 (:TYPE-PRESCRIPTION UNSIGNED-BYTE-P))
 (68 6 (:REWRITE LOGAND-NEG))
 (64 4 (:REWRITE UNSIGNED-BYTE-P-LOGAND))
 (54 2 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (54 2 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (48 8 (:REWRITE LOGNOT-NEG))
 (39 39 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (39 39 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (39 39 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (39 39 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (39 39 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (35 15 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (30 2 (:REWRITE UNSIGNED-BYTE-P-LOGIOR))
 (29 29 (:TYPE-PRESCRIPTION BINARY-LOGAND))
 (20 20 (:TYPE-PRESCRIPTION LOGMASKP))
 (19 14 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (19 14 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (17 17 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (17 17 (:REWRITE LOGAND---EXPT-REWRITE-V2))
 (17 17 (:REWRITE LOGAND---EXPT-REWRITE))
 (16 4 (:REWRITE LOGNOT-ZIP))
 (15 9 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (15 9 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 (10 10 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (10 10 (:REWRITE DEFAULT-<-2))
 (10 10 (:REWRITE DEFAULT-<-1))
 (8 8 (:TYPE-PRESCRIPTION ZIP))
 (8 8 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (4 4 (:REWRITE ZIP-OPEN))
 (2 2 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 )
(LOGXOR-REWRITE
 (208 2 (:LINEAR LOGIOR-BND-ERIC-LINEAR))
 (117 9 (:REWRITE LOGIOR-AS-B-IOR))
 (89 18 (:REWRITE LOGAND-BIT-0))
 (87 18 (:REWRITE LOGAND-BIT-1))
 (76 2 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (70 70 (:TYPE-PRESCRIPTION UNSIGNED-BYTE-P))
 (64 4 (:REWRITE UNSIGNED-BYTE-P-LOGAND))
 (58 6 (:REWRITE LOGAND-NEG))
 (58 2 (:LINEAR LOGAND-UPPER-BOUND . 1))
 (50 8 (:REWRITE LOGNOT-ZIP))
 (34 34 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (34 34 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (34 34 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (34 34 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (34 34 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (34 18 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (34 6 (:REWRITE LOGNOT-NEG))
 (32 4 (:REWRITE ZIP-OPEN))
 (30 2 (:REWRITE UNSIGNED-BYTE-P-LOGIOR))
 (27 17 (:REWRITE LOGAND-WHEN-J-IS-NOT-AN-INTEGERP))
 (26 17 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (20 20 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (20 20 (:REWRITE LOGAND---EXPT-REWRITE-V2))
 (20 20 (:REWRITE LOGAND---EXPT-REWRITE))
 (18 2 (:REWRITE CANCEL-EQUAL-LOGNOT . 2))
 (16 16 (:TYPE-PRESCRIPTION LOGMASKP))
 (16 9 (:REWRITE LOGIOR-WHEN-J-IS-NOT-AN-INTEGERP))
 (15 9 (:REWRITE LOGIOR-WHEN-I-IS-NOT-AN-INTEGERP))
 (14 14 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (14 14 (:REWRITE DEFAULT-<-2))
 (14 14 (:REWRITE DEFAULT-<-1))
 (12 12 (:REWRITE REMOVE-REDUNDANT-<=-HYPS))
 (12 2 (:REWRITE EQUAL-NEGATION-SAME-SIGN))
 (6 6 (:TYPE-PRESCRIPTION ZIP))
 (2 2 (:REWRITE MOVE---TO-CONSTANT-IN-EQUAL))
 (2 2 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (2 2 (:REWRITE IFIX-INTEGERP))
 )
(LOGAND-UPPER-BOUND-ERIC
 (46 5 (:REWRITE LOGAND-BIT-0))
 (40 5 (:REWRITE LOGAND-BIT-1))
 (20 20 (:TYPE-PRESCRIPTION UNSIGNED-BYTE-P))
 (16 10 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-TWO))
 (15 5 (:REWRITE LOGAND-WITH-MASK-ERIC))
 (13 7 (:REWRITE DEFAULT-<-1))
 (13 3 (:LINEAR LOGAND-UPPER-BOUND . 2))
 (10 10 (:TYPE-PRESCRIPTION LOGMASKP))
 (10 10 (:REWRITE UNSIGNED-BYTE-P-WHEN-N-IS-NON-POSITIVE))
 (10 10 (:REWRITE UNSIGNED-BYTE-P-SUBTYPE))
 (10 10 (:REWRITE UNSIGNED-BYTE-P-REWRITES-TO-LOWER-BOUND-WHEN-WE-KNOW-UPPER-BOUND-ONE))
 (10 10 (:REWRITE UNSIGNED-BYTE-P-OF-EXPT-CONST-VERSION))
 (9 9 (:REWRITE REMOVE-REDUNDANT-LESS-THANS))
 (9 9 (:REWRITE INTEGERP-*-CONSTANT-MEANS-1))
 (9 7 (:REWRITE DEFAULT-<-2))
 (8 4 (:REWRITE LOGAND-WHEN-I-IS-NOT-AN-INTEGERP))
 (6 6 (:REWRITE RATIONALP-IMPLIES-ACL2-NUMBERP))
 (5 5 (:REWRITE LOGAND-EXPT-CONSTANT-VERSION))
 (5 5 (:REWRITE LOGAND---EXPT-REWRITE-V2))
 (5 5 (:REWRITE LOGAND---EXPT-REWRITE))
 (2 2 (:TYPE-PRESCRIPTION EXPT-TYPE-PRESCRIPTION-INTEGERP))
 (2 2 (:TYPE-PRESCRIPTION EXPT-2-POSITIVE-RATIONAL-TYPE))
 )
