updated SMT2 certificates

--- a/src/HOL/SMT_Examples/SMT_Examples.certs	Thu Mar 13 15:54:41 2014 +0100
+++ b/src/HOL/SMT_Examples/SMT_Examples.certs	Thu Mar 13 16:17:14 2014 +0100
@@ -2065,3 +2065,404 @@
 #247 := [asserted]: #123
 [unit-resolution #247 #607]: false
 unsat
+c4f4c8220660d1979009b33a643f0927bee816b1 1 0
+unsat
+db6426d59fdd57da8ca5d11de399761d1f1443de 1 0
+unsat
+e7ef76d73ccb9bc09d2b5368495a7a59d1bae3dc 1 0
+unsat
+8578dab7bf88c7d119f9af2e5f7eaf948f1bdb87 84 0
+WARNING: failed to find a pattern for quantifier (quantifier id: k!10)
+#2 := false
+#8 := 0::Int
+#7 := (:var 0 Int)
+#49 := (<= #7 0::Int)
+#50 := (not #49)
+#47 := (>= #7 0::Int)
+#45 := (not #47)
+#53 := (or #45 #50)
+#56 := (forall (vars (?v0 Int)) #53)
+#525 := (not #56)
+#218 := (<= 0::Int 0::Int)
+#539 := (not #218)
+#207 := (>= 0::Int 0::Int)
+#201 := (not #207)
+#537 := (or #201 #539)
+#526 := (or #525 #537)
+#170 := (iff #526 #525)
+#527 := (or #525 false)
+#530 := (iff #527 #525)
+#169 := [rewrite]: #530
+#164 := (iff #526 #527)
+#523 := (iff #537 false)
+#182 := (or false false)
+#185 := (iff #182 false)
+#522 := [rewrite]: #185
+#183 := (iff #537 #182)
+#178 := (iff #539 false)
+#1 := true
+#543 := (not true)
+#222 := (iff #543 false)
+#544 := [rewrite]: #222
+#194 := (iff #539 #543)
+#198 := (iff #218 true)
+#535 := [rewrite]: #198
+#536 := [monotonicity #535]: #194
+#520 := [trans #536 #544]: #178
+#534 := (iff #201 false)
+#538 := (iff #201 #543)
+#541 := (iff #207 true)
+#542 := [rewrite]: #541
+#326 := [monotonicity #542]: #538
+#193 := [trans #326 #544]: #534
+#184 := [monotonicity #193 #520]: #183
+#524 := [trans #184 #522]: #523
+#528 := [monotonicity #524]: #164
+#531 := [trans #528 #169]: #170
+#521 := [quant-inst #8]: #526
+#529 := [mp #521 #531]: #525
+#69 := (~ #56 #56)
+#67 := (~ #53 #53)
+#68 := [refl]: #67
+#70 := [nnf-pos #68]: #69
+#10 := (< 0::Int #7)
+#9 := (< #7 0::Int)
+#11 := (or #9 #10)
+#12 := (forall (vars (?v0 Int)) #11)
+#13 := (if #12 false true)
+#14 := (not #13)
+#59 := (iff #14 #56)
+#57 := (iff #12 #56)
+#54 := (iff #11 #53)
+#51 := (iff #10 #50)
+#52 := [rewrite]: #51
+#46 := (iff #9 #45)
+#48 := [rewrite]: #46
+#55 := [monotonicity #48 #52]: #54
+#58 := [quant-intro #55]: #57
+#43 := (iff #14 #12)
+#35 := (not #12)
+#38 := (not #35)
+#41 := (iff #38 #12)
+#42 := [rewrite]: #41
+#39 := (iff #14 #38)
+#36 := (iff #13 #35)
+#37 := [rewrite]: #36
+#40 := [monotonicity #37]: #39
+#44 := [trans #40 #42]: #43
+#60 := [trans #44 #58]: #59
+#34 := [asserted]: #14
+#61 := [mp #34 #60]: #56
+#63 := [mp~ #61 #70]: #56
+[unit-resolution #63 #529]: false
+unsat
+252d255c564463d916bc68156eea8dbe7fb0be0a 165 0
+WARNING: failed to find a pattern for quantifier (quantifier id: k!10)
+#2 := false
+#7 := 0::Int
+#8 := (:var 0 Int)
+#55 := (<= #8 0::Int)
+#56 := (not #55)
+#52 := (>= #8 0::Int)
+#51 := (not #52)
+#59 := (or #51 #56)
+#62 := (forall (vars (?v0 Int)) #59)
+#95 := (not #62)
+#587 := (<= 0::Int 0::Int)
+#586 := (not #587)
+#585 := (>= 0::Int 0::Int)
+#248 := (not #585)
+#593 := (or #248 #586)
+#290 := (or #95 #593)
+#569 := (iff #290 #95)
+#292 := (or #95 false)
+#572 := (iff #292 #95)
+#287 := [rewrite]: #572
+#293 := (iff #290 #292)
+#576 := (iff #593 false)
+#578 := (or false false)
+#575 := (iff #578 false)
+#579 := [rewrite]: #575
+#300 := (iff #593 #578)
+#201 := (iff #586 false)
+#1 := true
+#594 := (not true)
+#592 := (iff #594 false)
+#595 := [rewrite]: #592
+#306 := (iff #586 #594)
+#304 := (iff #587 true)
+#305 := [rewrite]: #304
+#307 := [monotonicity #305]: #306
+#577 := [trans #307 #595]: #201
+#581 := (iff #248 false)
+#589 := (iff #248 #594)
+#233 := (iff #585 true)
+#234 := [rewrite]: #233
+#249 := [monotonicity #234]: #589
+#582 := [trans #249 #595]: #581
+#301 := [monotonicity #582 #577]: #300
+#580 := [trans #301 #579]: #576
+#571 := [monotonicity #580]: #293
+#573 := [trans #571 #287]: #569
+#291 := [quant-inst #7]: #290
+#570 := [mp #291 #573]: #95
+decl z3name!0 :: bool
+#92 := z3name!0
+#15 := 3::Int
+#39 := -1::Int
+#99 := (if z3name!0 -1::Int 3::Int)
+#284 := (= #99 3::Int)
+#604 := (not #284)
+#602 := (>= #99 3::Int)
+#259 := (not #602)
+#102 := (<= #99 0::Int)
+#65 := (if #62 -1::Int 3::Int)
+#71 := (<= #65 0::Int)
+#103 := (~ #71 #102)
+#100 := (= #65 #99)
+#97 := (~ #62 z3name!0)
+#88 := (or z3name!0 #95)
+#93 := (not z3name!0)
+#94 := (or #93 #62)
+#89 := (and #94 #88)
+#96 := [intro-def]: #89
+#98 := [apply-def #96]: #97
+#101 := [monotonicity #98]: #100
+#104 := [monotonicity #101]: #103
+#13 := 1::Int
+#14 := (- 1::Int)
+#10 := (< 0::Int #8)
+#9 := (< #8 0::Int)
+#11 := (or #9 #10)
+#12 := (forall (vars (?v0 Int)) #11)
+#16 := (if #12 #14 3::Int)
+#17 := (< 0::Int #16)
+#18 := (not #17)
+#84 := (iff #18 #71)
+#42 := (if #12 -1::Int 3::Int)
+#45 := (< 0::Int #42)
+#48 := (not #45)
+#82 := (iff #48 #71)
+#72 := (not #71)
+#77 := (not #72)
+#80 := (iff #77 #71)
+#81 := [rewrite]: #80
+#78 := (iff #48 #77)
+#75 := (iff #45 #72)
+#68 := (< 0::Int #65)
+#73 := (iff #68 #72)
+#74 := [rewrite]: #73
+#69 := (iff #45 #68)
+#66 := (= #42 #65)
+#63 := (iff #12 #62)
+#60 := (iff #11 #59)
+#57 := (iff #10 #56)
+#58 := [rewrite]: #57
+#53 := (iff #9 #51)
+#54 := [rewrite]: #53
+#61 := [monotonicity #54 #58]: #60
+#64 := [quant-intro #61]: #63
+#67 := [monotonicity #64]: #66
+#70 := [monotonicity #67]: #69
+#76 := [trans #70 #74]: #75
+#79 := [monotonicity #76]: #78
+#83 := [trans #79 #81]: #82
+#49 := (iff #18 #48)
+#46 := (iff #17 #45)
+#43 := (= #16 #42)
+#40 := (= #14 -1::Int)
+#41 := [rewrite]: #40
+#44 := [monotonicity #41]: #43
+#47 := [monotonicity #44]: #46
+#50 := [monotonicity #47]: #49
+#85 := [trans #50 #83]: #84
+#38 := [asserted]: #18
+#86 := [mp #38 #85]: #71
+#133 := [mp~ #86 #104]: #102
+#389 := (not #102)
+#596 := (or #259 #389)
+#270 := [th-lemma arith farkas 1 1]: #596
+#271 := [unit-resolution #270 #133]: #259
+#603 := [hypothesis]: #284
+#605 := (or #604 #602)
+#606 := [th-lemma arith triangle-eq]: #605
+#601 := [unit-resolution #606 #603 #271]: false
+#607 := [lemma #601]: #604
+#286 := (or z3name!0 #284)
+#265 := [def-axiom]: #286
+#574 := [unit-resolution #265 #607]: z3name!0
+decl ?v0!1 :: Int
+#115 := ?v0!1
+#118 := (<= ?v0!1 0::Int)
+#119 := (not #118)
+#116 := (>= ?v0!1 0::Int)
+#117 := (not #116)
+#120 := (or #117 #119)
+#121 := (not #120)
+#126 := (or z3name!0 #121)
+#129 := (and #94 #126)
+#130 := (~ #89 #129)
+#127 := (~ #88 #126)
+#122 := (~ #95 #121)
+#123 := [sk]: #122
+#113 := (~ z3name!0 z3name!0)
+#114 := [refl]: #113
+#128 := [monotonicity #114 #123]: #127
+#111 := (~ #94 #94)
+#109 := (~ #62 #62)
+#107 := (~ #59 #59)
+#108 := [refl]: #107
+#110 := [nnf-pos #108]: #109
+#105 := (~ #93 #93)
+#106 := [refl]: #105
+#112 := [monotonicity #106 #110]: #111
+#131 := [monotonicity #112 #128]: #130
+#132 := [mp~ #96 #131]: #129
+#136 := [and-elim #132]: #94
+#563 := [unit-resolution #136 #574]: #62
+[unit-resolution #563 #570]: false
+unsat
+8a78832884e41117489fba88c88de0b5cacb832a 143 0
+#2 := false
+#10 := 0::Int
+#8 := (:var 0 Int)
+#68 := (<= #8 0::Int)
+#69 := (not #68)
+#146 := (not false)
+#149 := (or #146 #69)
+#152 := (not #149)
+#155 := (forall (vars (?v0 Int)) #152)
+#182 := (iff #155 false)
+#177 := (forall (vars (?v0 Int)) false)
+#180 := (iff #177 false)
+#181 := [elim-unused]: #180
+#178 := (iff #155 #177)
+#175 := (iff #152 false)
+#1 := true
+#170 := (not true)
+#173 := (iff #170 false)
+#174 := [rewrite]: #173
+#171 := (iff #152 #170)
+#168 := (iff #149 true)
+#163 := (or true #69)
+#166 := (iff #163 true)
+#167 := [rewrite]: #166
+#164 := (iff #149 #163)
+#161 := (iff #146 true)
+#162 := [rewrite]: #161
+#165 := [monotonicity #162]: #164
+#169 := [trans #165 #167]: #168
+#172 := [monotonicity #169]: #171
+#176 := [trans #172 #174]: #175
+#179 := [quant-intro #176]: #178
+#183 := [trans #179 #181]: #182
+#59 := -1::Int
+#60 := (* -1::Int #8)
+#7 := (:var 1 Int)
+#61 := (+ #7 #60)
+#62 := (<= #61 0::Int)
+#65 := (not #62)
+#72 := (or #65 #69)
+#75 := (forall (vars (?v1 Int)) #72)
+#78 := (not #75)
+#81 := (or #78 #69)
+#107 := (not #81)
+#125 := (forall (vars (?v0 Int)) #107)
+#158 := (iff #125 #155)
+#129 := (forall (vars (?v1 Int)) #69)
+#132 := (not #129)
+#135 := (or #132 #69)
+#138 := (not #135)
+#141 := (forall (vars (?v0 Int)) #138)
+#156 := (iff #141 #155)
+#157 := [rewrite]: #156
+#142 := (iff #125 #141)
+#143 := [rewrite]: #142
+#159 := [trans #143 #157]: #158
+#118 := (and #75 #68)
+#121 := (forall (vars (?v0 Int)) #118)
+#126 := (iff #121 #125)
+#115 := (iff #118 #107)
+#124 := [rewrite]: #115
+#127 := [quant-intro #124]: #126
+#103 := (not #69)
+#106 := (and #75 #103)
+#110 := (forall (vars (?v0 Int)) #106)
+#122 := (iff #110 #121)
+#119 := (iff #106 #118)
+#116 := (iff #103 #68)
+#117 := [rewrite]: #116
+#120 := [monotonicity #117]: #119
+#123 := [quant-intro #120]: #122
+#84 := (exists (vars (?v0 Int)) #81)
+#87 := (not #84)
+#111 := (~ #87 #110)
+#108 := (~ #107 #106)
+#104 := (~ #103 #103)
+#105 := [refl]: #104
+#94 := (not #78)
+#95 := (~ #94 #75)
+#100 := (~ #75 #75)
+#98 := (~ #72 #72)
+#99 := [refl]: #98
+#101 := [nnf-pos #99]: #100
+#102 := [nnf-neg #101]: #95
+#109 := [nnf-neg #102 #105]: #108
+#112 := [nnf-neg #109]: #111
+#11 := (< 0::Int #8)
+#9 := (<= #7 #8)
+#12 := (implies #9 #11)
+#13 := (forall (vars (?v1 Int)) #12)
+#14 := (implies #13 #11)
+#15 := (exists (vars (?v0 Int)) #14)
+#16 := (not #15)
+#90 := (iff #16 #87)
+#37 := (not #9)
+#38 := (or #37 #11)
+#41 := (forall (vars (?v1 Int)) #38)
+#47 := (not #41)
+#48 := (or #47 #11)
+#53 := (exists (vars (?v0 Int)) #48)
+#56 := (not #53)
+#88 := (iff #56 #87)
+#85 := (iff #53 #84)
+#82 := (iff #48 #81)
+#70 := (iff #11 #69)
+#71 := [rewrite]: #70
+#79 := (iff #47 #78)
+#76 := (iff #41 #75)
+#73 := (iff #38 #72)
+#66 := (iff #37 #65)
+#63 := (iff #9 #62)
+#64 := [rewrite]: #63
+#67 := [monotonicity #64]: #66
+#74 := [monotonicity #67 #71]: #73
+#77 := [quant-intro #74]: #76
+#80 := [monotonicity #77]: #79
+#83 := [monotonicity #80 #71]: #82
+#86 := [quant-intro #83]: #85
+#89 := [monotonicity #86]: #88
+#57 := (iff #16 #56)
+#54 := (iff #15 #53)
+#51 := (iff #14 #48)
+#44 := (implies #41 #11)
+#49 := (iff #44 #48)
+#50 := [rewrite]: #49
+#45 := (iff #14 #44)
+#42 := (iff #13 #41)
+#39 := (iff #12 #38)
+#40 := [rewrite]: #39
+#43 := [quant-intro #40]: #42
+#46 := [monotonicity #43]: #45
+#52 := [trans #46 #50]: #51
+#55 := [quant-intro #52]: #54
+#58 := [monotonicity #55]: #57
+#91 := [trans #58 #89]: #90
+#36 := [asserted]: #16
+#92 := [mp #36 #91]: #87
+#113 := [mp~ #92 #112]: #110
+#114 := [mp #113 #123]: #121
+#128 := [mp #114 #127]: #125
+#160 := [mp #128 #159]: #155
+[mp #160 #183]: false
+unsat

--- a/src/HOL/SMT_Examples/SMT_Examples.certs2	Thu Mar 13 15:54:41 2014 +0100
+++ b/src/HOL/SMT_Examples/SMT_Examples.certs2	Thu Mar 13 16:17:14 2014 +0100
@@ -1,70 +1,79 @@
-bbf19253181a221ae876ff5207c4e19acd49bcc5 5 0
+7a16ef230bca5702aa346494226903ec25809d32 6 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(mp (asserted (not true)) (rewrite (= (not true) false)) false)))
+(let ((@x28 (rewrite (= (not true) false))))
+(mp (asserted (not true)) @x28 false))))
 
-7da7317115e337fb9b3e7260dcd426df65d770ca 5 0
+27731fc512042f0ea1785a47796a8bfd64c4a8cf 7 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(|unit-resolution| (|not-or-elim| (asserted (not (or |p$| (not |p$|)))) (not |p$|)) (|not-or-elim| (asserted (not (or |p$| (not |p$|)))) |p$|) false)))
+(let ((@x34 (monotonicity (rewrite (= (or |p$| (not |p$|)) true)) (= (not (or |p$| (not |p$|))) (not true)))))
+(let ((@x38 (trans @x34 (rewrite (= (not true) false)) (= (not (or |p$| (not |p$|))) false))))
+(mp (asserted (not (or |p$| (not |p$|)))) @x38 false)))))
 
-491ce0f180688f8b3ad41fb77c37c188bb719912 9 0
+5330fb77bfecb903300c8a50f577df102088abaa 9 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let ((@x14 (monotonicity (rewrite (= (and |p$| true) |p$|)) (= (= (and |p$| true) |p$|) (= |p$| |p$|)))))
-(let ((@x18 (trans @x14 (rewrite (= (= |p$| |p$|) true)) (= (= (and |p$| true) |p$|) true))))
-(let ((@x21 (monotonicity @x18 (= (not (= (and |p$| true) |p$|)) (not true)))))
-(let ((@x25 (trans @x21 (rewrite (= (not true) false)) (= (not (= (and |p$| true) |p$|)) false))))
-(mp (asserted (not (= (and |p$| true) |p$|))) @x25 false)))))))
+(let ((@x34 (monotonicity (rewrite (= (and |p$| true) |p$|)) (= (= (and |p$| true) |p$|) (= |p$| |p$|)))))
+(let ((@x38 (trans @x34 (rewrite (= (= |p$| |p$|) true)) (= (= (and |p$| true) |p$|) true))))
+(let ((@x41 (monotonicity @x38 (= (not (= (and |p$| true) |p$|)) (not true)))))
+(let ((@x45 (trans @x41 (rewrite (= (not true) false)) (= (not (= (and |p$| true) |p$|)) false))))
+(mp (asserted (not (= (and |p$| true) |p$|))) @x45 false)))))))
 
-bcdca2390eec1cc7907ebb4fd43ef90102359e67 13 0
+c2e74b12f4c731d0ea3ac811d94ac5a723029e93 13 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let (($x11 (not (=> (and (or |p$| |q$|) (not |p$|)) |q$|))))
-(let (($x15 (= (=> (and (or |p$| |q$|) (not |p$|)) |q$|) (or (not (and (or |p$| |q$|) (not |p$|))) |q$|))))
-(let ((@x19 (monotonicity (rewrite $x15) (= $x11 (not (or (not (and (or |p$| |q$|) (not |p$|))) |q$|))))))
-(let ((@x20 (mp (asserted $x11) @x19 (not (or (not (and (or |p$| |q$|) (not |p$|))) |q$|)))))
-(let ((@x23 (|and-elim| (|not-or-elim| @x20 (and (or |p$| |q$|) (not |p$|))) (not |p$|))))
-(let ((@x32 (monotonicity (|iff-false| @x23 (= |p$| false)) (|iff-false| (|not-or-elim| @x20 (not |q$|)) (= |q$| false)) (= (or |p$| |q$|) (or false false)))))
-(let ((@x36 (trans @x32 (rewrite (= (or false false) false)) (= (or |p$| |q$|) false))))
+(let (($x8 (not |p$|)))
 (let (($x7 (or |p$| |q$|)))
-(mp (|and-elim| (|not-or-elim| @x20 (and $x7 (not |p$|))) $x7) @x36 false)))))))))))
+(let (($x9 (and $x7 $x8)))
+(let ((@x39 (monotonicity (rewrite (= (=> $x9 |q$|) (or (not $x9) |q$|))) (= (not (=> $x9 |q$|)) (not (or (not $x9) |q$|))))))
+(let ((@x40 (|not-or-elim| (mp (asserted (not (=> $x9 |q$|))) @x39 (not (or (not $x9) |q$|))) $x9)))
+(let ((@x43 (|and-elim| @x40 $x8)))
+(let ((@x45 (|not-or-elim| (mp (asserted (not (=> $x9 |q$|))) @x39 (not (or (not $x9) |q$|))) (not |q$|))))
+(let ((@x41 (|and-elim| @x40 $x7)))
+(|unit-resolution| @x41 @x45 @x43 false)))))))))))
 
-33609f14221bd6366d7f13b136eb93ccf9841b7e 13 0
+800409db22b453674c1b66520bda2d5bafbf81b4 11 0
 unsat
 ((set-logic AUFLIA)
 (proof
 (let (($x10 (and |c$| |d$|)))
 (let (($x7 (and |a$| |b$|)))
-(let (($x13 (not (=> (or $x7 $x10) (or $x7 $x10)))))
-(let (($x17 (= (=> (or $x7 $x10) (or $x7 $x10)) (or (not (or $x7 $x10)) $x7 $x10))))
-(let ((@x21 (monotonicity (rewrite $x17) (= $x13 (not (or (not (or $x7 $x10)) $x7 $x10))))))
-(let ((@x22 (mp (asserted $x13) @x21 (not (or (not (or $x7 $x10)) $x7 $x10)))))
-(let ((@x34 (monotonicity (|iff-false| (|not-or-elim| @x22 (not $x7)) (= $x7 false)) (|iff-false| (|not-or-elim| @x22 (not $x10)) (= $x10 false)) (= (or $x7 $x10) (or false false)))))
-(let ((@x38 (trans @x34 (rewrite (= (or false false) false)) (= (or $x7 $x10) false))))
-(mp (|not-or-elim| @x22 (or $x7 $x10)) @x38 false)))))))))))
+(let (($x11 (or $x7 $x10)))
+(let (($x12 (=> $x11 $x11)))
+(let (($x13 (not $x12)))
+(let ((@x43 (trans (monotonicity (rewrite (= $x12 true)) (= $x13 (not true))) (rewrite (= (not true) false)) (= $x13 false))))
+(mp (asserted $x13) @x43 false)))))))))
 
-41601ebe27811aa51768455eec7d63637aa09b37 15 0
+8ba22a36afac456bfdc7db71e8b371143686dc86 23 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let (($x14 (or (=> |p1$| (or (and |p3$| |p2$|) (and |p1$| |p3$|))) |p1$|)))
-(let (($x15 (=> (or (and |p1$| |p2$|) |p3$|) $x14)))
+(let (($x11 (and |p1$| |p3$|)))
+(let (($x10 (and |p3$| |p2$|)))
+(let (($x12 (or $x10 $x11)))
+(let (($x13 (=> |p1$| $x12)))
+(let (($x14 (or $x13 |p1$|)))
+(let (($x7 (and |p1$| |p2$|)))
+(let (($x9 (or $x7 |p3$|)))
+(let (($x15 (=> $x9 $x14)))
 (let (($x16 (not $x15)))
-(let (($x25 (= (or (or (not |p1$|) (and |p3$| |p2$|) (and |p1$| |p3$|)) |p1$|) true)))
-(let (($x23 (= $x14 (or (or (not |p1$|) (and |p3$| |p2$|) (and |p1$| |p3$|)) |p1$|))))
-(let (($x20 (= (=> |p1$| (or (and |p3$| |p2$|) (and |p1$| |p3$|))) (or (not |p1$|) (and |p3$| |p2$|) (and |p1$| |p3$|)))))
-(let ((@x28 (trans (monotonicity (rewrite $x20) $x23) (rewrite $x25) (= $x14 true))))
-(let ((@x31 (monotonicity @x28 (= $x15 (=> (or (and |p1$| |p2$|) |p3$|) true)))))
-(let ((@x35 (trans @x31 (rewrite (= (=> (or (and |p1$| |p2$|) |p3$|) true) true)) (= $x15 true))))
-(let ((@x42 (trans (monotonicity @x35 (= $x16 (not true))) (rewrite (= (not true) false)) (= $x16 false))))
-(mp (asserted $x16) @x42 false)))))))))))))
+(let (($x38 (not |p1$|)))
+(let (($x39 (or $x38 $x12)))
+(let (($x42 (or $x39 |p1$|)))
+(let (($x48 (not $x9)))
+(let (($x49 (or $x48 $x42)))
+(let (($x54 (not $x49)))
+(let ((@x65 (trans (monotonicity (rewrite (= $x49 true)) (= $x54 (not true))) (rewrite (= (not true) false)) (= $x54 false))))
+(let ((@x47 (monotonicity (monotonicity (rewrite (= $x13 $x39)) (= $x14 $x42)) (= $x15 (=> $x9 $x42)))))
+(let ((@x56 (monotonicity (trans @x47 (rewrite (= (=> $x9 $x42) $x49)) (= $x15 $x49)) (= $x16 $x54))))
+(mp (asserted $x16) (trans @x56 @x65 (= $x16 false)) false)))))))))))))))))))))
 
-7f485e6a920dd309143a3ab1b4de9c4e47827bd1 24 0
+9d0d2643780c0052a3bf06c1fd96112084da5890 24 0
 unsat
 ((set-logic AUFLIA)
 (proof
@@ -78,91 +87,103 @@
 (let (($x13 (= $x12 |p$|)))
 (let (($x14 (= $x13 |p$|)))
 (let (($x15 (not $x14)))
-(let ((@x18 (rewrite (= $x6 true))))
-(let ((@x23 (rewrite (= (= true |p$|) |p$|))))
-(let ((@x25 (trans (monotonicity @x18 (= $x7 (= true |p$|))) @x23 (= $x7 |p$|))))
-(let ((@x31 (monotonicity (trans (monotonicity @x25 (= $x8 $x6)) @x18 (= $x8 true)) (= $x9 (= true |p$|)))))
-(let ((@x37 (trans (monotonicity (trans @x31 @x23 (= $x9 |p$|)) (= $x10 $x6)) @x18 (= $x10 true))))
-(let ((@x41 (trans (monotonicity @x37 (= $x11 (= true |p$|))) @x23 (= $x11 |p$|))))
-(let ((@x47 (monotonicity (trans (monotonicity @x41 (= $x12 $x6)) @x18 (= $x12 true)) (= $x13 (= true |p$|)))))
-(let ((@x53 (trans (monotonicity (trans @x47 @x23 (= $x13 |p$|)) (= $x14 $x6)) @x18 (= $x14 true))))
-(let ((@x60 (trans (monotonicity @x53 (= $x15 (not true))) (rewrite (= (not true) false)) (= $x15 false))))
-(mp (asserted $x15) @x60 false))))))))))))))))))))))
+(let ((@x38 (rewrite (= $x6 true))))
+(let ((@x43 (rewrite (= (= true |p$|) |p$|))))
+(let ((@x45 (trans (monotonicity @x38 (= $x7 (= true |p$|))) @x43 (= $x7 |p$|))))
+(let ((@x51 (monotonicity (trans (monotonicity @x45 (= $x8 $x6)) @x38 (= $x8 true)) (= $x9 (= true |p$|)))))
+(let ((@x57 (trans (monotonicity (trans @x51 @x43 (= $x9 |p$|)) (= $x10 $x6)) @x38 (= $x10 true))))
+(let ((@x61 (trans (monotonicity @x57 (= $x11 (= true |p$|))) @x43 (= $x11 |p$|))))
+(let ((@x67 (monotonicity (trans (monotonicity @x61 (= $x12 $x6)) @x38 (= $x12 true)) (= $x13 (= true |p$|)))))
+(let ((@x73 (trans (monotonicity (trans @x67 @x43 (= $x13 |p$|)) (= $x14 $x6)) @x38 (= $x14 true))))
+(let ((@x80 (trans (monotonicity @x73 (= $x15 (not true))) (rewrite (= (not true) false)) (= $x15 false))))
+(mp (asserted $x15) @x80 false))))))))))))))))))))))
 
-47fc1bdb5c81d2c954d3c9c4f6781abf20cd2ad5 33 0
+63439e1fd6656fc5a2376d7e5f00d0dd92c536a2 34 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let (($x101 (not |d$|)))
-(let (($x39 (not (or |c$| (and (not |p$|) (or |p$| (and |q$| (not |q$|))))))))
-(let ((@x109 (|iff-false| (|not-or-elim| (asserted $x39) (not |c$|)) (= |c$| false))))
-(let ((@x116 (trans (monotonicity @x109 (= (or $x101 |c$|) (or $x101 false))) (rewrite (= (or $x101 false) $x101)) (= (or $x101 |c$|) $x101))))
-(let (($x104 (or $x101 |c$|)))
-(let ((@x103 (monotonicity (rewrite (= (or |d$| false) |d$|)) (= (not (or |d$| false)) $x101))))
-(let ((@x107 (mp (asserted (or (not (or |d$| false)) |c$|)) (monotonicity @x103 (= (or (not (or |d$| false)) |c$|) $x104)) $x104)))
-(let (($x92 (not |b$|)))
-(let ((@x127 (trans (monotonicity @x109 (= (or $x92 |c$|) (or $x92 false))) (rewrite (= (or $x92 false) $x92)) (= (or $x92 |c$|) $x92))))
-(let (($x95 (or $x92 |c$|)))
-(let ((@x87 (monotonicity (rewrite (= (or |x$| (not |x$|)) true)) (= (and |b$| (or |x$| (not |x$|))) (and |b$| true)))))
-(let ((@x91 (trans @x87 (rewrite (= (and |b$| true) |b$|)) (= (and |b$| (or |x$| (not |x$|))) |b$|))))
-(let ((@x97 (monotonicity (monotonicity @x91 (= (not (and |b$| (or |x$| (not |x$|)))) $x92)) (= (or (not (and |b$| (or |x$| (not |x$|)))) |c$|) $x95))))
-(let ((@x98 (mp (asserted (or (not (and |b$| (or |x$| (not |x$|)))) |c$|)) @x97 $x95)))
-(let (($x76 (not |a$|)))
-(let ((@x128 (monotonicity (|iff-false| (mp @x98 @x127 $x92) (= |b$| false)) (= (or $x76 |b$|) (or $x76 false)))))
-(let ((@x133 (trans @x128 (rewrite (= (or $x76 false) $x76)) (= (or $x76 |b$|) $x76))))
-(let (($x79 (or $x76 |b$|)))
-(let ((@x71 (monotonicity (rewrite (= (and |c$| (not |c$|)) false)) (= (or |a$| (and |c$| (not |c$|))) (or |a$| false)))))
-(let ((@x75 (trans @x71 (rewrite (= (or |a$| false) |a$|)) (= (or |a$| (and |c$| (not |c$|))) |a$|))))
-(let ((@x81 (monotonicity (monotonicity @x75 (= (not (or |a$| (and |c$| (not |c$|)))) $x76)) (= (or (not (or |a$| (and |c$| (not |c$|)))) |b$|) $x79))))
-(let ((@x82 (mp (asserted (or (not (or |a$| (and |c$| (not |c$|)))) |b$|)) @x81 $x79)))
-(let ((@x155 (monotonicity (|iff-false| (mp @x82 @x133 $x76) (= |a$| false)) (|iff-false| (mp @x98 @x127 $x92) (= |b$| false)) @x109 (|iff-false| (mp @x107 @x116 $x101) (= |d$| false)) (= (or |a$| |b$| |c$| |d$|) (or false false false false)))))
-(let ((@x159 (trans @x155 (rewrite (= (or false false false false) false)) (= (or |a$| |b$| |c$| |d$|) false))))
-(let (($x57 (or |a$| |b$| |c$| |d$|)))
-(let (($x11 (or |a$| (or |b$| (or |c$| |d$|)))))
-(let ((@x56 (monotonicity (rewrite (= (or |b$| (or |c$| |d$|)) (or |b$| |c$| |d$|))) (= $x11 (or |a$| (or |b$| |c$| |d$|))))))
-(let ((@x61 (trans @x56 (rewrite (= (or |a$| (or |b$| |c$| |d$|)) $x57)) (= $x11 $x57))))
-(mp (mp (asserted $x11) @x61 $x57) @x159 false)))))))))))))))))))))))))))))))
+(let (($x98 (not |b$|)))
+(let (($x17 (not |c$|)))
+(let (($x36 (or |p$| (and |q$| (not |q$|)))))
+(let (($x37 (and (not |p$|) $x36)))
+(let (($x38 (or |c$| $x37)))
+(let (($x39 (not $x38)))
+(let ((@x120 (monotonicity (rewrite (= (and |q$| (not |q$|)) false)) (= $x36 (or |p$| false)))))
+(let ((@x127 (monotonicity (trans @x120 (rewrite (= (or |p$| false) |p$|)) (= $x36 |p$|)) (= $x37 (and (not |p$|) |p$|)))))
+(let ((@x131 (trans @x127 (rewrite (= (and (not |p$|) |p$|) false)) (= $x37 false))))
+(let ((@x138 (trans (monotonicity @x131 (= $x38 (or |c$| false))) (rewrite (= (or |c$| false) |c$|)) (= $x38 |c$|))))
+(let ((@x143 (mp (asserted $x39) (monotonicity @x138 (= $x39 $x17)) $x17)))
+(let (($x101 (or $x98 |c$|)))
+(let ((@x93 (monotonicity (rewrite (= (or |x$| (not |x$|)) true)) (= (and |b$| (or |x$| (not |x$|))) (and |b$| true)))))
+(let ((@x97 (trans @x93 (rewrite (= (and |b$| true) |b$|)) (= (and |b$| (or |x$| (not |x$|))) |b$|))))
+(let ((@x103 (monotonicity (monotonicity @x97 (= (not (and |b$| (or |x$| (not |x$|)))) $x98)) (= (or (not (and |b$| (or |x$| (not |x$|)))) |c$|) $x101))))
+(let ((@x106 (mp (asserted (or (not (and |b$| (or |x$| (not |x$|)))) |c$|)) @x103 $x101)))
+(let (($x108 (not |d$|)))
+(let (($x111 (or $x108 |c$|)))
+(let ((@x110 (monotonicity (rewrite (= (or |d$| false) |d$|)) (= (not (or |d$| false)) $x108))))
+(let ((@x116 (mp (asserted (or (not (or |d$| false)) |c$|)) (monotonicity @x110 (= (or (not (or |d$| false)) |c$|) $x111)) $x111)))
+(let (($x64 (or |a$| |b$| |c$| |d$|)))
+(let ((@x67 (mp (asserted (or |a$| (or |b$| (or |c$| |d$|)))) (rewrite (= (or |a$| (or |b$| (or |c$| |d$|))) $x64)) $x64)))
+(let ((@x160 (|unit-resolution| @x67 (|unit-resolution| @x106 @x143 $x98) @x143 (|unit-resolution| @x116 @x143 $x108) |a$|)))
+(let (($x81 (not |a$|)))
+(let (($x84 (or $x81 |b$|)))
+(let ((@x76 (monotonicity (rewrite (= (and |c$| $x17) false)) (= (or |a$| (and |c$| $x17)) (or |a$| false)))))
+(let ((@x80 (trans @x76 (rewrite (= (or |a$| false) |a$|)) (= (or |a$| (and |c$| $x17)) |a$|))))
+(let ((@x86 (monotonicity (monotonicity @x80 (= (not (or |a$| (and |c$| $x17))) $x81)) (= (or (not (or |a$| (and |c$| $x17))) |b$|) $x84))))
+(let ((@x89 (mp (asserted (or (not (or |a$| (and |c$| $x17))) |b$|)) @x86 $x84)))
+(|unit-resolution| @x89 @x160 (|unit-resolution| @x106 @x143 $x98) false))))))))))))))))))))))))))))))))
 
-8c24f75a894825932206d94b2ce1c08f0d064ba2 16 0
+c1a1d5a3f58100ecdaa72705a063eeccc5044c46 27 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let (($x16 (= (|symm_f$| |a$| |b$|) (|symm_f$| |b$| |a$|))))
-(let (($x30 (not $x16)))
-(let ((@x25 (monotonicity (rewrite (= (= |a$| |a$|) true)) (= (and (= |a$| |a$|) $x16) (and true $x16)))))
-(let ((@x29 (trans @x25 (rewrite (= (and true $x16) $x16)) (= (and (= |a$| |a$|) $x16) $x16))))
-(let ((@x33 (mp (asserted (not (and (= |a$| |a$|) $x16))) (monotonicity @x29 (= (not (and (= |a$| |a$|) $x16)) $x30)) $x30)))
-(let (($x483 (forall ((?v0 |A$|) (?v1 |A$|) )(!(= (|symm_f$| ?v0 ?v1) (|symm_f$| ?v1 ?v0)) :pattern ( (|symm_f$| ?v0 ?v1) ) :pattern ( (|symm_f$| ?v1 ?v0) )))
+(let ((?x15 (|symm_f$| |b$| |a$|)))
+(let ((?x14 (|symm_f$| |a$| |b$|)))
+(let (($x16 (= ?x14 ?x15)))
+(let (($x50 (not $x16)))
+(let ((@x45 (monotonicity (rewrite (= (= |a$| |a$|) true)) (= (and (= |a$| |a$|) $x16) (and true $x16)))))
+(let ((@x49 (trans @x45 (rewrite (= (and true $x16) $x16)) (= (and (= |a$| |a$|) $x16) $x16))))
+(let ((@x55 (mp (asserted (not (and (= |a$| |a$|) $x16))) (monotonicity @x49 (= (not (and (= |a$| |a$|) $x16)) $x50)) $x50)))
+(let (($x59 (forall ((?v0 |A$|) (?v1 |A$|) )(!(let ((?x8 (|symm_f$| ?v1 ?v0)))
+(let ((?x7 (|symm_f$| ?v0 ?v1)))
+(= ?x7 ?x8))) :pattern ( (|symm_f$| ?v0 ?v1) ) :pattern ( (|symm_f$| ?v1 ?v0) )))
 ))
-(let (($x10 (forall ((?v0 |A$|) (?v1 |A$|) )(= (|symm_f$| ?v0 ?v1) (|symm_f$| ?v1 ?v0)))
+(let (($x10 (forall ((?v0 |A$|) (?v1 |A$|) )(let ((?x8 (|symm_f$| ?v1 ?v0)))
+(let ((?x7 (|symm_f$| ?v0 ?v1)))
+(= ?x7 ?x8))))
 ))
-(let (($x9 (= (|symm_f$| ?1 ?0) (|symm_f$| ?0 ?1))))
-(let ((@x63 (|mp~| (mp (asserted $x10) (|rewrite*| (= $x10 $x10)) $x10) (|nnf-pos| (refl (|~| $x9 $x9)) (|~| $x10 $x10)) $x10)))
-(|unit-resolution| ((_ |quant-inst| |a$| |b$|) (or (not $x483) $x16)) (mp @x63 (|quant-intro| (refl (= $x9 $x9)) (= $x10 $x483)) $x483) (mp @x33 (|rewrite*| (= $x30 $x30)) $x30) false))))))))))))
+(let ((?x8 (|symm_f$| ?0 ?1)))
+(let ((?x7 (|symm_f$| ?1 ?0)))
+(let (($x9 (= ?x7 ?x8)))
+(let ((@x58 (|mp~| (asserted $x10) (|nnf-pos| (refl (|~| $x9 $x9)) (|~| $x10 $x10)) $x10)))
+(let ((@x66 (mp @x58 (|quant-intro| (refl (= $x9 $x9)) (= $x10 $x59)) $x59)))
+(let (($x70 (or (not $x59) $x16)))
+(let ((@x71 ((_ |quant-inst| |a$| |b$|) $x70)))
+(|unit-resolution| @x71 @x66 @x55 false)))))))))))))))))))
 
-b7bd810dad2f1e427087fcd2f0121b91d06c649f 37 0
+d1ba851b4b433507a4e12ae0555630bd23204076 38 0
 unsat
 ((set-logic AUFLIA)
 (declare-fun ?v0!0 () Int)
 (declare-fun ?v1!1 () Int)
 (proof
-(let (($x49 (|p$| ?v0!0)))
-(let (($x50 (not $x49)))
-(let (($x63 (not (or $x49 (|p$| ?v1!1)))))
-(let ((@x79 (monotonicity (rewrite (= (not $x50) $x49)) (= (and (not $x50) $x63) (and $x49 $x63)))))
-(let (($x57 (not $x50)))
-(let (($x67 (and $x57 $x63)))
-(let (($x19 (forall ((?v0 Int) )(let (($x10 (forall ((?v1 Int) )(let (($x6 (|p$| ?v1)))
+(let (($x46 (|p$| ?v0!0)))
+(let (($x48 (not $x46)))
+(let (($x61 (not (or $x46 (|p$| ?v1!1)))))
+(let ((@x77 (monotonicity (rewrite (= (not $x48) $x46)) (= (and (not $x48) $x61) (and $x46 $x61)))))
+(let (($x55 (not $x48)))
+(let (($x65 (and $x55 $x61)))
+(let (($x39 (forall ((?v0 Int) )(let (($x10 (forall ((?v1 Int) )(let (($x6 (|p$| ?v1)))
 (or (|p$| ?v0) $x6)))
 ))
 (or (not (|p$| ?v0)) $x10)))
 ))
-(let (($x22 (not $x19)))
-(let (($x52 (forall ((?v1 Int) )(let (($x6 (|p$| ?v1)))
-(let (($x49 (|p$| ?v0!0)))
-(or $x49 $x6))))
+(let (($x42 (not $x39)))
+(let (($x50 (forall ((?v1 Int) )(let (($x6 (|p$| ?v1)))
+(let (($x46 (|p$| ?v0!0)))
+(or $x46 $x6))))
 ))
-(let ((@x69 (|nnf-neg| (refl (|~| $x57 $x57)) (sk (|~| (not $x52) $x63)) (|~| (not (or $x50 $x52)) $x67))))
+(let ((@x67 (|nnf-neg| (refl (|~| $x55 $x55)) (sk (|~| (not $x50) $x61)) (|~| (not (or $x48 $x50)) $x65))))
 (let (($x12 (forall ((?v0 Int) )(let (($x10 (forall ((?v1 Int) )(let (($x6 (|p$| ?v1)))
 (or (|p$| ?v0) $x6)))
 ))
@@ -173,1788 +194,1905 @@
 (let (($x10 (forall ((?v1 Int) )(let (($x6 (|p$| ?v1)))
 (or (|p$| ?0) $x6)))
 ))
-(let ((@x21 (|quant-intro| (rewrite (= (=> (|p$| ?0) $x10) (or (not (|p$| ?0)) $x10))) (= $x12 $x19))))
-(let ((@x28 (mp (mp (asserted $x13) (monotonicity @x21 (= $x13 $x22)) $x22) (|rewrite*| (= $x22 $x22)) $x22)))
-(let ((@x72 (|mp~| @x28 (trans (sk (|~| $x22 (not (or $x50 $x52)))) @x69 (|~| $x22 $x67)) $x67)))
-(|unit-resolution| (|and-elim| (mp @x72 @x79 (and $x49 $x63)) $x49) (|not-or-elim| (|and-elim| (mp @x72 @x79 (and $x49 $x63)) $x63) $x50) false)))))))))))))))))))
+(let ((@x41 (|quant-intro| (rewrite (= (=> (|p$| ?0) $x10) (or (not (|p$| ?0)) $x10))) (= $x12 $x39))))
+(let ((@x70 (|mp~| (mp (asserted $x13) (monotonicity @x41 (= $x13 $x42)) $x42) (trans (sk (|~| $x42 (not (or $x48 $x50)))) @x67 (|~| $x42 $x65)) $x65)))
+(let ((@x79 (|not-or-elim| (|and-elim| (mp @x70 @x77 (and $x46 $x61)) $x61) $x48)))
+(let ((@x72 (|and-elim| (mp @x70 @x77 (and $x46 $x61)) $x46)))
+(|unit-resolution| @x72 @x79 false))))))))))))))))))))
 
-6cf824ace40aded20fac37a6bbde5bb680ac2a1c 22 0
+19f6b54cdb476573f91d167cec6fca10e0e66fc7 27 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let (($x6 (|p$| |x$|)))
-(let ((@x26 (monotonicity (rewrite (= (=> $x6 (|p$| |y$|)) (or (not $x6) (|p$| |y$|)))) (= (not (=> $x6 (|p$| |y$|))) (not (or (not $x6) (|p$| |y$|)))))))
-(let ((@x27 (mp (asserted (not (=> $x6 (|p$| |y$|)))) @x26 (not (or (not $x6) (|p$| |y$|))))))
-(let (($x492 (forall ((?v0 |A$|) )(!(let (($x8 (|p$| ?v0)))
+(let (($x72 (forall ((?v0 |A$|) )(!(let (($x8 (|p$| ?v0)))
 (not $x8)) :pattern ( (|p$| ?v0) )))
 ))
+(let (($x6 (|p$| |x$|)))
+(let ((@x46 (monotonicity (rewrite (= (=> $x6 (|p$| |y$|)) (or (not $x6) (|p$| |y$|)))) (= (not (=> $x6 (|p$| |y$|))) (not (or (not $x6) (|p$| |y$|)))))))
+(let ((@x49 (mp (asserted (not (=> $x6 (|p$| |y$|)))) @x46 (not (or (not $x6) (|p$| |y$|))))))
+(let ((@x47 (|not-or-elim| @x49 $x6)))
+(let (($x40 (not $x6)))
+(let (($x75 (or $x40 $x72)))
 (let (($x12 (forall ((?v0 |A$|) )(let (($x8 (|p$| ?v0)))
 (not $x8)))
 ))
-(let ((@x496 (|quant-intro| (refl (= (not (|p$| ?0)) (not (|p$| ?0)))) (= $x12 $x492))))
+(let (($x62 (or $x40 $x12)))
+(let ((@x74 (|quant-intro| (refl (= (not (|p$| ?0)) (not (|p$| ?0)))) (= $x12 $x72))))
 (let (($x9 (exists ((?v0 |A$|) )(|p$| ?v0))
 ))
-(let (($x10 (not $x9)))
-(let ((@x35 (monotonicity (|iff-true| (|not-or-elim| @x27 $x6) (= $x6 true)) (= (ite $x6 $x10 $x12) (ite true $x10 $x12)))))
-(let ((@x39 (trans @x35 (rewrite (= (ite true $x10 $x12) $x10)) (= (ite $x6 $x10 $x12) $x10))))
-(let ((@x43 (mp (mp (asserted (ite $x6 $x10 $x12)) @x39 $x10) (|rewrite*| (= $x10 $x10)) $x10)))
-(let ((@x70 (|mp~| @x43 (|nnf-neg| (refl (|~| (not (|p$| ?0)) (not (|p$| ?0)))) (|~| $x10 $x12)) $x12)))
-(|unit-resolution| ((_ |quant-inst| |x$|) (or (not $x492) (not $x6))) (mp @x70 @x496 $x492) (mp (|not-or-elim| @x27 $x6) (|rewrite*| (= $x6 $x6)) $x6) false)))))))))))))))
+(let (($x13 (ite $x6 (not $x9) $x12)))
+(let ((@x58 (|nnf-neg| (refl (|~| (not (|p$| ?0)) (not (|p$| ?0)))) (|~| (not $x9) $x12))))
+(let ((@x65 (|nnf-pos| (refl (|~| $x6 $x6)) (refl (|~| $x40 $x40)) @x58 (|nnf-pos| (refl (|~| (not (|p$| ?0)) (not (|p$| ?0)))) (|~| $x12 $x12)) (|~| $x13 (and $x62 (or $x6 $x12))))))
+(let ((@x78 (mp (|and-elim| (|mp~| (asserted $x13) @x65 (and $x62 (or $x6 $x12))) $x62) (monotonicity @x74 (= $x62 $x75)) $x75)))
+(let (($x86 (or (not $x72) $x40)))
+(let ((@x87 ((_ |quant-inst| |x$|) $x86)))
+(|unit-resolution| @x87 @x47 (|unit-resolution| @x78 @x47 $x72) false))))))))))))))))))))
 
-a89c726795a8d0e170934e5d099744330d95400b 7 0
+e86ca8427589ec8e24e5a85d218331bfb59ff385 7 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let ((@x14 (monotonicity (rewrite (= (= 3 3) true)) (= (not (= 3 3)) (not true)))))
-(let ((@x18 (trans @x14 (rewrite (= (not true) false)) (= (not (= 3 3)) false))))
-(mp (asserted (not (= 3 3))) @x18 false)))))
+(let ((@x33 (monotonicity (rewrite (= (= 3 3) true)) (= (not (= 3 3)) (not true)))))
+(let ((@x37 (trans @x33 (rewrite (= (not true) false)) (= (not (= 3 3)) false))))
+(mp (asserted (not (= 3 3))) @x37 false)))))
 
-f7b25fbc92a3db52d764adfa193cc9c7d084b0d6 7 0
+77108fa1aa6a8a356ebdd1a376316f26d90399cb 7 0
 unsat
 ((set-logic AUFLIRA)
 (proof
-(let ((@x14 (monotonicity (rewrite (= (= 3.0 3.0) true)) (= (not (= 3.0 3.0)) (not true)))))
-(let ((@x18 (trans @x14 (rewrite (= (not true) false)) (= (not (= 3.0 3.0)) false))))
-(mp (asserted (not (= 3.0 3.0))) @x18 false)))))
+(let ((@x33 (monotonicity (rewrite (= (= 3.0 3.0) true)) (= (not (= 3.0 3.0)) (not true)))))
+(let ((@x37 (trans @x33 (rewrite (= (not true) false)) (= (not (= 3.0 3.0)) false))))
+(mp (asserted (not (= 3.0 3.0))) @x37 false)))))
 
-54ea7c923e2f51278ebed4a257f587326e98cb4d 9 0
+98abe835b7d13273c58720c5dadf713cd8637495 9 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let ((@x15 (monotonicity (rewrite (= (+ 3 1) 4)) (= (= (+ 3 1) 4) (= 4 4)))))
-(let ((@x20 (trans @x15 (rewrite (= (= 4 4) true)) (= (= (+ 3 1) 4) true))))
-(let ((@x23 (monotonicity @x20 (= (not (= (+ 3 1) 4)) (not true)))))
-(let ((@x27 (trans @x23 (rewrite (= (not true) false)) (= (not (= (+ 3 1) 4)) false))))
-(mp (asserted (not (= (+ 3 1) 4))) @x27 false)))))))
+(let ((@x35 (monotonicity (rewrite (= (+ 3 1) 4)) (= (= (+ 3 1) 4) (= 4 4)))))
+(let ((@x39 (trans @x35 (rewrite (= (= 4 4) true)) (= (= (+ 3 1) 4) true))))
+(let ((@x42 (monotonicity @x39 (= (not (= (+ 3 1) 4)) (not true)))))
+(let ((@x46 (trans @x42 (rewrite (= (not true) false)) (= (not (= (+ 3 1) 4)) false))))
+(mp (asserted (not (= (+ 3 1) 4))) @x46 false)))))))
 
-552d7f5bd067421657495756c4f47648a5eef581 10 0
+0382c7d04a37d9ca60cac3282bc80f6b329ab12f 16 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let (($x12 (= (+ |x$| (+ |y$| |z$|)) (+ |y$| (+ |z$| |x$|)))))
+(let ((?x10 (+ |z$| |x$|)))
+(let ((?x11 (+ |y$| ?x10)))
+(let ((?x8 (+ |y$| |z$|)))
+(let ((?x9 (+ |x$| ?x8)))
+(let (($x12 (= ?x9 ?x11)))
 (let (($x13 (not $x12)))
-(let ((@x23 (monotonicity (rewrite (= (+ |x$| (+ |y$| |z$|)) (+ |x$| |y$| |z$|))) (rewrite (= (+ |y$| (+ |z$| |x$|)) (+ |y$| |z$| |x$|))) (= $x12 (= (+ |x$| |y$| |z$|) (+ |y$| |z$| |x$|))))))
-(let ((@x28 (trans @x23 (rewrite (= (= (+ |x$| |y$| |z$|) (+ |y$| |z$| |x$|)) true)) (= $x12 true))))
-(let ((@x35 (trans (monotonicity @x28 (= $x13 (not true))) (rewrite (= (not true) false)) (= $x13 false))))
-(mp (asserted $x13) @x35 false))))))))
+(let ((@x43 (monotonicity (rewrite (= ?x10 (+ |x$| |z$|))) (= ?x11 (+ |y$| (+ |x$| |z$|))))))
+(let ((@x47 (trans @x43 (rewrite (= (+ |y$| (+ |x$| |z$|)) (+ |x$| |y$| |z$|))) (= ?x11 (+ |x$| |y$| |z$|)))))
+(let ((@x50 (monotonicity (rewrite (= ?x9 (+ |x$| |y$| |z$|))) @x47 (= $x12 (= (+ |x$| |y$| |z$|) (+ |x$| |y$| |z$|))))))
+(let ((@x54 (trans @x50 (rewrite (= (= (+ |x$| |y$| |z$|) (+ |x$| |y$| |z$|)) true)) (= $x12 true))))
+(let ((@x61 (trans (monotonicity @x54 (= $x13 (not true))) (rewrite (= (not true) false)) (= $x13 false))))
+(mp (asserted $x13) @x61 false))))))))))))))
 
-36faa6237c000d60624d7bc78360f9dad21b1321 15 0
+c608fc7154ce1246a30c68f4d20c1d35cedba663 11 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let ((@x36 (monotonicity (rewrite (= (<= 8 5) false)) (= (not (<= 8 5)) (not false)))))
-(let ((@x40 (trans @x36 (rewrite (= (not false) true)) (= (not (<= 8 5)) true))))
-(let (($x27 (not (<= 8 5))))
-(let ((?x9 (ite (<= 3 8) 8 3)))
-(let (($x10 (< 5 ?x9)))
-(let ((@x18 (monotonicity (rewrite (= (<= 3 8) true)) (= ?x9 (ite true 8 3)))))
-(let ((@x22 (trans @x18 (rewrite (= (ite true 8 3) 8)) (= ?x9 8))))
-(let ((@x31 (trans (monotonicity @x22 (= $x10 (< 5 8))) (rewrite (= (< 5 8) $x27)) (= $x10 $x27))))
-(let ((@x45 (monotonicity (trans @x31 @x40 (= $x10 true)) (= (not $x10) (not true)))))
-(let ((@x49 (trans @x45 (rewrite (= (not true) false)) (= (not $x10) false))))
-(mp (asserted (not $x10)) @x49 false)))))))))))))
+(let ((@x39 (monotonicity (rewrite (= (<= 3 8) true)) (= (ite (<= 3 8) 8 3) (ite true 8 3)))))
+(let ((@x43 (trans @x39 (rewrite (= (ite true 8 3) 8)) (= (ite (<= 3 8) 8 3) 8))))
+(let ((@x46 (monotonicity @x43 (= (< 5 (ite (<= 3 8) 8 3)) (< 5 8)))))
+(let ((@x50 (trans @x46 (rewrite (= (< 5 8) true)) (= (< 5 (ite (<= 3 8) 8 3)) true))))
+(let ((@x53 (monotonicity @x50 (= (not (< 5 (ite (<= 3 8) 8 3))) (not true)))))
+(let ((@x57 (trans @x53 (rewrite (= (not true) false)) (= (not (< 5 (ite (<= 3 8) 8 3))) false))))
+(mp (asserted (not (< 5 (ite (<= 3 8) 8 3)))) @x57 false)))))))))
 
-e8e28789ea05d7727096ba10500963856291639a 85 0
+4bdd1f2f245666e5db75e9d320ea9e892060d851 88 0
 unsat
 ((set-logic AUFLIRA)
 (proof
-(let (($x194 (<= (+ |x$| (* (~ 1.0) (ite (>= |x$| 0.0) |x$| (* (~ 1.0) |x$|)))) 0.0)))
-(let ((?x35 (* (~ 1.0) |x$|)))
-(let (($x140 (>= |x$| 0.0)))
-(let ((?x143 (ite $x140 |x$| ?x35)))
-(let (($x176 (= |x$| ?x143)))
-(let ((?x36 (* (~ 1.0) |y$|)))
-(let ((?x37 (+ ?x35 ?x36)))
+(let ((?x42 (* (~ 1.0) |x$|)))
+(let (($x81 (>= |x$| 0.0)))
+(let ((?x88 (ite $x81 |x$| ?x42)))
+(let ((?x111 (* (~ 1.0) ?x88)))
+(let ((?x146 (+ |x$| ?x111)))
+(let (($x147 (<= ?x146 0.0)))
+(let (($x131 (= |x$| ?x88)))
+(let ((?x43 (* (~ 1.0) |y$|)))
+(let ((?x44 (+ ?x42 ?x43)))
 (let ((?x7 (+ |x$| |y$|)))
-(let (($x134 (>= ?x7 0.0)))
-(let ((?x137 (ite $x134 ?x7 ?x37)))
-(let (($x226 (>= (+ ?x37 (* (~ 1.0) ?x137)) 0.0)))
-(let (($x172 (= ?x37 ?x137)))
-(let (($x133 (not $x134)))
-(let (($x146 (>= |y$| 0.0)))
-(let (($x185 (not $x146)))
-(let (($x199 (>= (+ ?x7 (* (~ 1.0) ?x137)) 0.0)))
-(let (($x171 (= ?x7 ?x137)))
-(let (($x235 (not $x226)))
-(let ((@x206 (hypothesis $x146)))
-(let (($x161 (<= (+ ?x137 (* (~ 1.0) ?x143) (* (~ 1.0) (ite $x146 |y$| ?x36))) 0.0)))
-(let (($x69 (<= 0.0 |y$|)))
-(let ((?x83 (ite $x69 |y$| ?x36)))
-(let (($x50 (<= 0.0 |x$|)))
-(let ((?x64 (ite $x50 |x$| ?x35)))
-(let ((?x88 (+ ?x64 ?x83)))
-(let (($x22 (<= 0.0 ?x7)))
-(let ((?x45 (ite $x22 ?x7 ?x37)))
-(let (($x91 (<= ?x45 ?x88)))
-(let (($x94 (not $x91)))
-(let ((@x154 (monotonicity (monotonicity (rewrite (= $x50 $x140)) (= ?x64 ?x143)) (monotonicity (rewrite (= $x69 $x146)) (= ?x83 (ite $x146 |y$| ?x36))) (= ?x88 (+ ?x143 (ite $x146 |y$| ?x36))))))
-(let ((@x157 (monotonicity (monotonicity (rewrite (= $x22 $x134)) (= ?x45 ?x137)) @x154 (= $x91 (<= ?x137 (+ ?x143 (ite $x146 |y$| ?x36)))))))
-(let ((@x165 (trans @x157 (rewrite (= (<= ?x137 (+ ?x143 (ite $x146 |y$| ?x36))) $x161)) (= $x91 $x161))))
-(let ((@x108 (monotonicity (monotonicity (rewrite (= $x50 $x50)) (= ?x64 ?x64)) (monotonicity (rewrite (= $x69 $x69)) (= ?x83 ?x83)) (= ?x88 ?x88))))
-(let ((@x110 (monotonicity (monotonicity (rewrite (= $x22 $x22)) (= ?x45 ?x45)) @x108 (= $x91 $x91))))
-(let ((?x17 (ite (< |y$| 0.0) (- |y$|) |y$|)))
-(let ((?x14 (ite (< |x$| 0.0) (- |x$|) |x$|)))
-(let ((?x10 (- ?x7)))
-(let ((?x11 (ite (< ?x7 0.0) ?x10 ?x7)))
-(let (($x20 (not (<= ?x11 (+ ?x14 ?x17)))))
-(let ((@x77 (trans (rewrite (= (< |y$| 0.0) (not $x69))) (monotonicity (rewrite (= $x69 $x69)) (= (not $x69) (not $x69))) (= (< |y$| 0.0) (not $x69)))))
-(let ((@x82 (monotonicity @x77 (rewrite (= (- |y$|) ?x36)) (= ?x17 (ite (not $x69) ?x36 |y$|)))))
-(let ((@x87 (trans @x82 (rewrite (= (ite (not $x69) ?x36 |y$|) ?x83)) (= ?x17 ?x83))))
-(let ((@x58 (trans (rewrite (= (< |x$| 0.0) (not $x50))) (monotonicity (rewrite (= $x50 $x50)) (= (not $x50) (not $x50))) (= (< |x$| 0.0) (not $x50)))))
-(let ((@x63 (monotonicity @x58 (rewrite (= (- |x$|) ?x35)) (= ?x14 (ite (not $x50) ?x35 |x$|)))))
-(let ((@x68 (trans @x63 (rewrite (= (ite (not $x50) ?x35 |x$|) ?x64)) (= ?x14 ?x64))))
-(let ((@x41 (trans (rewrite (= ?x10 (* (~ 1.0) ?x7))) (rewrite (= (* (~ 1.0) ?x7) ?x37)) (= ?x10 ?x37))))
-(let ((@x30 (trans (rewrite (= (< ?x7 0.0) (not $x22))) (monotonicity (rewrite (= $x22 $x22)) (= (not $x22) (not $x22))) (= (< ?x7 0.0) (not $x22)))))
-(let ((@x49 (trans (monotonicity @x30 @x41 (= ?x11 (ite (not $x22) ?x37 ?x7))) (rewrite (= (ite (not $x22) ?x37 ?x7) ?x45)) (= ?x11 ?x45))))
-(let ((@x93 (monotonicity @x49 (monotonicity @x68 @x87 (= (+ ?x14 ?x17) ?x88)) (= (<= ?x11 (+ ?x14 ?x17)) $x91))))
-(let ((@x100 (mp (mp (asserted $x20) (monotonicity @x93 (= $x20 $x94)) $x94) (|rewrite*| (= $x94 $x94)) $x94)))
-(let ((@x113 (mp (mp @x100 (monotonicity @x110 (= $x94 $x94)) $x94) (monotonicity @x110 (= $x94 $x94)) $x94)))
-(let ((@x169 (mp @x113 (monotonicity @x165 (= $x94 (not $x161))) (not $x161))))
-(let ((?x149 (ite $x146 |y$| ?x36)))
-(let (($x183 (= |y$| ?x149)))
-(let ((@x219 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x183) (<= (+ |y$| (* (~ 1.0) ?x149)) 0.0))) (|unit-resolution| (|def-axiom| (or $x185 $x183)) @x206 $x183) (<= (+ |y$| (* (~ 1.0) ?x149)) 0.0))))
-(let (($x198 (<= (+ ?x35 (* (~ 1.0) ?x143)) 0.0)))
-(let (($x177 (= ?x35 ?x143)))
-(let (($x178 (not $x140)))
-(let ((@x204 ((_ |th-lemma| arith triangle-eq) (or (not $x176) $x194))))
-(let ((@x205 (|unit-resolution| @x204 (|unit-resolution| (|def-axiom| (or $x178 $x176)) (hypothesis $x140) $x176) $x194)))
-(let ((@x209 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1) (or $x134 $x178 $x185)) (hypothesis $x140) @x206 $x134)))
-(let ((@x173 (|def-axiom| (or $x133 $x171))))
-(let ((@x213 ((_ |th-lemma| arith triangle-eq) (or (not $x171) $x199))))
-(let ((@x220 ((_ |th-lemma| arith farkas 1 -1 -1 1) @x219 (|unit-resolution| @x213 (|unit-resolution| @x173 @x209 $x171) $x199) @x169 @x205 false)))
-(let ((@x229 (|unit-resolution| (|def-axiom| (or $x140 $x177)) (|unit-resolution| (lemma @x220 (or $x178 $x185)) @x206 $x178) $x177)))
-(let ((@x234 ((_ |th-lemma| arith farkas 2 -1 -1 1 1) @x206 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x177) $x198)) @x229 $x198) @x219 @x169 (hypothesis $x226) false)))
-(let ((@x243 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x172) $x226)) (hypothesis $x172) (hypothesis $x235) false)))
-(let ((@x246 (|unit-resolution| (lemma @x243 (or (not $x172) $x226)) (|unit-resolution| (lemma @x234 (or $x235 $x185)) @x206 $x235) (not $x172))))
-(let ((@x248 (|unit-resolution| @x173 (|unit-resolution| (|def-axiom| (or $x134 $x172)) @x246 $x134) $x171)))
-(let ((@x250 ((_ |th-lemma| arith farkas 2 1 1 1 1) (|unit-resolution| (lemma @x220 (or $x178 $x185)) @x206 $x178) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x177) $x198)) @x229 $x198) @x219 @x169 (|unit-resolution| @x213 @x248 $x199) false)))
-(let ((@x251 (lemma @x250 $x185)))
-(let ((@x257 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1) (or $x140 $x146 $x133)) (hypothesis $x134) @x251 $x140)))
-(let ((@x180 (|def-axiom| (or $x178 $x176))))
-(let ((@x261 (|unit-resolution| @x213 (|unit-resolution| @x173 (hypothesis $x134) $x171) $x199)))
-(let (($x184 (= ?x36 ?x149)))
-(let ((@x266 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x184) (<= (+ ?x36 (* (~ 1.0) ?x149)) 0.0))) (|unit-resolution| (|def-axiom| (or $x146 $x184)) @x251 $x184) (<= (+ ?x36 (* (~ 1.0) ?x149)) 0.0))))
-(let ((@x267 ((_ |th-lemma| arith farkas 2 1 1 1 1) @x251 @x266 @x169 @x261 (|unit-resolution| @x204 (|unit-resolution| @x180 @x257 $x176) $x194) false)))
-(let ((@x271 (|unit-resolution| (lemma @x243 (or (not $x172) $x226)) (|unit-resolution| (|def-axiom| (or $x134 $x172)) (lemma @x267 $x133) $x172) $x226)))
-(let ((@x276 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x177) $x198)) (hypothesis $x177) (lemma ((_ |th-lemma| arith farkas 1 -1 -1 1) @x266 @x169 @x271 (hypothesis $x198) false) (not $x198)) false)))
-(let ((@x278 (|unit-resolution| (|def-axiom| (or $x140 $x177)) (lemma @x276 (not $x177)) $x140)))
-((_ |th-lemma| arith farkas -2 1 -1 -1 1) @x278 @x266 @x169 @x271 (|unit-resolution| @x204 (|unit-resolution| @x180 @x278 $x176) $x194) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
+(let (($x69 (>= ?x7 0.0)))
+(let ((?x76 (ite $x69 ?x7 ?x44)))
+(let ((?x149 (* (~ 1.0) ?x76)))
+(let ((?x177 (+ ?x44 ?x149)))
+(let (($x179 (>= ?x177 0.0)))
+(let (($x128 (= ?x44 ?x76)))
+(let (($x70 (not $x69)))
+(let (($x93 (>= |y$| 0.0)))
+(let (($x94 (not $x93)))
+(let (($x152 (>= (+ ?x7 ?x149) 0.0)))
+(let (($x127 (= ?x7 ?x76)))
+(let (($x188 (not $x179)))
+(let ((@x159 (hypothesis $x93)))
+(let ((?x100 (ite $x93 |y$| ?x43)))
+(let ((?x112 (* (~ 1.0) ?x100)))
+(let ((?x113 (+ ?x76 ?x111 ?x112)))
+(let (($x114 (<= ?x113 0.0)))
+(let (($x119 (not $x114)))
+(let ((?x18 (+ (ite (< |x$| 0.0) (- |x$|) |x$|) (ite (< |y$| 0.0) (- |y$|) |y$|))))
+(let (($x20 (not (<= (ite (< ?x7 0.0) (- ?x7) ?x7) ?x18))))
+(let (($x15 (< |y$| 0.0)))
+(let ((?x57 (ite $x15 ?x43 |y$|)))
+(let (($x12 (< |x$| 0.0)))
+(let ((?x52 (ite $x12 ?x42 |x$|)))
+(let ((?x60 (+ ?x52 ?x57)))
+(let (($x9 (< ?x7 0.0)))
+(let ((?x47 (ite $x9 ?x44 ?x7)))
+(let (($x63 (<= ?x47 ?x60)))
+(let ((@x104 (trans (monotonicity (rewrite (= $x15 $x94)) (= ?x57 (ite $x94 ?x43 |y$|))) (rewrite (= (ite $x94 ?x43 |y$|) ?x100)) (= ?x57 ?x100))))
+(let ((@x87 (monotonicity (rewrite (= $x12 (not $x81))) (= ?x52 (ite (not $x81) ?x42 |x$|)))))
+(let ((@x92 (trans @x87 (rewrite (= (ite (not $x81) ?x42 |x$|) ?x88)) (= ?x52 ?x88))))
+(let ((@x80 (trans (monotonicity (rewrite (= $x9 $x70)) (= ?x47 (ite $x70 ?x44 ?x7))) (rewrite (= (ite $x70 ?x44 ?x7) ?x76)) (= ?x47 ?x76))))
+(let ((@x110 (monotonicity @x80 (monotonicity @x92 @x104 (= ?x60 (+ ?x88 ?x100))) (= $x63 (<= ?x76 (+ ?x88 ?x100))))))
+(let ((@x118 (trans @x110 (rewrite (= (<= ?x76 (+ ?x88 ?x100)) $x114)) (= $x63 $x114))))
+(let ((@x59 (monotonicity (rewrite (= (- |y$|) ?x43)) (= (ite $x15 (- |y$|) |y$|) ?x57))))
+(let ((@x54 (monotonicity (rewrite (= (- |x$|) ?x42)) (= (ite $x12 (- |x$|) |x$|) ?x52))))
+(let ((@x49 (monotonicity (rewrite (= (- ?x7) ?x44)) (= (ite $x9 (- ?x7) ?x7) ?x47))))
+(let ((@x65 (monotonicity @x49 (monotonicity @x54 @x59 (= ?x18 ?x60)) (= (<= (ite $x9 (- ?x7) ?x7) ?x18) $x63))))
+(let ((@x123 (trans (monotonicity @x65 (= $x20 (not $x63))) (monotonicity @x118 (= (not $x63) $x119)) (= $x20 $x119))))
+(let ((@x124 (mp (asserted $x20) @x123 $x119)))
+(let (($x137 (= |y$| ?x100)))
+(let ((@x172 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x137) (<= (+ |y$| ?x112) 0.0))) (|unit-resolution| (|def-axiom| (or $x94 $x137)) @x159 $x137) (<= (+ |y$| ?x112) 0.0))))
+(let ((?x148 (+ ?x42 ?x111)))
+(let (($x151 (<= ?x148 0.0)))
+(let (($x132 (= ?x42 ?x88)))
+(let (($x82 (not $x81)))
+(let ((@x157 ((_ |th-lemma| arith triangle-eq) (or (not $x131) $x147))))
+(let ((@x158 (|unit-resolution| @x157 (|unit-resolution| (|def-axiom| (or $x82 $x131)) (hypothesis $x81) $x131) $x147)))
+(let ((@x162 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1) (or $x69 $x82 $x94)) (hypothesis $x81) @x159 $x69)))
+(let ((@x126 (|def-axiom| (or $x70 $x127))))
+(let ((@x166 ((_ |th-lemma| arith triangle-eq) (or (not $x127) $x152))))
+(let ((@x173 ((_ |th-lemma| arith farkas 1 -1 -1 1) @x172 (|unit-resolution| @x166 (|unit-resolution| @x126 @x162 $x127) $x152) @x124 @x158 false)))
+(let ((@x136 (|def-axiom| (or $x81 $x132))))
+(let ((@x182 (|unit-resolution| @x136 (|unit-resolution| (lemma @x173 (or $x82 $x94)) @x159 $x82) $x132)))
+(let ((@x187 ((_ |th-lemma| arith farkas 2 -1 -1 1 1) @x159 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x132) $x151)) @x182 $x151) @x172 @x124 (hypothesis $x179) false)))
+(let ((@x196 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x128) $x179)) (hypothesis $x128) (hypothesis $x188) false)))
+(let ((@x197 (lemma @x196 (or (not $x128) $x179))))
+(let ((@x199 (|unit-resolution| @x197 (|unit-resolution| (lemma @x187 (or $x188 $x94)) @x159 $x188) (not $x128))))
+(let ((@x130 (|def-axiom| (or $x69 $x128))))
+(let ((@x202 (|unit-resolution| @x166 (|unit-resolution| @x126 (|unit-resolution| @x130 @x199 $x69) $x127) $x152)))
+(let ((@x203 ((_ |th-lemma| arith farkas 2 1 1 1 1) (|unit-resolution| (lemma @x173 (or $x82 $x94)) @x159 $x82) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x132) $x151)) @x182 $x151) @x172 @x124 @x202 false)))
+(let ((@x204 (lemma @x203 $x94)))
+(let ((@x210 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1) (or $x81 $x93 $x70)) (hypothesis $x69) @x204 $x81)))
+(let ((@x134 (|def-axiom| (or $x82 $x131))))
+(let ((@x214 (|unit-resolution| @x166 (|unit-resolution| @x126 (hypothesis $x69) $x127) $x152)))
+(let ((?x145 (+ ?x43 ?x112)))
+(let (($x176 (<= ?x145 0.0)))
+(let (($x138 (= ?x43 ?x100)))
+(let ((@x219 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x138) $x176)) (|unit-resolution| (|def-axiom| (or $x93 $x138)) @x204 $x138) $x176)))
+(let ((@x220 ((_ |th-lemma| arith farkas 2 1 1 1 1) @x204 @x219 @x124 @x214 (|unit-resolution| @x157 (|unit-resolution| @x134 @x210 $x131) $x147) false)))
+(let ((@x224 (|unit-resolution| @x197 (|unit-resolution| @x130 (lemma @x220 $x70) $x128) $x179)))
+(let ((@x229 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x132) $x151)) (hypothesis $x132) (lemma ((_ |th-lemma| arith farkas 1 -1 -1 1) @x219 @x124 @x224 (hypothesis $x151) false) (not $x151)) false)))
+(let ((@x232 (|unit-resolution| @x134 (|unit-resolution| @x136 (lemma @x229 (not $x132)) $x81) $x131)))
+((_ |th-lemma| arith farkas -2 1 -1 -1 1) (|unit-resolution| @x136 (lemma @x229 (not $x132)) $x81) @x219 @x124 @x224 (|unit-resolution| @x157 @x232 $x147) false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
 
-d11fcb5f4744241869bf523344d4028dde874c74 15 0
+f8d266138153a7b5a745c746bbb489254a734ae0 16 0
 unsat
 ((set-logic AUFLIA)
 (proof
 (let ((?x10 (|p$| true)))
-(let (($x11 (= (|p$| (ite (< 2 3) true false)) ?x10)))
+(let (($x7 (< 2 3)))
+(let (($x8 (ite $x7 true false)))
+(let ((?x9 (|p$| $x8)))
+(let (($x11 (= ?x9 ?x10)))
 (let (($x12 (not $x11)))
-(let ((@x23 (monotonicity (rewrite (= (<= 3 2) false)) (= (not (<= 3 2)) (not false)))))
-(let ((@x27 (trans @x23 (rewrite (= (not false) true)) (= (not (<= 3 2)) true))))
-(let ((@x29 (trans (rewrite (= (< 2 3) (not (<= 3 2)))) @x27 (= (< 2 3) true))))
-(let ((@x32 (monotonicity @x29 (= (ite (< 2 3) true false) (ite true true false)))))
-(let ((@x36 (trans @x32 (rewrite (= (ite true true false) true)) (= (ite (< 2 3) true false) true))))
-(let ((@x44 (trans (monotonicity (monotonicity @x36 $x11) (= $x11 (= ?x10 ?x10))) (rewrite (= (= ?x10 ?x10) true)) (= $x11 true))))
-(let ((@x51 (trans (monotonicity @x44 (= $x12 (not true))) (rewrite (= (not true) false)) (= $x12 false))))
-(mp (asserted $x12) @x51 false)))))))))))))
+(let ((@x50 (monotonicity (monotonicity (rewrite (= $x7 true)) (= (|p$| $x7) ?x10)) (= (= (|p$| $x7) ?x10) (= ?x10 ?x10)))))
+(let ((@x54 (trans @x50 (rewrite (= (= ?x10 ?x10) true)) (= (= (|p$| $x7) ?x10) true))))
+(let ((@x61 (trans (monotonicity @x54 (= (not (= (|p$| $x7) ?x10)) (not true))) (rewrite (= (not true) false)) (= (not (= (|p$| $x7) ?x10)) false))))
+(let ((@x41 (monotonicity (monotonicity (rewrite (= $x8 $x7)) (= ?x9 (|p$| $x7))) (= $x11 (= (|p$| $x7) ?x10)))))
+(let ((@x44 (monotonicity @x41 (= $x12 (not (= (|p$| $x7) ?x10))))))
+(mp (asserted $x12) (trans @x44 @x61 (= $x12 false)) false))))))))))))))
 
-118bd48c31dce91a7e08520c2c1fe2c904fc8d4f 16 0
+81a816463ea508b010daafde9e601b0b985afe71 16 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let (($x25 (<= 1 |x$|)))
-(let ((@x40 (trans (rewrite (= (< |x$| 1) (not $x25))) (monotonicity (rewrite (= $x25 $x25)) (= (not $x25) (not $x25))) (= (< |x$| 1) (not $x25)))))
-(let ((@x47 (trans (monotonicity @x40 (= (not (< |x$| 1)) (not (not $x25)))) (rewrite (= (not (not $x25)) $x25)) (= (not (< |x$| 1)) $x25))))
 (let (($x11 (< |x$| 1)))
-(let (($x17 (not $x11)))
-(let ((@x18 (|not-or-elim| (asserted (not (or (<= 4 (+ |x$| 3)) $x11))) $x17)))
-(let (($x30 (not $x25)))
-(let ((@x24 (monotonicity (rewrite (= (+ |x$| 3) (+ 3 |x$|))) (= (<= 4 (+ |x$| 3)) (<= 4 (+ 3 |x$|))))))
-(let ((@x29 (trans @x24 (rewrite (= (<= 4 (+ 3 |x$|)) $x25)) (= (<= 4 (+ |x$| 3)) $x25))))
-(let ((@x16 (|not-or-elim| (asserted (not (or (<= 4 (+ |x$| 3)) $x11))) (not (<= 4 (+ |x$| 3))))))
-(let ((@x33 (mp @x16 (monotonicity @x29 (= (not (<= 4 (+ |x$| 3))) $x30)) $x30)))
-(|unit-resolution| @x33 (mp @x18 @x47 $x25) false))))))))))))))
+(let ((?x35 (+ 3 |x$|)))
+(let (($x38 (<= 4 ?x35)))
+(let (($x41 (or $x38 $x11)))
+(let (($x44 (not $x41)))
+(let ((@x55 (monotonicity (rewrite (= $x38 (>= |x$| 1))) (rewrite (= $x11 (not (>= |x$| 1)))) (= $x41 (or (>= |x$| 1) (not (>= |x$| 1)))))))
+(let ((@x59 (trans @x55 (rewrite (= (or (>= |x$| 1) (not (>= |x$| 1))) true)) (= $x41 true))))
+(let ((@x66 (trans (monotonicity @x59 (= $x44 (not true))) (rewrite (= (not true) false)) (= $x44 false))))
+(let ((@x40 (monotonicity (rewrite (= (+ |x$| 3) ?x35)) (= (<= 4 (+ |x$| 3)) $x38))))
+(let ((@x46 (monotonicity (monotonicity @x40 (= (or (<= 4 (+ |x$| 3)) $x11) $x41)) (= (not (or (<= 4 (+ |x$| 3)) $x11)) $x44))))
+(let ((@x68 (trans @x46 @x66 (= (not (or (<= 4 (+ |x$| 3)) $x11)) false))))
+(mp (asserted (not (or (<= 4 (+ |x$| 3)) $x11))) @x68 false))))))))))))))
 
-10f47384b1edbbe0088cb4f6641650cff9776ff0 23 0
+3da41aa632fdaf484d160ab8b5a2c83b931d3de7 18 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let ((@x93 (rewrite (= (= |y$| (+ 4 |x$|)) (= (+ |x$| (* (~ 1) |y$|)) (~ 4))))))
-(let (($x25 (= |y$| (+ 4 |x$|))))
-(let ((@x29 (rewrite (= $x25 $x25))))
-(let ((@x27 (monotonicity (rewrite (= (+ |x$| 4) (+ 4 |x$|))) (= (= |y$| (+ |x$| 4)) $x25))))
-(let ((@x31 (mp (asserted (= |y$| (+ |x$| 4))) (trans @x27 @x29 (= (= |y$| (+ |x$| 4)) $x25)) $x25)))
-(let ((@x64 (mp (mp (mp @x31 (|rewrite*| (= $x25 $x25)) $x25) @x29 $x25) @x29 $x25)))
-(let ((@x110 (monotonicity (mp @x64 @x93 (= (+ |x$| (* (~ 1) |y$|)) (~ 4))) (= (>= (+ |x$| (* (~ 1) |y$|)) 0) (>= (~ 4) 0)))))
-(let ((@x112 (trans @x110 (rewrite (= (>= (~ 4) 0) false)) (= (>= (+ |x$| (* (~ 1) |y$|)) 0) false))))
-(let (($x100 (>= (+ |x$| (* (~ 1) |y$|)) 0)))
-(let ((?x34 (+ |y$| (* (~ 1) |x$|))))
-(let (($x40 (<= ?x34 0)))
-(let ((@x99 (monotonicity (rewrite (= ?x34 (+ (* (~ 1) |x$|) |y$|))) (= $x40 (<= (+ (* (~ 1) |x$|) |y$|) 0)))))
-(let ((@x104 (trans @x99 (rewrite (= (<= (+ (* (~ 1) |x$|) |y$|) 0) $x100)) (= $x40 $x100))))
-(let ((@x39 (monotonicity (rewrite (= (- |y$| |x$|) ?x34)) (= (< 0 (- |y$| |x$|)) (< 0 ?x34)))))
-(let ((@x45 (trans @x39 (rewrite (= (< 0 ?x34) (not $x40))) (= (< 0 (- |y$| |x$|)) (not $x40)))))
-(let ((@x48 (monotonicity @x45 (= (not (< 0 (- |y$| |x$|))) (not (not $x40))))))
-(let ((@x52 (trans @x48 (rewrite (= (not (not $x40)) $x40)) (= (not (< 0 (- |y$| |x$|))) $x40))))
-(let ((@x60 (mp (mp (asserted (not (< 0 (- |y$| |x$|)))) @x52 $x40) (|rewrite*| (= $x40 $x40)) $x40)))
-(mp (mp @x60 @x104 $x100) @x112 false)))))))))))))))))))))
+(let (($x52 (= (+ |x$| (* (~ 1) |y$|)) (~ 4))))
+(let ((@x46 (monotonicity (rewrite (= (+ |x$| 4) (+ 4 |x$|))) (= (= |y$| (+ |x$| 4)) (= |y$| (+ 4 |x$|))))))
+(let ((@x55 (trans @x46 (rewrite (= (= |y$| (+ 4 |x$|)) $x52)) (= (= |y$| (+ |x$| 4)) $x52))))
+(let ((@x84 (monotonicity (mp (asserted (= |y$| (+ |x$| 4))) @x55 $x52) (= (>= (+ |x$| (* (~ 1) |y$|)) 0) (>= (~ 4) 0)))))
+(let ((@x88 (trans @x84 (rewrite (= (>= (~ 4) 0) false)) (= (>= (+ |x$| (* (~ 1) |y$|)) 0) false))))
+(let (($x68 (>= (+ |x$| (* (~ 1) |y$|)) 0)))
+(let ((@x74 (monotonicity (rewrite (= (< 0 (+ (* (~ 1) |x$|) |y$|)) (not $x68))) (= (not (< 0 (+ (* (~ 1) |x$|) |y$|))) (not (not $x68))))))
+(let ((@x78 (trans @x74 (rewrite (= (not (not $x68)) $x68)) (= (not (< 0 (+ (* (~ 1) |x$|) |y$|))) $x68))))
+(let (($x62 (< 0 (+ (* (~ 1) |x$|) |y$|))))
+(let (($x65 (not $x62)))
+(let (($x15 (not (< 0 (- |y$| |x$|)))))
+(let ((@x64 (monotonicity (rewrite (= (- |y$| |x$|) (+ (* (~ 1) |x$|) |y$|))) (= (< 0 (- |y$| |x$|)) $x62))))
+(let ((@x81 (mp (asserted $x15) (trans (monotonicity @x64 (= $x15 $x65)) @x78 (= $x15 $x68)) $x68)))
+(mp @x81 @x88 false))))))))))))))))
 
-aa7e091783f91e1fa3f52d47f54666f367d1bb36 11 0
+e43b05132d28d45640c9d0131930806093dbb0e2 11 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let ((@x17 (monotonicity (rewrite (= (+ 2 2) 4)) (= (= (+ 2 2) 5) (= 4 5)))))
-(let ((@x23 (trans @x17 (rewrite (= (= 4 5) false)) (= (= (+ 2 2) 5) false))))
-(let ((@x26 (monotonicity @x23 (= (not (= (+ 2 2) 5)) (not false)))))
-(let ((@x30 (trans @x26 (rewrite (= (not false) true)) (= (not (= (+ 2 2) 5)) true))))
-(let ((@x33 (monotonicity @x30 (= (not (not (= (+ 2 2) 5))) (not true)))))
-(let ((@x37 (trans @x33 (rewrite (= (not true) false)) (= (not (not (= (+ 2 2) 5))) false))))
-(mp (asserted (not (not (= (+ 2 2) 5)))) @x37 false)))))))))
+(let ((@x37 (monotonicity (rewrite (= (+ 2 2) 4)) (= (= (+ 2 2) 5) (= 4 5)))))
+(let ((@x41 (trans @x37 (rewrite (= (= 4 5) false)) (= (= (+ 2 2) 5) false))))
+(let ((@x44 (monotonicity @x41 (= (not (= (+ 2 2) 5)) (not false)))))
+(let ((@x48 (trans @x44 (rewrite (= (not false) true)) (= (not (= (+ 2 2) 5)) true))))
+(let ((@x51 (monotonicity @x48 (= (not (not (= (+ 2 2) 5))) (not true)))))
+(let ((@x55 (trans @x51 (rewrite (= (not true) false)) (= (not (not (= (+ 2 2) 5))) false))))
+(mp (asserted (not (not (= (+ 2 2) 5)))) @x55 false)))))))))
 
-8f1ec6af8997aeb8e9888ff48bba8de209292f6d 22 0
+135df42816691c806246099ddf6fc7f6b81a2f42 19 0
 unsat
 ((set-logic AUFLIRA)
 (proof
-(let ((?x11 (+ (* 3.0 |x$|) (* 7.0 |a$|))))
-(let (($x23 (<= 4.0 ?x11)))
-(let (($x24 (not $x23)))
-(let ((@x100 (monotonicity (rewrite (= $x23 (>= ?x11 4.0))) (= $x24 (not (>= ?x11 4.0))))))
-(let ((@x30 (monotonicity (rewrite (= $x23 $x23)) (= $x24 $x24))))
-(let ((@x31 (trans (rewrite (= (< ?x11 4.0) $x24)) @x30 (= (< ?x11 4.0) $x24))))
-(let ((@x65 (mp (mp (asserted (< ?x11 4.0)) @x31 $x24) (|rewrite*| (= $x24 $x24)) $x24)))
-(let (($x47 (<= 0.0 |a$|)))
-(let ((@x52 (rewrite (= $x47 $x47))))
-(let ((@x55 (trans (rewrite (= (< |a$| 0.0) (not $x47))) (monotonicity @x52 (= (not $x47) (not $x47))) (= (< |a$| 0.0) (not $x47)))))
-(let ((@x62 (trans (monotonicity @x55 (= (not (< |a$| 0.0)) (not (not $x47)))) (rewrite (= (not (not $x47)) $x47)) (= (not (< |a$| 0.0)) $x47))))
-(let ((@x70 (mp (mp (asserted (not (< |a$| 0.0))) @x62 $x47) (|rewrite*| (= $x47 $x47)) $x47)))
-(let ((@x105 (mp (mp (mp @x70 @x52 $x47) @x52 $x47) (rewrite (= $x47 (>= |a$| 0.0))) (>= |a$| 0.0))))
-(let (($x41 (not (<= |x$| (/ 3.0 2.0)))))
-(let ((@x43 (monotonicity (rewrite (= (<= (* 2.0 |x$|) 3.0) (<= |x$| (/ 3.0 2.0)))) (= (not (<= (* 2.0 |x$|) 3.0)) $x41))))
-(let ((@x36 (rewrite (= (< 3.0 (* 2.0 |x$|)) (not (<= (* 2.0 |x$|) 3.0))))))
-(let ((@x46 (mp (asserted (< 3.0 (* 2.0 |x$|))) (trans @x36 @x43 (= (< 3.0 (* 2.0 |x$|)) $x41)) $x41)))
-((_ |th-lemma| arith farkas 3 7 1) (mp @x46 (|rewrite*| (= $x41 $x41)) $x41) @x105 (mp (mp (mp @x65 @x30 $x24) @x30 $x24) @x100 (not (>= ?x11 4.0))) false))))))))))))))))))))
+(let ((?x10 (* 7.0 |a$|)))
+(let ((?x7 (* 3.0 |x$|)))
+(let ((?x11 (+ ?x7 ?x10)))
+(let (($x46 (>= ?x11 4.0)))
+(let (($x44 (not $x46)))
+(let ((@x43 (mp (asserted (< ?x11 4.0)) (rewrite (= (< ?x11 4.0) $x44)) $x44)))
+(let ((?x15 (* 2.0 |x$|)))
+(let (($x48 (<= ?x15 3.0)))
+(let (($x49 (not $x48)))
+(let ((@x52 (mp (asserted (< 3.0 ?x15)) (rewrite (= (< 3.0 ?x15) $x49)) $x49)))
+(let (($x56 (>= |a$| 0.0)))
+(let ((@x60 (monotonicity (rewrite (= (< |a$| 0.0) (not $x56))) (= (not (< |a$| 0.0)) (not (not $x56))))))
+(let ((@x64 (trans @x60 (rewrite (= (not (not $x56)) $x56)) (= (not (< |a$| 0.0)) $x56))))
+(let ((@x65 (mp (asserted (not (< |a$| 0.0))) @x64 $x56)))
+((_ |th-lemma| arith farkas 7 3/2 1) @x65 @x52 @x43 false)))))))))))))))))
 
-123ff9b46d34a4f3a7f6c3b75522584cd621fb1d 22 0
+de926642fcc1657dfaa079f1656df9cc74f3caaf 22 0
 unsat
 ((set-logic AUFLIA)
 (proof
+(let (($x17 (not false)))
 (let (($x13 (<= 0 |x$|)))
 (let (($x14 (not $x13)))
 (let (($x15 (or $x14 $x13)))
-(let (($x16 (or (<= 0 (+ |y$| (* (- 1) |x$|))) $x15)))
-(let (($x18 (= $x16 (not false))))
+(let ((?x8 (- 1)))
+(let ((?x10 (* ?x8 |x$|)))
+(let ((?x11 (+ |y$| ?x10)))
+(let (($x12 (<= 0 ?x11)))
+(let (($x16 (or $x12 $x15)))
+(let (($x18 (= $x16 $x17)))
 (let (($x19 (not $x18)))
-(let ((@x49 (rewrite (= (or (<= 0 (+ |y$| (* (~ 1) |x$|))) true) true))))
-(let ((@x41 (monotonicity (monotonicity (rewrite (= $x13 $x13)) (= $x14 $x14)) (rewrite (= $x13 $x13)) (= $x15 $x15))))
-(let (($x30 (<= 0 (+ |y$| (* (~ 1) |x$|)))))
-(let ((@x26 (monotonicity (rewrite (= (- 1) (~ 1))) (= (* (- 1) |x$|) (* (~ 1) |x$|)))))
-(let ((@x29 (monotonicity @x26 (= (+ |y$| (* (- 1) |x$|)) (+ |y$| (* (~ 1) |x$|))))))
-(let ((@x32 (monotonicity @x29 (= (<= 0 (+ |y$| (* (- 1) |x$|))) $x30))))
-(let ((@x35 (trans @x32 (rewrite (= $x30 $x30)) (= (<= 0 (+ |y$| (* (- 1) |x$|))) $x30))))
-(let ((@x47 (monotonicity @x35 (trans @x41 (rewrite (= $x15 true)) (= $x15 true)) (= $x16 (or $x30 true)))))
-(let ((@x56 (monotonicity (trans @x47 @x49 (= $x16 true)) (rewrite (= (not false) true)) (= $x18 (= true true)))))
-(let ((@x60 (trans @x56 (rewrite (= (= true true) true)) (= $x18 true))))
-(let ((@x67 (trans (monotonicity @x60 (= $x19 (not true))) (rewrite (= (not true) false)) (= $x19 false))))
-(mp (asserted $x19) @x67 false))))))))))))))))))))
+(let ((@x58 (rewrite (= (or (<= 0 (+ |y$| (* (~ 1) |x$|))) true) true))))
+(let ((@x48 (monotonicity (monotonicity (rewrite (= ?x8 (~ 1))) (= ?x10 (* (~ 1) |x$|))) (= ?x11 (+ |y$| (* (~ 1) |x$|))))))
+(let ((@x56 (monotonicity (monotonicity @x48 (= $x12 (<= 0 (+ |y$| (* (~ 1) |x$|))))) (rewrite (= $x15 true)) (= $x16 (or (<= 0 (+ |y$| (* (~ 1) |x$|))) true)))))
+(let ((@x65 (monotonicity (trans @x56 @x58 (= $x16 true)) (rewrite (= $x17 true)) (= $x18 (= true true)))))
+(let ((@x69 (trans @x65 (rewrite (= (= true true) true)) (= $x18 true))))
+(let ((@x76 (trans (monotonicity @x69 (= $x19 (not true))) (rewrite (= (not true) false)) (= $x19 false))))
+(mp (asserted $x19) @x76 false))))))))))))))))))))
 
-3162fe55c0ec329908fcb4e022c32656696c4c11 223 0
+c19a59241b121ac2665c4fbd7ba1fa2d48fef984 159 0
 unsat
 ((set-logic AUFLIA)
 (proof
 (let (($x22 (= |m$| |n$|)))
-(let ((@x700 (symm (commutativity (= $x22 (= |n$| |m$|))) (= (= |n$| |m$|) $x22))))
+(let ((@x478 (symm (commutativity (= $x22 (= |n$| |m$|))) (= (= |n$| |m$|) $x22))))
 (let (($x18 (= |n$| |m$|)))
-(let (($x312 (>= (+ |n$| (* (~ 1) |m$|)) 0)))
-(let (($x348 (<= (+ |m$| (* (~ 1) |n$a|)) 0)))
-(let (($x342 (>= (+ |n$| (* (~ 1) |n$a|)) 0)))
-(let (($x459 (or $x342 $x348)))
-(let ((@x471 (monotonicity (rewrite (= (and (not $x342) (not $x348)) (not $x459))) (= (not (and (not $x342) (not $x348))) (not (not $x459))))))
-(let ((@x491 (trans @x471 (rewrite (= (not (not $x459)) $x459)) (= (not (and (not $x342) (not $x348))) $x459))))
-(let (($x351 (not $x348)))
-(let (($x345 (not $x342)))
-(let (($x354 (and $x345 $x351)))
-(let (($x357 (not $x354)))
-(let ((@x353 (monotonicity (rewrite (= (<= |m$| |n$a|) $x348)) (= (not (<= |m$| |n$a|)) $x351))))
-(let ((@x347 (monotonicity (rewrite (= (<= |n$a| |n$|) $x342)) (= (not (<= |n$a| |n$|)) $x345))))
-(let ((@x356 (monotonicity @x347 @x353 (= (and (not (<= |n$a| |n$|)) (not (<= |m$| |n$a|))) $x354))))
-(let ((@x359 (monotonicity @x356 (= (not (and (not (<= |n$a| |n$|)) (not (<= |m$| |n$a|)))) $x357))))
-(let (($x140 (not (<= |m$| |n$a|))))
-(let (($x136 (not (<= |n$a| |n$|))))
-(let (($x143 (and $x136 $x140)))
-(let (($x146 (not $x143)))
-(let ((@x142 (rewrite (= (< |n$a| |m$|) $x140))))
-(let ((@x145 (monotonicity (rewrite (= (< |n$| |n$a|) $x136)) @x142 (= (and (< |n$| |n$a|) (< |n$a| |m$|)) $x143))))
-(let ((@x148 (monotonicity @x145 (= (not (and (< |n$| |n$a|) (< |n$a| |m$|))) $x146))))
-(let (($x37 (or (and $x22 (< |n$| |n$a|)) (or (and (= |m$| |n$a|) (< |n$a| |n$|)) (and (= |n$a| |m$|) $x22)))))
-(let (($x24 (< |n$a| |n$|)))
-(let (($x9 (< |m$| |n$a|)))
-(let (($x32 (and $x9 $x24)))
-(let (($x26 (= |n$a| |n$|)))
-(let (($x20 (< |m$| |n$|)))
-(let (($x31 (and $x20 $x26)))
-(let (($x13 (< |n$| |n$a|)))
-(let (($x30 (and $x20 $x13)))
-(let (($x42 (or (and $x26 (< |n$| |m$|)) (or (and (= |n$a| |m$|) $x20) (or $x30 (or $x31 (or $x32 $x37)))))))
-(let (($x7 (< |n$| |m$|)))
-(let (($x25 (and $x24 $x7)))
-(let (($x14 (< |n$a| |m$|)))
-(let (($x23 (and $x14 $x22)))
-(let (($x21 (and $x14 $x20)))
-(let (($x19 (and $x18 $x9)))
-(let (($x16 (= |n$| |n$a|)))
-(let (($x17 (and $x16 $x14)))
-(let (($x15 (and $x13 $x14)))
-(let (($x59 (not (or $x15 (or $x17 (or $x19 (or $x21 (or $x23 (or $x25 $x42)))))))))
+(let ((?x100 (* (~ 1) |m$|)))
+(let ((?x101 (+ |n$| ?x100)))
+(let (($x116 (>= ?x101 0)))
+(let ((?x76 (* (~ 1) |n$a|)))
+(let ((?x94 (+ |m$| ?x76)))
+(let (($x125 (<= ?x94 0)))
+(let ((?x77 (+ |n$| ?x76)))
+(let (($x86 (>= ?x77 0)))
+(let (($x259 (or $x86 $x125)))
+(let ((@x265 (monotonicity (rewrite (= (and (not $x86) (not $x125)) (not $x259))) (= (not (and (not $x86) (not $x125))) (not (not $x259))))))
+(let ((@x269 (trans @x265 (rewrite (= (not (not $x259)) $x259)) (= (not (and (not $x86) (not $x125))) $x259))))
+(let (($x126 (not $x125)))
+(let (($x85 (not $x86)))
+(let (($x141 (and $x85 $x126)))
+(let (($x208 (not $x141)))
+(let (($x28 (= |n$a| |m$|)))
+(let (($x35 (and $x28 $x22)))
+(let (($x78 (<= ?x77 0)))
+(let (($x79 (not $x78)))
 (let (($x11 (= |m$| |n$a|)))
-(let (($x12 (and $x7 $x11)))
-(let (($x49 (or $x12 (or $x15 (or $x17 (or $x19 (or $x21 (or $x23 (or $x25 $x42)))))))))
-(let ((@x60 (|not-or-elim| (|not-or-elim| (asserted (not (or (and $x7 $x9) $x49))) (not $x49)) $x59)))
-(let ((@x250 (mp (mp (|not-or-elim| @x60 (not $x15)) @x148 $x146) (|rewrite*| (= $x146 $x146)) $x146)))
-(let ((@x674 (|unit-resolution| (mp (mp @x250 @x359 $x357) @x491 $x459) (hypothesis $x351) $x342)))
-(let (($x493 (not $x16)))
-(let (($x494 (or $x493 $x348)))
-(let ((@x500 (monotonicity (rewrite (= (and $x16 $x351) (not $x494))) (= (not (and $x16 $x351)) (not (not $x494))))))
-(let ((@x504 (trans @x500 (rewrite (= (not (not $x494)) $x494)) (= (not (and $x16 $x351)) $x494))))
-(let (($x361 (and $x16 $x351)))
-(let (($x364 (not $x361)))
-(let ((@x366 (monotonicity (monotonicity @x353 (= (and $x16 $x140) $x361)) (= (not (and $x16 $x140)) $x364))))
-(let (($x150 (and $x16 $x140)))
-(let (($x153 (not $x150)))
-(let ((@x155 (monotonicity (monotonicity @x142 (= $x17 $x150)) (= (not $x17) $x153))))
-(let ((@x64 (|not-or-elim| @x60 (not (or $x17 (or $x19 (or $x21 (or $x23 (or $x25 $x42)))))))))
-(let ((@x253 (mp (mp (|not-or-elim| @x64 (not $x17)) @x155 $x153) (|rewrite*| (= $x153 $x153)) $x153)))
-(let ((@x675 (|unit-resolution| (mp (mp @x253 @x366 $x364) @x504 $x494) (hypothesis $x351) $x493)))
-(let (($x395 (<= (+ |n$| (* (~ 1) |n$a|)) 0)))
-(let (($x506 (not $x18)))
-(let (($x531 (not $x22)))
-(let (($x319 (>= (+ |m$| (* (~ 1) |n$a|)) 0)))
-(let (($x398 (not $x395)))
-(let ((@x654 (hypothesis $x398)))
-(let (($x606 (or $x319 $x395)))
-(let ((@x612 (monotonicity (rewrite (= (and (not $x319) $x398) (not $x606))) (= (not (and (not $x319) $x398)) (not (not $x606))))))
-(let ((@x616 (trans @x612 (rewrite (= (not (not $x606)) $x606)) (= (not (and (not $x319) $x398)) $x606))))
-(let (($x324 (not $x319)))
-(let (($x436 (and $x324 $x398)))
-(let (($x439 (not $x436)))
-(let ((@x400 (monotonicity (rewrite (= (<= |n$| |n$a|) $x395)) (= (not (<= |n$| |n$a|)) $x398))))
-(let ((@x326 (monotonicity (rewrite (= (<= |n$a| |m$|) $x319)) (= (not (<= |n$a| |m$|)) $x324))))
-(let ((@x438 (monotonicity @x326 @x400 (= (and (not (<= |n$a| |m$|)) (not (<= |n$| |n$a|))) $x436))))
-(let ((@x441 (monotonicity @x438 (= (not (and (not (<= |n$a| |m$|)) (not (<= |n$| |n$a|)))) $x439))))
-(let (($x183 (not (<= |n$| |n$a|))))
-(let (($x118 (not (<= |n$a| |m$|))))
-(let (($x221 (and $x118 $x183)))
-(let (($x224 (not $x221)))
-(let ((@x185 (rewrite (= $x24 $x183))))
-(let ((@x120 (rewrite (= $x9 $x118))))
-(let ((@x226 (monotonicity (monotonicity @x120 @x185 (= $x32 $x221)) (= (not $x32) $x224))))
-(let (($x87 (not (or (and (= |n$a| |m$|) $x20) (or $x30 (or $x31 (or $x32 $x37)))))))
-(let ((@x68 (|not-or-elim| @x64 (not (or $x19 (or $x21 (or $x23 (or $x25 $x42))))))))
-(let ((@x76 (|not-or-elim| (|not-or-elim| @x68 (not (or $x21 (or $x23 (or $x25 $x42))))) (not (or $x23 (or $x25 $x42))))))
-(let ((@x88 (|not-or-elim| (|not-or-elim| (|not-or-elim| @x76 (not (or $x25 $x42))) (not $x42)) $x87)))
-(let ((@x96 (|not-or-elim| (|not-or-elim| @x88 (not (or $x30 (or $x31 (or $x32 $x37))))) (not (or $x31 (or $x32 $x37))))))
-(let ((@x227 (mp (|not-or-elim| (|not-or-elim| @x96 (not (or $x32 $x37))) (not $x32)) @x226 $x224)))
-(let ((@x617 (mp (mp (mp @x227 (|rewrite*| (= $x224 $x224)) $x224) @x441 $x439) @x616 $x606)))
-(let (($x466 (not $x11)))
-(let (($x630 (or $x466 $x395)))
-(let ((@x636 (monotonicity (rewrite (= (and $x11 $x398) (not $x630))) (= (not (and $x11 $x398)) (not (not $x630))))))
-(let ((@x640 (trans @x636 (rewrite (= (not (not $x630)) $x630)) (= (not (and $x11 $x398)) $x630))))
-(let (($x450 (and $x11 $x398)))
-(let (($x453 (not $x450)))
-(let ((@x455 (monotonicity (monotonicity @x400 (= (and $x11 $x183) $x450)) (= (not (and $x11 $x183)) $x453))))
-(let (($x235 (and $x11 $x183)))
-(let (($x238 (not $x235)))
-(let ((@x240 (monotonicity (monotonicity @x185 (= (and $x11 $x24) $x235)) (= (not (and $x11 $x24)) $x238))))
-(let ((@x108 (|not-or-elim| (|not-or-elim| (|not-or-elim| @x96 (not (or $x32 $x37))) (not $x37)) (not (or (and $x11 $x24) (and (= |n$a| |m$|) $x22))))))
-(let ((@x286 (mp (mp (|not-or-elim| @x108 (not (and $x11 $x24))) @x240 $x238) (|rewrite*| (= $x238 $x238)) $x238)))
-(let ((@x659 ((_ |th-lemma| arith triangle-eq) (or $x11 $x351 $x324))))
-(let ((@x660 (|unit-resolution| @x659 (|unit-resolution| (mp (mp @x286 @x455 $x453) @x640 $x630) @x654 $x466) (|unit-resolution| @x617 @x654 $x319) $x351)))
-(let (($x532 (or $x348 $x531)))
-(let ((@x538 (monotonicity (rewrite (= (and $x351 $x22) (not $x532))) (= (not (and $x351 $x22)) (not (not $x532))))))
-(let ((@x542 (trans @x538 (rewrite (= (not (not $x532)) $x532)) (= (not (and $x351 $x22)) $x532))))
-(let (($x388 (and $x351 $x22)))
-(let (($x391 (not $x388)))
-(let ((@x393 (monotonicity (monotonicity @x353 (= (and $x140 $x22) $x388)) (= (not (and $x140 $x22)) $x391))))
-(let (($x175 (and $x140 $x22)))
-(let (($x178 (not $x175)))
-(let ((@x180 (monotonicity (monotonicity @x142 (= $x23 $x175)) (= (not $x23) $x178))))
-(let ((@x262 (mp (mp (|not-or-elim| @x76 (not $x23)) @x180 $x178) (|rewrite*| (= $x178 $x178)) $x178)))
-(let ((@x670 (mp (|unit-resolution| (mp (mp @x262 @x393 $x391) @x542 $x532) @x660 $x531) (monotonicity (commutativity (= $x22 $x18)) (= $x531 $x506)) $x506)))
-(let (($x544 (or $x395 $x312)))
-(let ((@x550 (monotonicity (rewrite (= (and $x398 (not $x312)) (not $x544))) (= (not (and $x398 (not $x312))) (not (not $x544))))))
-(let ((@x554 (trans @x550 (rewrite (= (not (not $x544)) $x544)) (= (not (and $x398 (not $x312))) $x544))))
-(let (($x316 (not $x312)))
-(let (($x401 (and $x398 $x316)))
-(let (($x404 (not $x401)))
-(let ((@x318 (monotonicity (rewrite (= (<= |m$| |n$|) $x312)) (= (not (<= |m$| |n$|)) $x316))))
-(let ((@x406 (monotonicity (monotonicity @x400 @x318 (= (and $x183 (not (<= |m$| |n$|))) $x401)) (= (not (and $x183 (not (<= |m$| |n$|)))) $x404))))
-(let (($x114 (not (<= |m$| |n$|))))
-(let (($x186 (and $x183 $x114)))
-(let (($x189 (not $x186)))
-(let ((@x191 (monotonicity (monotonicity @x185 (rewrite (= $x7 $x114)) (= $x25 $x186)) (= (not $x25) $x189))))
-(let ((@x192 (mp (|not-or-elim| (|not-or-elim| @x76 (not (or $x25 $x42))) (not $x25)) @x191 $x189)))
-(let ((@x555 (mp (mp (mp @x192 (|rewrite*| (= $x189 $x189)) $x189) @x406 $x404) @x554 $x544)))
-(let (($x375 (<= (+ |n$| (* (~ 1) |m$|)) 0)))
-(let (($x519 (or $x348 $x375)))
-(let ((@x525 (monotonicity (rewrite (= (and $x351 (not $x375)) (not $x519))) (= (not (and $x351 (not $x375))) (not (not $x519))))))
-(let ((@x529 (trans @x525 (rewrite (= (not (not $x519)) $x519)) (= (not (and $x351 (not $x375))) $x519))))
-(let (($x378 (not $x375)))
-(let (($x381 (and $x351 $x378)))
-(let (($x384 (not $x381)))
-(let ((@x380 (monotonicity (rewrite (= (<= |n$| |m$|) $x375)) (= (not (<= |n$| |m$|)) $x378))))
-(let ((@x386 (monotonicity (monotonicity @x353 @x380 (= (and $x140 (not (<= |n$| |m$|))) $x381)) (= (not (and $x140 (not (<= |n$| |m$|)))) $x384))))
-(let (($x165 (not (<= |n$| |m$|))))
-(let (($x168 (and $x140 $x165)))
-(let (($x171 (not $x168)))
-(let ((@x173 (monotonicity (monotonicity @x142 (rewrite (= $x20 $x165)) (= $x21 $x168)) (= (not $x21) $x171))))
-(let ((@x74 (|not-or-elim| (|not-or-elim| @x68 (not (or $x21 (or $x23 (or $x25 $x42))))) (not $x21))))
-(let ((@x387 (mp (mp (mp @x74 @x173 $x171) (|rewrite*| (= $x171 $x171)) $x171) @x386 $x384)))
-(let ((@x664 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x18 $x378 $x316)) (|unit-resolution| (mp @x387 @x529 $x519) @x660 $x375) (|unit-resolution| @x555 @x654 $x312) $x18)))
-(let ((@x679 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x16 $x398 $x345)) (lemma (|unit-resolution| @x664 @x670 false) $x395) (or $x16 $x345))))
-(let (($x474 (or $x312 $x319)))
-(let ((@x482 (monotonicity (rewrite (= (and $x316 $x324) (not $x474))) (= (not (and $x316 $x324)) (not (not $x474))))))
-(let ((@x476 (trans @x482 (rewrite (= (not (not $x474)) $x474)) (= (not (and $x316 $x324)) $x474))))
-(let (($x327 (and $x316 $x324)))
-(let (($x330 (not $x327)))
-(let ((@x332 (monotonicity (monotonicity @x318 @x326 (= (and $x114 $x118) $x327)) (= (not (and $x114 $x118)) $x330))))
-(let (($x121 (and $x114 $x118)))
-(let (($x124 (not $x121)))
-(let ((@x116 (rewrite (= $x7 $x114))))
-(let ((@x126 (monotonicity (monotonicity @x116 @x120 (= (and $x7 $x9) $x121)) (= (not (and $x7 $x9)) $x124))))
-(let ((@x54 (|not-or-elim| (asserted (not (or (and $x7 $x9) $x49))) (not (and $x7 $x9)))))
-(let ((@x333 (mp (mp (mp @x54 @x126 $x124) (|rewrite*| (= $x124 $x124)) $x124) @x332 $x330)))
-(let (($x467 (or $x312 $x466)))
-(let ((@x479 (monotonicity (rewrite (= (and $x316 $x11) (not $x467))) (= (not (and $x316 $x11)) (not (not $x467))))))
-(let ((@x465 (trans @x479 (rewrite (= (not (not $x467)) $x467)) (= (not (and $x316 $x11)) $x467))))
-(let (($x334 (and $x316 $x11)))
-(let (($x337 (not $x334)))
-(let ((@x339 (monotonicity (monotonicity @x318 (= (and $x114 $x11) $x334)) (= (not (and $x114 $x11)) $x337))))
-(let (($x128 (and $x114 $x11)))
-(let (($x131 (not $x128)))
-(let ((@x133 (monotonicity (monotonicity @x116 (= $x12 $x128)) (= (not $x12) $x131))))
-(let ((@x58 (|not-or-elim| (|not-or-elim| (asserted (not (or (and $x7 $x9) $x49))) (not $x49)) (not $x12))))
-(let ((@x340 (mp (mp (mp @x58 @x133 $x131) (|rewrite*| (= $x131 $x131)) $x131) @x339 $x337)))
-(let ((@x685 (|unit-resolution| @x659 (|unit-resolution| (mp @x340 @x465 $x467) (hypothesis $x316) $x466) (|unit-resolution| (mp @x333 @x476 $x474) (hypothesis $x316) $x319) (lemma (|unit-resolution| @x679 @x675 @x674 false) $x348) false)))
-(let (($x556 (not $x26)))
-(let (($x594 (or $x375 $x556)))
-(let ((@x600 (monotonicity (rewrite (= (and $x378 $x26) (not $x594))) (= (not (and $x378 $x26)) (not (not $x594))))))
-(let ((@x604 (trans @x600 (rewrite (= (not (not $x594)) $x594)) (= (not (and $x378 $x26)) $x594))))
-(let (($x429 (and $x378 $x26)))
-(let (($x432 (not $x429)))
-(let ((@x434 (monotonicity (monotonicity @x380 (= (and $x165 $x26) $x429)) (= (not (and $x165 $x26)) $x432))))
-(let (($x214 (and $x165 $x26)))
-(let (($x217 (not $x214)))
-(let ((@x219 (monotonicity (monotonicity (rewrite (= $x20 $x165)) (= $x31 $x214)) (= (not $x31) $x217))))
-(let ((@x277 (mp (mp (|not-or-elim| @x96 (not $x31)) @x219 $x217) (|rewrite*| (= $x217 $x217)) $x217)))
-(let ((@x690 (|unit-resolution| (mp (mp @x277 @x434 $x432) @x604 $x594) (hypothesis $x378) $x556)))
-(let ((@x695 (mp @x690 (monotonicity (commutativity (= $x26 $x16)) (= $x556 $x493)) $x493)))
-(let (($x582 (or $x375 $x342)))
-(let ((@x588 (monotonicity (rewrite (= (and $x378 $x345) (not $x582))) (= (not (and $x378 $x345)) (not (not $x582))))))
-(let ((@x592 (trans @x588 (rewrite (= (not (not $x582)) $x582)) (= (not (and $x378 $x345)) $x582))))
-(let (($x422 (and $x378 $x345)))
-(let (($x425 (not $x422)))
-(let ((@x427 (monotonicity (monotonicity @x380 @x347 (= (and $x165 $x136) $x422)) (= (not (and $x165 $x136)) $x425))))
-(let (($x207 (and $x165 $x136)))
-(let (($x210 (not $x207)))
-(let ((@x167 (rewrite (= $x20 $x165))))
-(let ((@x212 (monotonicity (monotonicity @x167 (rewrite (= $x13 $x136)) (= $x30 $x207)) (= (not $x30) $x210))))
-(let ((@x94 (|not-or-elim| (|not-or-elim| @x88 (not (or $x30 (or $x31 (or $x32 $x37))))) (not $x30))))
-(let ((@x428 (mp (mp (mp @x94 @x212 $x210) (|rewrite*| (= $x210 $x210)) $x210) @x427 $x425)))
-(let ((@x689 (|unit-resolution| @x679 (|unit-resolution| (mp @x428 @x592 $x582) (hypothesis $x378) $x342) $x16)))
-(let ((@x698 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x18 $x378 $x316)) (lemma (|unit-resolution| @x689 @x695 false) $x375) (lemma @x685 $x312) $x18)))
-(let (($x28 (= |n$a| |m$|)))
-(let (($x507 (or $x506 $x319)))
-(let ((@x513 (monotonicity (rewrite (= (and $x18 $x324) (not $x507))) (= (not (and $x18 $x324)) (not (not $x507))))))
-(let ((@x517 (trans @x513 (rewrite (= (not (not $x507)) $x507)) (= (not (and $x18 $x324)) $x507))))
-(let (($x368 (and $x18 $x324)))
-(let (($x371 (not $x368)))
-(let ((@x373 (monotonicity (monotonicity @x326 (= (and $x18 $x118) $x368)) (= (not (and $x18 $x118)) $x371))))
-(let (($x157 (and $x18 $x118)))
-(let (($x160 (not $x157)))
-(let ((@x162 (monotonicity (monotonicity @x120 (= $x19 $x157)) (= (not $x19) $x160))))
-(let ((@x256 (mp (mp (|not-or-elim| @x68 (not $x19)) @x162 $x160) (|rewrite*| (= $x160 $x160)) $x160)))
-(let ((@x703 (|unit-resolution| @x659 (|unit-resolution| (mp (mp @x256 @x373 $x371) @x517 $x507) @x698 $x319) (lemma (|unit-resolution| @x679 @x675 @x674 false) $x348) $x11)))
-(let (($x642 (or (not $x28) $x531)))
-(let ((@x648 (monotonicity (rewrite (= (and $x28 $x22) (not $x642))) (= (not (and $x28 $x22)) (not (not $x642))))))
-(let ((@x652 (trans @x648 (rewrite (= (not (not $x642)) $x642)) (= (not (and $x28 $x22)) $x642))))
-(let (($x35 (and $x28 $x22)))
-(let (($x111 (not $x35)))
-(let ((@x653 (mp (mp (|not-or-elim| @x108 $x111) (|rewrite*| (= $x111 $x111)) $x111) @x652 $x642)))
-(|unit-resolution| @x653 (mp @x703 (symm (commutativity (= $x28 $x11)) (= $x11 $x28)) $x28) (mp @x698 @x700 $x22) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
+(let (($x82 (and $x11 $x79)))
+(let (($x89 (and $x22 $x85)))
+(let (($x93 (>= ?x94 0)))
+(let (($x92 (not $x93)))
+(let (($x97 (and $x92 $x79)))
+(let (($x26 (= |n$a| |n$|)))
+(let (($x102 (<= ?x101 0)))
+(let (($x103 (not $x102)))
+(let (($x106 (and $x103 $x26)))
+(let (($x109 (and $x103 $x85)))
+(let (($x112 (and $x28 $x103)))
+(let (($x115 (not $x116)))
+(let (($x119 (and $x26 $x115)))
+(let (($x122 (and $x79 $x115)))
+(let (($x129 (and $x126 $x22)))
+(let (($x132 (and $x126 $x103)))
+(let (($x135 (and $x18 $x92)))
+(let (($x16 (= |n$| |n$a|)))
+(let (($x138 (and $x16 $x126)))
+(let (($x144 (and $x115 $x11)))
+(let (($x147 (and $x115 $x92)))
+(let (($x195 (or $x147 $x144 $x141 $x138 $x135 $x132 $x129 $x122 $x119 $x112 $x109 $x106 $x97 $x89 $x82 $x35)))
+(let (($x38 (or (and (< |m$| |n$a|) (< |n$a| |n$|)) (or (and $x22 (< |n$| |n$a|)) (or (and $x11 (< |n$a| |n$|)) $x35)))))
+(let (($x40 (or (and (< |m$| |n$|) (< |n$| |n$a|)) (or (and (< |m$| |n$|) $x26) $x38))))
+(let (($x43 (or (and (< |n$a| |n$|) (< |n$| |m$|)) (or (and $x26 (< |n$| |m$|)) (or (and $x28 (< |m$| |n$|)) $x40)))))
+(let (($x45 (or (and (< |n$a| |m$|) (< |m$| |n$|)) (or (and (< |n$a| |m$|) $x22) $x43))))
+(let (($x48 (or (and (< |n$| |n$a|) (< |n$a| |m$|)) (or (and $x16 (< |n$a| |m$|)) (or (and $x18 (< |m$| |n$a|)) $x45)))))
+(let (($x50 (or (and (< |n$| |m$|) (< |m$| |n$a|)) (or (and (< |n$| |m$|) $x11) $x48))))
+(let (($x51 (not $x50)))
+(let (($x168 (or $x119 (or $x112 (or $x109 (or $x106 (or $x97 (or $x89 (or $x82 $x35)))))))))
+(let (($x189 (or $x144 (or $x141 (or $x138 (or $x135 (or $x132 (or $x129 (or $x122 $x168)))))))))
+(let (($x187 (= $x48 (or $x141 (or $x138 (or $x135 (or $x132 (or $x129 (or $x122 $x168)))))))))
+(let (($x184 (= (or (and $x16 (< |n$a| |m$|)) (or (and $x18 (< |m$| |n$a|)) $x45)) (or $x138 (or $x135 (or $x132 (or $x129 (or $x122 $x168))))))))
+(let (($x181 (= (or (and $x18 (< |m$| |n$a|)) $x45) (or $x135 (or $x132 (or $x129 (or $x122 $x168)))))))
+(let (($x169 (= (or (and $x26 (< |n$| |m$|)) (or (and $x28 (< |m$| |n$|)) $x40)) $x168)))
+(let (($x166 (= (or (and $x28 (< |m$| |n$|)) $x40) (or $x112 (or $x109 (or $x106 (or $x97 (or $x89 (or $x82 $x35)))))))))
+(let (($x160 (= (or (and (< |m$| |n$|) $x26) $x38) (or $x106 (or $x97 (or $x89 (or $x82 $x35)))))))
+(let (($x154 (= (or (and $x22 (< |n$| |n$a|)) (or (and $x11 (< |n$a| |n$|)) $x35)) (or $x89 (or $x82 $x35)))))
+(let ((@x81 (rewrite (= (< |n$a| |n$|) $x79))))
+(let ((@x152 (monotonicity (monotonicity @x81 (= (and $x11 (< |n$a| |n$|)) $x82)) (= (or (and $x11 (< |n$a| |n$|)) $x35) (or $x82 $x35)))))
+(let ((@x88 (rewrite (= (< |n$| |n$a|) $x85))))
+(let ((@x155 (monotonicity (monotonicity @x88 (= (and $x22 (< |n$| |n$a|)) $x89)) @x152 $x154)))
+(let ((@x96 (rewrite (= (< |m$| |n$a|) $x92))))
+(let ((@x99 (monotonicity @x96 @x81 (= (and (< |m$| |n$a|) (< |n$a| |n$|)) $x97))))
+(let ((@x158 (monotonicity @x99 @x155 (= $x38 (or $x97 (or $x89 (or $x82 $x35)))))))
+(let ((@x105 (rewrite (= (< |m$| |n$|) $x103))))
+(let ((@x161 (monotonicity (monotonicity @x105 (= (and (< |m$| |n$|) $x26) $x106)) @x158 $x160)))
+(let ((@x111 (monotonicity @x105 @x88 (= (and (< |m$| |n$|) (< |n$| |n$a|)) $x109))))
+(let ((@x164 (monotonicity @x111 @x161 (= $x40 (or $x109 (or $x106 (or $x97 (or $x89 (or $x82 $x35)))))))))
+(let ((@x167 (monotonicity (monotonicity @x105 (= (and $x28 (< |m$| |n$|)) $x112)) @x164 $x166)))
+(let ((@x118 (rewrite (= (< |n$| |m$|) $x115))))
+(let ((@x170 (monotonicity (monotonicity @x118 (= (and $x26 (< |n$| |m$|)) $x119)) @x167 $x169)))
+(let ((@x124 (monotonicity @x81 @x118 (= (and (< |n$a| |n$|) (< |n$| |m$|)) $x122))))
+(let ((@x128 (rewrite (= (< |n$a| |m$|) $x126))))
+(let ((@x176 (monotonicity (monotonicity @x128 (= (and (< |n$a| |m$|) $x22) $x129)) (monotonicity @x124 @x170 (= $x43 (or $x122 $x168))) (= (or (and (< |n$a| |m$|) $x22) $x43) (or $x129 (or $x122 $x168))))))
+(let ((@x134 (monotonicity @x128 @x105 (= (and (< |n$a| |m$|) (< |m$| |n$|)) $x132))))
+(let ((@x179 (monotonicity @x134 @x176 (= $x45 (or $x132 (or $x129 (or $x122 $x168)))))))
+(let ((@x182 (monotonicity (monotonicity @x96 (= (and $x18 (< |m$| |n$a|)) $x135)) @x179 $x181)))
+(let ((@x185 (monotonicity (monotonicity @x128 (= (and $x16 (< |n$a| |m$|)) $x138)) @x182 $x184)))
+(let ((@x143 (monotonicity @x88 @x128 (= (and (< |n$| |n$a|) (< |n$a| |m$|)) $x141))))
+(let ((@x191 (monotonicity (monotonicity @x118 (= (and (< |n$| |m$|) $x11) $x144)) (monotonicity @x143 @x185 $x187) (= (or (and (< |n$| |m$|) $x11) $x48) $x189))))
+(let ((@x149 (monotonicity @x118 @x96 (= (and (< |n$| |m$|) (< |m$| |n$a|)) $x147))))
+(let ((@x199 (trans (monotonicity @x149 @x191 (= $x50 (or $x147 $x189))) (rewrite (= (or $x147 $x189) $x195)) (= $x50 $x195))))
+(let ((@x203 (mp (asserted $x51) (monotonicity @x199 (= $x51 (not $x195))) (not $x195))))
+(let ((@x270 (mp (|not-or-elim| @x203 $x208) @x269 $x259)))
+(let (($x271 (not $x16)))
+(let (($x272 (or $x271 $x125)))
+(let ((@x278 (monotonicity (rewrite (= $x138 (not $x272))) (= (not $x138) (not (not $x272))))))
+(let ((@x282 (trans @x278 (rewrite (= (not (not $x272)) $x272)) (= (not $x138) $x272))))
+(let ((@x283 (mp (|not-or-elim| @x203 (not $x138)) @x282 $x272)))
+(let (($x284 (not $x18)))
+(let (($x309 (not $x22)))
+(let ((@x432 (hypothesis $x79)))
+(let (($x384 (or $x93 $x78)))
+(let ((@x390 (monotonicity (rewrite (= $x97 (not $x384))) (= (not $x97) (not (not $x384))))))
+(let ((@x394 (trans @x390 (rewrite (= (not (not $x384)) $x384)) (= (not $x97) $x384))))
+(let ((@x395 (mp (|not-or-elim| @x203 (not $x97)) @x394 $x384)))
+(let (($x246 (not $x11)))
+(let (($x408 (or $x246 $x78)))
+(let ((@x414 (monotonicity (rewrite (= $x82 (not $x408))) (= (not $x82) (not (not $x408))))))
+(let ((@x418 (trans @x414 (rewrite (= (not (not $x408)) $x408)) (= (not $x82) $x408))))
+(let ((@x419 (mp (|not-or-elim| @x203 (not $x82)) @x418 $x408)))
+(let ((@x437 ((_ |th-lemma| arith triangle-eq) (or $x11 $x126 $x92))))
+(let ((@x438 (|unit-resolution| @x437 (|unit-resolution| @x419 @x432 $x246) (|unit-resolution| @x395 @x432 $x93) $x126)))
+(let (($x310 (or $x125 $x309)))
+(let ((@x316 (monotonicity (rewrite (= $x129 (not $x310))) (= (not $x129) (not (not $x310))))))
+(let ((@x320 (trans @x316 (rewrite (= (not (not $x310)) $x310)) (= (not $x129) $x310))))
+(let ((@x321 (mp (|not-or-elim| @x203 (not $x129)) @x320 $x310)))
+(let ((@x448 (mp (|unit-resolution| @x321 @x438 $x309) (monotonicity (commutativity (= $x22 $x18)) (= $x309 $x284)) $x284)))
+(let (($x322 (or $x78 $x116)))
+(let ((@x328 (monotonicity (rewrite (= $x122 (not $x322))) (= (not $x122) (not (not $x322))))))
+(let ((@x332 (trans @x328 (rewrite (= (not (not $x322)) $x322)) (= (not $x122) $x322))))
+(let ((@x333 (mp (|not-or-elim| @x203 (not $x122)) @x332 $x322)))
+(let (($x297 (or $x125 $x102)))
+(let ((@x303 (monotonicity (rewrite (= $x132 (not $x297))) (= (not $x132) (not (not $x297))))))
+(let ((@x307 (trans @x303 (rewrite (= (not (not $x297)) $x297)) (= (not $x132) $x297))))
+(let ((@x308 (mp (|not-or-elim| @x203 (not $x132)) @x307 $x297)))
+(let ((@x442 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x18 $x103 $x115)) (|unit-resolution| @x308 @x438 $x102) (|unit-resolution| @x333 @x432 $x116) $x18)))
+(let ((@x457 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x16 $x79 $x85)) (lemma (|unit-resolution| @x442 @x448 false) $x78) (or $x16 $x85))))
+(let ((@x458 (|unit-resolution| @x457 (|unit-resolution| @x283 (hypothesis $x126) $x271) (|unit-resolution| @x270 (hypothesis $x126) $x86) false)))
+(let ((@x459 (lemma @x458 $x125)))
+(let (($x73 (or $x116 $x93)))
+(let ((@x240 (monotonicity (rewrite (= $x147 (not $x73))) (= (not $x147) (not (not $x73))))))
+(let ((@x244 (trans @x240 (rewrite (= (not (not $x73)) $x73)) (= (not $x147) $x73))))
+(let ((@x245 (mp (|not-or-elim| @x203 (not $x147)) @x244 $x73)))
+(let (($x247 (or $x116 $x246)))
+(let ((@x253 (monotonicity (rewrite (= $x144 (not $x247))) (= (not $x144) (not (not $x247))))))
+(let ((@x257 (trans @x253 (rewrite (= (not (not $x247)) $x247)) (= (not $x144) $x247))))
+(let ((@x258 (mp (|not-or-elim| @x203 (not $x144)) @x257 $x247)))
+(let ((@x463 (|unit-resolution| @x437 (|unit-resolution| @x258 (hypothesis $x115) $x246) (|unit-resolution| @x245 (hypothesis $x115) $x93) @x459 false)))
+(let (($x334 (not $x26)))
+(let (($x372 (or $x102 $x334)))
+(let ((@x378 (monotonicity (rewrite (= $x106 (not $x372))) (= (not $x106) (not (not $x372))))))
+(let ((@x382 (trans @x378 (rewrite (= (not (not $x372)) $x372)) (= (not $x106) $x372))))
+(let ((@x383 (mp (|not-or-elim| @x203 (not $x106)) @x382 $x372)))
+(let ((@x473 (mp (|unit-resolution| @x383 (hypothesis $x103) $x334) (monotonicity (commutativity (= $x26 $x16)) (= $x334 $x271)) $x271)))
+(let (($x360 (or $x102 $x86)))
+(let ((@x366 (monotonicity (rewrite (= $x109 (not $x360))) (= (not $x109) (not (not $x360))))))
+(let ((@x370 (trans @x366 (rewrite (= (not (not $x360)) $x360)) (= (not $x109) $x360))))
+(let ((@x371 (mp (|not-or-elim| @x203 (not $x109)) @x370 $x360)))
+(let ((@x467 (|unit-resolution| @x457 (|unit-resolution| @x371 (hypothesis $x103) $x86) $x16)))
+(let ((@x476 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x18 $x103 $x115)) (lemma (|unit-resolution| @x467 @x473 false) $x102) (lemma @x463 $x116) $x18)))
+(let (($x285 (or $x284 $x93)))
+(let ((@x291 (monotonicity (rewrite (= $x135 (not $x285))) (= (not $x135) (not (not $x285))))))
+(let ((@x295 (trans @x291 (rewrite (= (not (not $x285)) $x285)) (= (not $x135) $x285))))
+(let ((@x296 (mp (|not-or-elim| @x203 (not $x135)) @x295 $x285)))
+(let ((@x486 (mp (|unit-resolution| @x437 (|unit-resolution| @x296 @x476 $x93) @x459 $x11) (symm (commutativity (= $x28 $x11)) (= $x11 $x28)) $x28)))
+(let (($x420 (or (not $x28) $x309)))
+(let ((@x426 (monotonicity (rewrite (= $x35 (not $x420))) (= (not $x35) (not (not $x420))))))
+(let ((@x430 (trans @x426 (rewrite (= (not (not $x420)) $x420)) (= (not $x35) $x420))))
+(let ((@x431 (mp (|not-or-elim| @x203 (not $x35)) @x430 $x420)))
+(|unit-resolution| @x431 @x486 (mp @x476 @x478 $x22) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
 
-4464df6a987862165c07a2bd783815dc9c588fb6 888 0
+ad69b5703e25623b7fccdbcfa3db5949b2899f42 927 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let (($x917 (>= (+ |x7$| (* (~ 1) (ite (>= |x7$| 0) |x7$| (* (~ 1) |x7$|)))) 0)))
-(let (($x954 (not $x917)))
-(let (($x904 (<= (+ |x2$| (* (~ 1) |x11$|)) 0)))
-(let (($x1013 (not $x904)))
+(let ((?x131 (* (~ 1) |x4$|)))
+(let (($x436 (>= |x4$| 0)))
+(let ((?x443 (ite $x436 |x4$| ?x131)))
+(let ((?x454 (* (~ 1) ?x443)))
+(let ((?x675 (+ |x4$| ?x454)))
+(let (($x676 (<= ?x675 0)))
+(let (($x782 (not $x676)))
+(let ((?x672 (+ ?x131 ?x454)))
+(let (($x673 (<= ?x672 0)))
+(let (($x743 (not $x673)))
+(let ((?x653 (* (~ 1) |x11$|)))
+(let ((?x654 (+ |x2$| ?x653)))
+(let (($x656 (>= ?x654 0)))
+(let (($x708 (not $x656)))
 (let (($x71 (= |x2$| |x11$|)))
-(let (($x808 (not $x71)))
+(let ((@x1263 (hypothesis $x656)))
+(let (($x655 (<= ?x654 0)))
+(let ((?x165 (* (~ 1) |x6$|)))
+(let (($x386 (>= |x6$| 0)))
+(let ((?x393 (ite $x386 |x6$| ?x165)))
+(let ((?x404 (* (~ 1) ?x393)))
+(let ((?x669 (+ |x6$| ?x404)))
+(let (($x934 (<= ?x669 0)))
+(let (($x610 (= |x6$| ?x393)))
+(let (($x411 (>= |x5$| 0)))
+(let (($x286 (>= |x9$| 0)))
+(let (($x671 (>= ?x669 0)))
+(let (($x287 (not $x286)))
+(let ((@x1426 (hypothesis $x287)))
+(let ((?x233 (* (~ 1) |x10$|)))
+(let (($x311 (>= |x10$| 0)))
+(let ((?x318 (ite $x311 |x10$| ?x233)))
+(let ((?x329 (* (~ 1) ?x318)))
+(let ((?x660 (+ |x10$| ?x329)))
+(let (($x1369 (<= ?x660 0)))
+(let (($x642 (= |x10$| ?x318)))
+(let (($x643 (= ?x233 ?x318)))
+(let (($x1119 (not $x643)))
+(let ((?x1101 (+ ?x233 ?x329)))
+(let (($x1247 (<= ?x1101 0)))
+(let (($x1259 (not $x1247)))
+(let ((?x216 (* (~ 1) |x9$|)))
+(let ((?x293 (ite $x286 |x9$| ?x216)))
+(let ((?x304 (* (~ 1) ?x293)))
+(let ((?x1498 (+ ?x216 ?x304)))
+(let (($x1543 (>= ?x1498 0)))
+(let (($x635 (= ?x216 ?x293)))
+(let ((@x639 (|def-axiom| (or $x286 $x635))))
+(let ((@x1553 (|unit-resolution| @x639 @x1426 $x635)))
+(let ((@x1572 ((_ |th-lemma| arith triangle-eq) (or (not $x635) $x1543))))
+(let ((@x1573 (|unit-resolution| @x1572 @x1553 $x1543)))
+(let ((?x182 (* (~ 1) |x7$|)))
+(let (($x361 (>= |x7$| 0)))
+(let ((?x368 (ite $x361 |x7$| ?x182)))
+(let ((?x379 (* (~ 1) ?x368)))
+(let ((?x666 (+ |x7$| ?x379)))
+(let (($x838 (<= ?x666 0)))
+(let (($x618 (= |x7$| ?x368)))
+(let (($x412 (not $x411)))
+(let ((@x842 (hypothesis $x412)))
+(let ((?x775 (+ ?x165 ?x404)))
+(let (($x778 (<= ?x775 0)))
+(let (($x611 (= ?x165 ?x393)))
+(let (($x387 (not $x386)))
+(let (($x362 (not $x361)))
+(let ((@x1025 (hypothesis $x362)))
+(let ((@x1024 (hypothesis $x386)))
+(let ((?x405 (+ |x5$| |x7$| ?x404)))
+(let (($x617 (>= ?x405 0)))
+(let (($x406 (= ?x405 0)))
+(let ((?x330 (+ |x9$| |x11$| ?x329)))
+(let (($x331 (= ?x330 0)))
+(let ((?x305 (+ |x8$| |x10$| ?x304)))
+(let (($x306 (= ?x305 0)))
+(let ((?x199 (* (~ 1) |x8$|)))
+(let (($x336 (>= |x8$| 0)))
+(let ((?x343 (ite $x336 |x8$| ?x199)))
+(let ((?x354 (* (~ 1) ?x343)))
+(let ((?x355 (+ |x7$| |x9$| ?x354)))
+(let (($x356 (= ?x355 0)))
+(let ((?x380 (+ |x6$| |x8$| ?x379)))
+(let (($x381 (= ?x380 0)))
+(let ((?x148 (* (~ 1) |x5$|)))
+(let ((?x418 (ite $x411 |x5$| ?x148)))
+(let ((?x429 (* (~ 1) ?x418)))
+(let ((?x430 (+ |x4$| |x6$| ?x429)))
+(let (($x431 (= ?x430 0)))
+(let ((?x455 (+ |x3$| |x5$| ?x454)))
+(let (($x456 (= ?x455 0)))
+(let ((?x114 (* (~ 1) |x3$|)))
+(let (($x461 (>= |x3$| 0)))
+(let ((?x468 (ite $x461 |x3$| ?x114)))
+(let ((?x479 (* (~ 1) ?x468)))
+(let ((?x480 (+ |x2$| |x4$| ?x479)))
+(let (($x481 (= ?x480 0)))
+(let ((?x96 (* (~ 1) |x2$|)))
+(let (($x486 (>= |x2$| 0)))
+(let ((?x493 (ite $x486 |x2$| ?x96)))
+(let ((?x504 (* (~ 1) ?x493)))
+(let ((?x505 (+ |x3$| |x1$| ?x504)))
+(let (($x506 (= ?x505 0)))
+(let (($x535 (and $x506 $x481 $x456 $x431 $x406 $x381 $x356 $x306 $x331)))
+(let (($x546 (not (or (not $x535) (and (= |x1$| |x10$|) $x71)))))
 (let (($x70 (= |x1$| |x10$|)))
-(let (($x900 (<= (+ |x1$| (* (~ 1) |x10$|)) 0)))
-(let (($x925 (<= (+ |x4$| (* (~ 1) (ite (>= |x4$| 0) |x4$| (* (~ 1) |x4$|)))) 0)))
-(let (($x1023 (>= (+ |x5$| (* (~ 1) (ite (>= |x5$| 0) |x5$| (* (~ 1) |x5$|)))) 0)))
-(let ((?x180 (* (~ 1) |x5$|)))
-(let (($x642 (>= |x5$| 0)))
-(let ((?x645 (ite $x642 |x5$| ?x180)))
-(let (($x845 (= |x5$| ?x645)))
-(let (($x1628 (<= (+ |x10$| (* (~ 1) (ite (>= |x10$| 0) |x10$| (* (~ 1) |x10$|)))) 0)))
-(let ((?x335 (* (~ 1) |x10$|)))
-(let (($x782 (>= |x10$| 0)))
-(let ((?x785 (ite $x782 |x10$| ?x335)))
-(let (($x890 (= |x10$| ?x785)))
-(let (($x891 (= ?x335 ?x785)))
-(let (($x1368 (not $x891)))
-(let (($x1496 (<= (+ ?x335 (* (~ 1) ?x785)) 0)))
-(let (($x1508 (not $x1496)))
-(let ((?x304 (* (~ 1) |x9$|)))
-(let (($x754 (>= |x9$| 0)))
-(let ((?x757 (ite $x754 |x9$| ?x304)))
-(let ((?x766 (* (~ 1) ?x757)))
-(let (($x1616 (>= (+ ?x304 ?x766) 0)))
-(let (($x882 (= ?x304 ?x757)))
-(let (($x883 (not $x754)))
-(let (($x847 (not $x642)))
-(let ((@x1091 (hypothesis $x847)))
-(let (($x670 (>= |x6$| 0)))
-(let ((?x149 (* (~ 1) |x4$|)))
-(let (($x614 (>= |x4$| 0)))
-(let ((?x617 (ite $x614 |x4$| ?x149)))
-(let (($x836 (= |x4$| ?x617)))
-(let ((@x1325 (hypothesis $x754)))
-(let (($x914 (>= (+ |x8$| (* (~ 1) (ite (>= |x8$| 0) |x8$| (* (~ 1) |x8$|)))) 0)))
-(let (($x1107 (not $x914)))
-(let (($x838 (not $x614)))
-(let ((@x1010 (hypothesis $x838)))
-(let ((?x654 (* (~ 1) ?x645)))
-(let ((?x655 (+ |x4$| |x6$| ?x654)))
-(let (($x853 (>= ?x655 0)))
-(let (($x656 (= ?x655 0)))
-(let (($x171 (<= 0 |x5$|)))
-(let ((?x186 (ite $x171 |x5$| ?x180)))
-(let ((?x636 (+ ?x149 ?x186)))
-(let (($x639 (= |x6$| ?x636)))
-(let ((@x650 (monotonicity (monotonicity (rewrite (= $x171 $x642)) (= ?x186 ?x645)) (= ?x636 (+ ?x149 ?x645)))))
-(let ((@x660 (trans (monotonicity @x650 (= $x639 (= |x6$| (+ ?x149 ?x645)))) (rewrite (= (= |x6$| (+ ?x149 ?x645)) $x656)) (= $x639 $x656))))
-(let ((@x641 (monotonicity (rewrite (= (+ ?x186 ?x149) ?x636)) (= (= |x6$| (+ ?x186 ?x149)) $x639))))
-(let ((?x194 (+ ?x186 ?x149)))
-(let (($x199 (= |x6$| ?x194)))
-(let ((@x492 (monotonicity (monotonicity (rewrite (= $x171 $x171)) (= ?x186 ?x186)) (= ?x194 ?x194))))
-(let (($x326 (<= 0 |x10$|)))
-(let ((?x341 (ite $x326 |x10$| ?x335)))
-(let ((?x349 (+ ?x341 ?x304)))
-(let (($x354 (= |x11$| ?x349)))
-(let ((?x273 (* (~ 1) |x8$|)))
-(let (($x295 (<= 0 |x9$|)))
-(let ((?x310 (ite $x295 |x9$| ?x304)))
-(let ((?x318 (+ ?x310 ?x273)))
-(let (($x323 (= |x10$| ?x318)))
-(let ((?x242 (* (~ 1) |x7$|)))
-(let (($x264 (<= 0 |x8$|)))
-(let ((?x279 (ite $x264 |x8$| ?x273)))
-(let ((?x287 (+ ?x279 ?x242)))
-(let (($x292 (= |x9$| ?x287)))
-(let ((?x211 (* (~ 1) |x6$|)))
-(let (($x233 (<= 0 |x7$|)))
-(let ((?x248 (ite $x233 |x7$| ?x242)))
-(let ((?x256 (+ ?x248 ?x211)))
-(let (($x261 (= |x8$| ?x256)))
-(let (($x202 (<= 0 |x6$|)))
-(let ((?x217 (ite $x202 |x6$| ?x211)))
-(let ((?x225 (+ ?x217 ?x180)))
-(let (($x230 (= |x7$| ?x225)))
-(let ((?x118 (* (~ 1) |x3$|)))
-(let (($x140 (<= 0 |x4$|)))
-(let ((?x155 (ite $x140 |x4$| ?x149)))
-(let ((?x163 (+ ?x155 ?x118)))
-(let (($x168 (= |x5$| ?x163)))
-(let ((?x86 (* (~ 1) |x2$|)))
-(let (($x109 (<= 0 |x3$|)))
-(let ((?x124 (ite $x109 |x3$| ?x118)))
-(let ((?x132 (+ ?x124 ?x86)))
-(let (($x137 (= |x4$| ?x132)))
-(let ((?x100 (* (~ 1) |x1$|)))
-(let (($x76 (<= 0 |x2$|)))
-(let ((?x92 (ite $x76 |x2$| ?x86)))
-(let ((?x101 (+ ?x92 ?x100)))
-(let (($x106 (= |x3$| ?x101)))
-(let (($x411 (and $x106 $x137 $x168 $x199 $x230 $x261 $x292 $x323 $x354)))
 (let (($x72 (and $x70 $x71)))
 (let (($x62 (and (= |x10$| (- (ite (< |x9$| 0) (- |x9$|) |x9$|) |x8$|)) (= |x11$| (- (ite (< |x10$| 0) (- |x10$|) |x10$|) |x9$|)))))
-(let (($x63 (and (= |x9$| (- (ite (< |x8$| 0) (- |x8$|) |x8$|) |x7$|)) $x62)))
-(let (($x64 (and (= |x8$| (- (ite (< |x7$| 0) (- |x7$|) |x7$|) |x6$|)) $x63)))
-(let (($x65 (and (= |x7$| (- (ite (< |x6$| 0) (- |x6$|) |x6$|) |x5$|)) $x64)))
-(let (($x66 (and (= |x6$| (- (ite (< |x5$| 0) (- |x5$|) |x5$|) |x4$|)) $x65)))
-(let (($x67 (and (= |x5$| (- (ite (< |x4$| 0) (- |x4$|) |x4$|) |x3$|)) $x66)))
-(let (($x68 (and (= |x4$| (- (ite (< |x3$| 0) (- |x3$|) |x3$|) |x2$|)) $x67)))
-(let (($x69 (and (= |x3$| (- (ite (< |x2$| 0) (- |x2$|) |x2$|) |x1$|)) $x68)))
-(let (($x73 (=> $x69 $x72)))
+(let (($x64 (and (= |x8$| (- (ite (< |x7$| 0) (- |x7$|) |x7$|) |x6$|)) (and (= |x9$| (- (ite (< |x8$| 0) (- |x8$|) |x8$|) |x7$|)) $x62))))
+(let (($x66 (and (= |x6$| (- (ite (< |x5$| 0) (- |x5$|) |x5$|) |x4$|)) (and (= |x7$| (- (ite (< |x6$| 0) (- |x6$|) |x6$|) |x5$|)) $x64))))
+(let (($x68 (and (= |x4$| (- (ite (< |x3$| 0) (- |x3$|) |x3$|) |x2$|)) (and (= |x5$| (- (ite (< |x4$| 0) (- |x4$|) |x4$|) |x3$|)) $x66))))
+(let (($x73 (=> (and (= |x3$| (- (ite (< |x2$| 0) (- |x2$|) |x2$|) |x1$|)) $x68) $x72)))
 (let (($x74 (not $x73)))
-(let ((@x413 (rewrite (= (and $x106 (and $x137 $x168 $x199 $x230 $x261 $x292 $x323 $x354)) $x411))))
-(let (($x403 (and $x137 $x168 $x199 $x230 $x261 $x292 $x323 $x354)))
-(let ((@x405 (rewrite (= (and $x137 (and $x168 $x199 $x230 $x261 $x292 $x323 $x354)) $x403))))
-(let (($x395 (and $x168 $x199 $x230 $x261 $x292 $x323 $x354)))
-(let (($x387 (and $x199 $x230 $x261 $x292 $x323 $x354)))
-(let (($x379 (and $x230 $x261 $x292 $x323 $x354)))
-(let ((@x373 (rewrite (= (and $x261 (and $x292 $x323 $x354)) (and $x261 $x292 $x323 $x354)))))
-(let (($x355 (= (= |x11$| (- (ite (< |x10$| 0) (- |x10$|) |x10$|) |x9$|)) $x354)))
-(let ((?x59 (ite (< |x10$| 0) (- |x10$|) |x10$|)))
-(let ((?x60 (- ?x59 |x9$|)))
-(let ((@x334 (trans (rewrite (= (< |x10$| 0) (not $x326))) (monotonicity (rewrite (= $x326 $x326)) (= (not $x326) (not $x326))) (= (< |x10$| 0) (not $x326)))))
-(let ((@x340 (monotonicity @x334 (rewrite (= (- |x10$|) ?x335)) (= ?x59 (ite (not $x326) ?x335 |x10$|)))))
-(let ((@x345 (trans @x340 (rewrite (= (ite (not $x326) ?x335 |x10$|) ?x341)) (= ?x59 ?x341))))
-(let ((@x353 (trans (monotonicity @x345 (= ?x60 (- ?x341 |x9$|))) (rewrite (= (- ?x341 |x9$|) ?x349)) (= ?x60 ?x349))))
-(let (($x324 (= (= |x10$| (- (ite (< |x9$| 0) (- |x9$|) |x9$|) |x8$|)) $x323)))
-(let ((@x303 (trans (rewrite (= (< |x9$| 0) (not $x295))) (monotonicity (rewrite (= $x295 $x295)) (= (not $x295) (not $x295))) (= (< |x9$| 0) (not $x295)))))
-(let ((@x309 (monotonicity @x303 (rewrite (= (- |x9$|) ?x304)) (= (ite (< |x9$| 0) (- |x9$|) |x9$|) (ite (not $x295) ?x304 |x9$|)))))
-(let ((@x314 (trans @x309 (rewrite (= (ite (not $x295) ?x304 |x9$|) ?x310)) (= (ite (< |x9$| 0) (- |x9$|) |x9$|) ?x310))))
-(let ((@x317 (monotonicity @x314 (= (- (ite (< |x9$| 0) (- |x9$|) |x9$|) |x8$|) (- ?x310 |x8$|)))))
-(let ((@x322 (trans @x317 (rewrite (= (- ?x310 |x8$|) ?x318)) (= (- (ite (< |x9$| 0) (- |x9$|) |x9$|) |x8$|) ?x318))))
-(let ((@x359 (monotonicity (monotonicity @x322 $x324) (monotonicity @x353 $x355) (= $x62 (and $x323 $x354)))))
-(let ((@x272 (trans (rewrite (= (< |x8$| 0) (not $x264))) (monotonicity (rewrite (= $x264 $x264)) (= (not $x264) (not $x264))) (= (< |x8$| 0) (not $x264)))))
-(let ((@x278 (monotonicity @x272 (rewrite (= (- |x8$|) ?x273)) (= (ite (< |x8$| 0) (- |x8$|) |x8$|) (ite (not $x264) ?x273 |x8$|)))))
-(let ((@x283 (trans @x278 (rewrite (= (ite (not $x264) ?x273 |x8$|) ?x279)) (= (ite (< |x8$| 0) (- |x8$|) |x8$|) ?x279))))
-(let ((@x286 (monotonicity @x283 (= (- (ite (< |x8$| 0) (- |x8$|) |x8$|) |x7$|) (- ?x279 |x7$|)))))
-(let ((@x291 (trans @x286 (rewrite (= (- ?x279 |x7$|) ?x287)) (= (- (ite (< |x8$| 0) (- |x8$|) |x8$|) |x7$|) ?x287))))
-(let ((@x294 (monotonicity @x291 (= (= |x9$| (- (ite (< |x8$| 0) (- |x8$|) |x8$|) |x7$|)) $x292))))
-(let ((@x367 (trans (monotonicity @x294 @x359 (= $x63 (and $x292 (and $x323 $x354)))) (rewrite (= (and $x292 (and $x323 $x354)) (and $x292 $x323 $x354))) (= $x63 (and $x292 $x323 $x354)))))
-(let ((@x241 (trans (rewrite (= (< |x7$| 0) (not $x233))) (monotonicity (rewrite (= $x233 $x233)) (= (not $x233) (not $x233))) (= (< |x7$| 0) (not $x233)))))
-(let ((@x247 (monotonicity @x241 (rewrite (= (- |x7$|) ?x242)) (= (ite (< |x7$| 0) (- |x7$|) |x7$|) (ite (not $x233) ?x242 |x7$|)))))
-(let ((@x252 (trans @x247 (rewrite (= (ite (not $x233) ?x242 |x7$|) ?x248)) (= (ite (< |x7$| 0) (- |x7$|) |x7$|) ?x248))))
-(let ((@x255 (monotonicity @x252 (= (- (ite (< |x7$| 0) (- |x7$|) |x7$|) |x6$|) (- ?x248 |x6$|)))))
-(let ((@x260 (trans @x255 (rewrite (= (- ?x248 |x6$|) ?x256)) (= (- (ite (< |x7$| 0) (- |x7$|) |x7$|) |x6$|) ?x256))))
-(let ((@x263 (monotonicity @x260 (= (= |x8$| (- (ite (< |x7$| 0) (- |x7$|) |x7$|) |x6$|)) $x261))))
-(let ((@x375 (trans (monotonicity @x263 @x367 (= $x64 (and $x261 (and $x292 $x323 $x354)))) @x373 (= $x64 (and $x261 $x292 $x323 $x354)))))
-(let ((@x210 (trans (rewrite (= (< |x6$| 0) (not $x202))) (monotonicity (rewrite (= $x202 $x202)) (= (not $x202) (not $x202))) (= (< |x6$| 0) (not $x202)))))
-(let ((@x216 (monotonicity @x210 (rewrite (= (- |x6$|) ?x211)) (= (ite (< |x6$| 0) (- |x6$|) |x6$|) (ite (not $x202) ?x211 |x6$|)))))
-(let ((@x221 (trans @x216 (rewrite (= (ite (not $x202) ?x211 |x6$|) ?x217)) (= (ite (< |x6$| 0) (- |x6$|) |x6$|) ?x217))))
-(let ((@x224 (monotonicity @x221 (= (- (ite (< |x6$| 0) (- |x6$|) |x6$|) |x5$|) (- ?x217 |x5$|)))))
-(let ((@x229 (trans @x224 (rewrite (= (- ?x217 |x5$|) ?x225)) (= (- (ite (< |x6$| 0) (- |x6$|) |x6$|) |x5$|) ?x225))))
-(let ((@x232 (monotonicity @x229 (= (= |x7$| (- (ite (< |x6$| 0) (- |x6$|) |x6$|) |x5$|)) $x230))))
-(let ((@x378 (monotonicity @x232 @x375 (= $x65 (and $x230 (and $x261 $x292 $x323 $x354))))))
-(let ((@x383 (trans @x378 (rewrite (= (and $x230 (and $x261 $x292 $x323 $x354)) $x379)) (= $x65 $x379))))
-(let ((@x179 (trans (rewrite (= (< |x5$| 0) (not $x171))) (monotonicity (rewrite (= $x171 $x171)) (= (not $x171) (not $x171))) (= (< |x5$| 0) (not $x171)))))
-(let ((@x185 (monotonicity @x179 (rewrite (= (- |x5$|) ?x180)) (= (ite (< |x5$| 0) (- |x5$|) |x5$|) (ite (not $x171) ?x180 |x5$|)))))
-(let ((@x190 (trans @x185 (rewrite (= (ite (not $x171) ?x180 |x5$|) ?x186)) (= (ite (< |x5$| 0) (- |x5$|) |x5$|) ?x186))))
-(let ((@x193 (monotonicity @x190 (= (- (ite (< |x5$| 0) (- |x5$|) |x5$|) |x4$|) (- ?x186 |x4$|)))))
-(let ((@x198 (trans @x193 (rewrite (= (- ?x186 |x4$|) ?x194)) (= (- (ite (< |x5$| 0) (- |x5$|) |x5$|) |x4$|) ?x194))))
-(let ((@x201 (monotonicity @x198 (= (= |x6$| (- (ite (< |x5$| 0) (- |x5$|) |x5$|) |x4$|)) $x199))))
-(let ((@x391 (trans (monotonicity @x201 @x383 (= $x66 (and $x199 $x379))) (rewrite (= (and $x199 $x379) $x387)) (= $x66 $x387))))
-(let ((@x148 (trans (rewrite (= (< |x4$| 0) (not $x140))) (monotonicity (rewrite (= $x140 $x140)) (= (not $x140) (not $x140))) (= (< |x4$| 0) (not $x140)))))
-(let ((@x154 (monotonicity @x148 (rewrite (= (- |x4$|) ?x149)) (= (ite (< |x4$| 0) (- |x4$|) |x4$|) (ite (not $x140) ?x149 |x4$|)))))
-(let ((@x159 (trans @x154 (rewrite (= (ite (not $x140) ?x149 |x4$|) ?x155)) (= (ite (< |x4$| 0) (- |x4$|) |x4$|) ?x155))))
-(let ((@x162 (monotonicity @x159 (= (- (ite (< |x4$| 0) (- |x4$|) |x4$|) |x3$|) (- ?x155 |x3$|)))))
-(let ((@x167 (trans @x162 (rewrite (= (- ?x155 |x3$|) ?x163)) (= (- (ite (< |x4$| 0) (- |x4$|) |x4$|) |x3$|) ?x163))))
-(let ((@x170 (monotonicity @x167 (= (= |x5$| (- (ite (< |x4$| 0) (- |x4$|) |x4$|) |x3$|)) $x168))))
-(let ((@x399 (trans (monotonicity @x170 @x391 (= $x67 (and $x168 $x387))) (rewrite (= (and $x168 $x387) $x395)) (= $x67 $x395))))
-(let ((@x117 (trans (rewrite (= (< |x3$| 0) (not $x109))) (monotonicity (rewrite (= $x109 $x109)) (= (not $x109) (not $x109))) (= (< |x3$| 0) (not $x109)))))
-(let ((@x123 (monotonicity @x117 (rewrite (= (- |x3$|) ?x118)) (= (ite (< |x3$| 0) (- |x3$|) |x3$|) (ite (not $x109) ?x118 |x3$|)))))
-(let ((@x128 (trans @x123 (rewrite (= (ite (not $x109) ?x118 |x3$|) ?x124)) (= (ite (< |x3$| 0) (- |x3$|) |x3$|) ?x124))))
-(let ((@x131 (monotonicity @x128 (= (- (ite (< |x3$| 0) (- |x3$|) |x3$|) |x2$|) (- ?x124 |x2$|)))))
-(let ((@x136 (trans @x131 (rewrite (= (- ?x124 |x2$|) ?x132)) (= (- (ite (< |x3$| 0) (- |x3$|) |x3$|) |x2$|) ?x132))))
-(let ((@x139 (monotonicity @x136 (= (= |x4$| (- (ite (< |x3$| 0) (- |x3$|) |x3$|) |x2$|)) $x137))))
-(let ((@x407 (trans (monotonicity @x139 @x399 (= $x68 (and $x137 $x395))) @x405 (= $x68 $x403))))
-(let ((@x84 (trans (rewrite (= (< |x2$| 0) (not $x76))) (monotonicity (rewrite (= $x76 $x76)) (= (not $x76) (not $x76))) (= (< |x2$| 0) (not $x76)))))
-(let ((@x91 (monotonicity @x84 (rewrite (= (- |x2$|) ?x86)) (= (ite (< |x2$| 0) (- |x2$|) |x2$|) (ite (not $x76) ?x86 |x2$|)))))
-(let ((@x96 (trans @x91 (rewrite (= (ite (not $x76) ?x86 |x2$|) ?x92)) (= (ite (< |x2$| 0) (- |x2$|) |x2$|) ?x92))))
-(let ((@x99 (monotonicity @x96 (= (- (ite (< |x2$| 0) (- |x2$|) |x2$|) |x1$|) (- ?x92 |x1$|)))))
-(let ((@x105 (trans @x99 (rewrite (= (- ?x92 |x1$|) ?x101)) (= (- (ite (< |x2$| 0) (- |x2$|) |x2$|) |x1$|) ?x101))))
-(let ((@x108 (monotonicity @x105 (= (= |x3$| (- (ite (< |x2$| 0) (- |x2$|) |x2$|) |x1$|)) $x106))))
-(let ((@x415 (trans (monotonicity @x108 @x407 (= $x69 (and $x106 $x403))) @x413 (= $x69 $x411))))
-(let ((@x424 (trans (monotonicity @x415 (= $x73 (=> $x411 $x72))) (rewrite (= (=> $x411 $x72) (or (not $x411) $x72))) (= $x73 (or (not $x411) $x72)))))
-(let ((@x428 (mp (asserted $x74) (monotonicity @x424 (= $x74 (not (or (not $x411) $x72)))) (not (or (not $x411) $x72)))))
-(let ((@x429 (|not-or-elim| @x428 $x411)))
-(let ((@x494 (mp (mp (|and-elim| @x429 $x199) (|rewrite*| (= $x199 $x199)) $x199) (monotonicity @x492 (= $x199 $x199)) $x199)))
-(let ((@x663 (mp (mp @x494 (monotonicity @x492 (= $x199 $x199)) $x199) (trans @x641 @x660 (= $x199 $x656)) $x656)))
-(let ((@x1046 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x656) $x853)) @x663 $x853)))
-(let (($x1180 (<= (+ ?x180 ?x654) 0)))
-(let (($x846 (= ?x180 ?x645)))
-(let ((@x1247 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x846) $x1180)) (|unit-resolution| (|def-axiom| (or $x642 $x846)) @x1091 $x846) $x1180)))
-(let (($x726 (>= |x8$| 0)))
-(let ((?x729 (ite $x726 |x8$| ?x273)))
-(let ((?x738 (* (~ 1) ?x729)))
-(let ((?x739 (+ |x7$| |x9$| ?x738)))
-(let (($x879 (<= ?x739 0)))
-(let (($x740 (= ?x739 0)))
-(let ((@x734 (monotonicity (monotonicity (rewrite (= $x264 $x726)) (= ?x279 ?x729)) (= (+ ?x242 ?x279) (+ ?x242 ?x729)))))
-(let ((@x737 (monotonicity @x734 (= (= |x9$| (+ ?x242 ?x279)) (= |x9$| (+ ?x242 ?x729))))))
-(let ((@x744 (trans @x737 (rewrite (= (= |x9$| (+ ?x242 ?x729)) $x740)) (= (= |x9$| (+ ?x242 ?x279)) $x740))))
-(let ((@x725 (monotonicity (rewrite (= ?x287 (+ ?x242 ?x279))) (= $x292 (= |x9$| (+ ?x242 ?x279))))))
-(let ((@x510 (monotonicity (monotonicity (rewrite (= $x264 $x264)) (= ?x279 ?x279)) (= ?x287 ?x287))))
-(let ((@x512 (mp (mp (|and-elim| @x429 $x292) (|rewrite*| (= $x292 $x292)) $x292) (monotonicity @x510 (= $x292 $x292)) $x292)))
-(let ((@x747 (mp (mp @x512 (monotonicity @x510 (= $x292 $x292)) $x292) (trans @x725 @x744 (= $x292 $x740)) $x740)))
-(let ((@x1104 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x740) $x879)) @x747 $x879)))
-(let (($x698 (>= |x7$| 0)))
-(let ((?x701 (ite $x698 |x7$| ?x242)))
-(let (($x863 (= |x7$| ?x701)))
-(let (($x1027 (<= (+ ?x211 (* (~ 1) (ite $x670 |x6$| ?x211))) 0)))
-(let ((?x673 (ite $x670 |x6$| ?x211)))
-(let (($x855 (= ?x211 ?x673)))
-(let (($x856 (not $x670)))
-(let (($x865 (not $x698)))
-(let ((@x1274 (hypothesis $x865)))
-(let ((@x1273 (hypothesis $x670)))
-(let ((?x682 (* (~ 1) ?x673)))
-(let ((?x683 (+ |x5$| |x7$| ?x682)))
-(let (($x862 (>= ?x683 0)))
-(let (($x684 (= ?x683 0)))
-(let ((@x678 (monotonicity (monotonicity (rewrite (= $x202 $x670)) (= ?x217 ?x673)) (= (+ ?x180 ?x217) (+ ?x180 ?x673)))))
-(let ((@x681 (monotonicity @x678 (= (= |x7$| (+ ?x180 ?x217)) (= |x7$| (+ ?x180 ?x673))))))
-(let ((@x688 (trans @x681 (rewrite (= (= |x7$| (+ ?x180 ?x673)) $x684)) (= (= |x7$| (+ ?x180 ?x217)) $x684))))
-(let ((@x669 (monotonicity (rewrite (= ?x225 (+ ?x180 ?x217))) (= $x230 (= |x7$| (+ ?x180 ?x217))))))
-(let ((@x498 (monotonicity (monotonicity (rewrite (= $x202 $x202)) (= ?x217 ?x217)) (= ?x225 ?x225))))
-(let ((@x500 (mp (mp (|and-elim| @x429 $x230) (|rewrite*| (= $x230 $x230)) $x230) (monotonicity @x498 (= $x230 $x230)) $x230)))
-(let ((@x691 (mp (mp @x500 (monotonicity @x498 (= $x230 $x230)) $x230) (trans @x669 @x688 (= $x230 $x684)) $x684)))
-(let ((@x1100 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x684) $x862)) @x691 $x862)))
-(let (($x1183 (<= (+ |x6$| ?x682) 0)))
-(let (($x854 (= |x6$| ?x673)))
-(let ((@x858 (|def-axiom| (or $x856 $x854))))
-(let ((@x1197 ((_ |th-lemma| arith triangle-eq) (or (not $x854) $x1183))))
-(let ((@x1276 (|unit-resolution| @x1197 (|unit-resolution| @x858 @x1273 $x854) $x1183)))
-(let ((@x1279 (lemma ((_ |th-lemma| arith farkas 1 1 1 1 1) @x1276 @x1100 @x1274 @x1091 @x1273 false) (or $x698 $x642 $x856))))
-(let ((@x860 (|def-axiom| (or $x670 $x855))))
-(let ((@x1310 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x855) $x1027)) (|unit-resolution| @x860 (|unit-resolution| @x1279 @x1274 @x1091 $x856) $x855) $x1027)))
-(let ((@x1311 ((_ |th-lemma| arith farkas 1 1 1 1 1) (|unit-resolution| @x1279 @x1274 @x1091 $x856) @x1274 @x1100 @x1091 @x1310 false)))
-(let ((@x867 (|def-axiom| (or $x865 $x863))))
-(let ((@x1334 (|unit-resolution| @x867 (|unit-resolution| (lemma @x1311 (or $x698 $x642)) @x1091 $x698) $x863)))
-(let ((@x1173 ((_ |th-lemma| arith triangle-eq) (or (not $x863) $x917))))
-(let ((@x1335 (|unit-resolution| @x1173 @x1334 $x917)))
-(let ((?x710 (* (~ 1) ?x701)))
-(let ((?x711 (+ |x6$| |x8$| ?x710)))
-(let (($x870 (<= ?x711 0)))
-(let (($x712 (= ?x711 0)))
-(let ((@x706 (monotonicity (monotonicity (rewrite (= $x233 $x698)) (= ?x248 ?x701)) (= (+ ?x211 ?x248) (+ ?x211 ?x701)))))
-(let ((@x709 (monotonicity @x706 (= (= |x8$| (+ ?x211 ?x248)) (= |x8$| (+ ?x211 ?x701))))))
-(let ((@x716 (trans @x709 (rewrite (= (= |x8$| (+ ?x211 ?x701)) $x712)) (= (= |x8$| (+ ?x211 ?x248)) $x712))))
-(let ((@x697 (monotonicity (rewrite (= ?x256 (+ ?x211 ?x248))) (= $x261 (= |x8$| (+ ?x211 ?x248))))))
-(let ((@x504 (monotonicity (monotonicity (rewrite (= $x233 $x233)) (= ?x248 ?x248)) (= ?x256 ?x256))))
-(let ((@x506 (mp (mp (|and-elim| @x429 $x261) (|rewrite*| (= $x261 $x261)) $x261) (monotonicity @x504 (= $x261 $x261)) $x261)))
-(let ((@x719 (mp (mp @x506 (monotonicity @x504 (= $x261 $x261)) $x261) (trans @x697 @x716 (= $x261 $x712)) $x712)))
-(let ((@x950 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x712) $x870)) @x719 $x870)))
-(let ((@x1105 (hypothesis $x914)))
-(let ((@x1351 (lemma ((_ |th-lemma| arith farkas 1 1 1 1 1 1 1 1 1) @x1105 @x950 @x1335 @x1104 @x1010 @x1247 @x1091 @x1046 @x1325 false) (or $x614 $x1107 $x642 $x883))))
-(let (($x872 (= |x8$| ?x729)))
-(let (($x1087 (<= (+ |x7$| ?x710) 0)))
-(let ((@x1112 ((_ |th-lemma| arith triangle-eq) (or (not $x863) $x1087))))
-(let ((@x1336 (|unit-resolution| @x1112 @x1334 $x1087)))
-(let (($x871 (>= ?x711 0)))
-(let ((@x1082 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x712) $x871)) @x719 $x871)))
-(let ((@x1488 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1) (or $x614 (not $x1180) $x642 (not $x853) $x670)) @x1010 @x1046 @x1247 @x1091 $x670)))
-(let ((@x1341 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x726 (not $x871) (not $x1087) (not $x1183) (not $x862) $x642))))
-(let ((@x1491 (|unit-resolution| @x1341 (|unit-resolution| @x1197 (|unit-resolution| @x858 @x1488 $x854) $x1183) @x1082 @x1091 @x1336 @x1100 $x726)))
-(let ((@x876 (|def-axiom| (or (not $x726) $x872))))
-(let ((@x1364 ((_ |th-lemma| arith triangle-eq) (or (not $x872) $x914))))
-(let ((@x1493 (|unit-resolution| @x1364 (|unit-resolution| @x876 @x1491 $x872) (|unit-resolution| @x1351 @x1010 @x1091 @x1325 $x1107) false)))
-(let ((@x840 (|def-axiom| (or $x838 $x836))))
-(let ((@x1574 (|unit-resolution| @x840 (|unit-resolution| (lemma @x1493 (or $x614 $x642 $x883)) @x1091 @x1325 $x614) $x836)))
-(let ((@x940 ((_ |th-lemma| arith triangle-eq) (or (not $x836) $x925))))
-(let (($x908 (>= (+ |x9$| ?x766) 0)))
-(let (($x881 (= |x9$| ?x757)))
-(let ((@x885 (|def-axiom| (or $x883 $x881))))
-(let ((@x1393 ((_ |th-lemma| arith triangle-eq) (or (not $x881) $x908))))
-(let ((@x1394 (|unit-resolution| @x1393 (|unit-resolution| @x885 @x1325 $x881) $x908)))
-(let (($x907 (<= (+ |x9$| ?x766) 0)))
-(let ((@x1398 ((_ |th-lemma| arith triangle-eq) (or (not $x881) $x907))))
-(let ((@x1399 (|unit-resolution| @x1398 (|unit-resolution| @x885 @x1325 $x881) $x907)))
-(let (($x905 (>= (+ |x2$| (* (~ 1) |x11$|)) 0)))
-(let (($x920 (>= (+ |x6$| ?x682) 0)))
-(let (($x953 (not $x920)))
-(let (($x910 (<= (+ |x8$| ?x738) 0)))
-(let ((?x767 (+ |x8$| |x10$| ?x766)))
-(let (($x889 (>= ?x767 0)))
-(let (($x768 (= ?x767 0)))
-(let ((@x762 (monotonicity (monotonicity (rewrite (= $x295 $x754)) (= ?x310 ?x757)) (= (+ ?x273 ?x310) (+ ?x273 ?x757)))))
-(let ((@x765 (monotonicity @x762 (= (= |x10$| (+ ?x273 ?x310)) (= |x10$| (+ ?x273 ?x757))))))
-(let ((@x772 (trans @x765 (rewrite (= (= |x10$| (+ ?x273 ?x757)) $x768)) (= (= |x10$| (+ ?x273 ?x310)) $x768))))
-(let ((@x753 (monotonicity (rewrite (= ?x318 (+ ?x273 ?x310))) (= $x323 (= |x10$| (+ ?x273 ?x310))))))
-(let ((@x516 (monotonicity (monotonicity (rewrite (= $x295 $x295)) (= ?x310 ?x310)) (= ?x318 ?x318))))
-(let ((@x518 (mp (mp (|and-elim| @x429 $x323) (|rewrite*| (= $x323 $x323)) $x323) (monotonicity @x516 (= $x323 $x323)) $x323)))
-(let ((@x775 (mp (mp @x518 (monotonicity @x516 (= $x323 $x323)) $x323) (trans @x753 @x772 (= $x323 $x768)) $x768)))
-(let ((@x1385 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x768) $x889)) @x775 $x889)))
-(let (($x892 (not $x782)))
-(let (($x1411 (not $x890)))
-(let (($x911 (>= (+ |x10$| (* (~ 1) ?x785)) 0)))
-(let (($x981 (not $x911)))
-(let (($x957 (not $x905)))
-(let ((@x958 (hypothesis $x957)))
-(let (($x586 (>= |x3$| 0)))
-(let ((@x978 (hypothesis $x908)))
-(let ((@x963 (hypothesis $x911)))
-(let (($x864 (= ?x242 ?x701)))
-(let (($x1070 (not $x864)))
-(let (($x1026 (<= (+ ?x242 ?x710) 0)))
-(let (($x1149 (not $x1026)))
-(let (($x916 (>= (+ |x4$| (* (~ 1) ?x617)) 0)))
-(let (($x829 (not $x586)))
-(let ((@x935 (hypothesis $x829)))
-(let (($x1094 (not $x855)))
-(let (($x1086 (>= (+ ?x211 ?x682) 0)))
-(let (($x1119 (not $x1086)))
-(let (($x928 (<= (+ |x3$| (* (~ 1) (ite $x586 |x3$| ?x118))) 0)))
-(let (($x926 (<= (+ ?x118 (* (~ 1) (ite $x586 |x3$| ?x118))) 0)))
-(let ((?x589 (ite $x586 |x3$| ?x118)))
-(let (($x828 (= ?x118 ?x589)))
-(let ((@x1005 (|unit-resolution| (|def-axiom| (or $x586 $x828)) @x935 $x828)))
-(let ((@x1009 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x828) $x926)) @x1005 $x926)))
-(let (($x922 (<= (+ ?x149 (* (~ 1) ?x617)) 0)))
-(let (($x837 (= ?x149 ?x617)))
-(let ((@x1188 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x837) $x922)) (|unit-resolution| (|def-axiom| (or $x614 $x837)) @x1010 $x837) $x922)))
-(let ((@x1191 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1) (or $x925 $x614 (not $x922))) @x1188 @x1010 $x925)))
-(let ((@x1116 (hypothesis $x928)))
-(let ((@x1115 (hypothesis $x925)))
-(let ((@x1114 (hypothesis $x1086)))
-(let ((@x1113 (|unit-resolution| @x1112 (|unit-resolution| @x867 (hypothesis $x698) $x863) $x1087)))
-(let ((@x1088 (hypothesis $x698)))
-(let (($x861 (<= ?x683 0)))
-(let ((@x945 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x684) $x861)) @x691 $x861)))
-(let ((?x626 (* (~ 1) ?x617)))
-(let ((?x627 (+ |x3$| |x5$| ?x626)))
-(let (($x844 (>= ?x627 0)))
-(let (($x628 (= ?x627 0)))
-(let ((@x622 (monotonicity (monotonicity (rewrite (= $x140 $x614)) (= ?x155 ?x617)) (= (+ ?x118 ?x155) (+ ?x118 ?x617)))))
-(let ((@x625 (monotonicity @x622 (= (= |x5$| (+ ?x118 ?x155)) (= |x5$| (+ ?x118 ?x617))))))
-(let ((@x632 (trans @x625 (rewrite (= (= |x5$| (+ ?x118 ?x617)) $x628)) (= (= |x5$| (+ ?x118 ?x155)) $x628))))
-(let ((@x613 (monotonicity (rewrite (= ?x163 (+ ?x118 ?x155))) (= $x168 (= |x5$| (+ ?x118 ?x155))))))
-(let ((@x486 (monotonicity (monotonicity (rewrite (= $x140 $x140)) (= ?x155 ?x155)) (= ?x163 ?x163))))
-(let ((@x488 (mp (mp (|and-elim| @x429 $x168) (|rewrite*| (= $x168 $x168)) $x168) (monotonicity @x486 (= $x168 $x168)) $x168)))
-(let ((@x635 (mp (mp @x488 (monotonicity @x486 (= $x168 $x168)) $x168) (trans @x613 @x632 (= $x168 $x628)) $x628)))
-(let ((@x934 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x628) $x844)) @x635 $x844)))
-(let ((?x794 (* (~ 1) ?x785)))
-(let ((?x795 (+ |x9$| |x11$| ?x794)))
-(let (($x897 (<= ?x795 0)))
-(let (($x796 (= ?x795 0)))
-(let ((@x790 (monotonicity (monotonicity (rewrite (= $x326 $x782)) (= ?x341 ?x785)) (= (+ ?x304 ?x341) (+ ?x304 ?x785)))))
-(let ((@x793 (monotonicity @x790 (= (= |x11$| (+ ?x304 ?x341)) (= |x11$| (+ ?x304 ?x785))))))
-(let ((@x800 (trans @x793 (rewrite (= (= |x11$| (+ ?x304 ?x785)) $x796)) (= (= |x11$| (+ ?x304 ?x341)) $x796))))
-(let ((@x781 (monotonicity (rewrite (= ?x349 (+ ?x304 ?x341))) (= $x354 (= |x11$| (+ ?x304 ?x341))))))
-(let ((@x522 (monotonicity (monotonicity (rewrite (= $x326 $x326)) (= ?x341 ?x341)) (= ?x349 ?x349))))
-(let ((@x524 (mp (mp (|and-elim| @x429 $x354) (|rewrite*| (= $x354 $x354)) $x354) (monotonicity @x522 (= $x354 $x354)) $x354)))
-(let ((@x803 (mp (mp @x524 (monotonicity @x522 (= $x354 $x354)) $x354) (trans @x781 @x800 (= $x354 $x796)) $x796)))
-(let ((@x962 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x796) $x897)) @x803 $x897)))
-(let ((?x598 (* (~ 1) ?x589)))
-(let ((?x599 (+ |x2$| |x4$| ?x598)))
-(let (($x835 (>= ?x599 0)))
-(let (($x600 (= ?x599 0)))
-(let ((@x594 (monotonicity (monotonicity (rewrite (= $x109 $x586)) (= ?x124 ?x589)) (= (+ ?x86 ?x124) (+ ?x86 ?x589)))))
-(let ((@x597 (monotonicity @x594 (= (= |x4$| (+ ?x86 ?x124)) (= |x4$| (+ ?x86 ?x589))))))
-(let ((@x604 (trans @x597 (rewrite (= (= |x4$| (+ ?x86 ?x589)) $x600)) (= (= |x4$| (+ ?x86 ?x124)) $x600))))
-(let ((@x585 (monotonicity (rewrite (= ?x132 (+ ?x86 ?x124))) (= $x137 (= |x4$| (+ ?x86 ?x124))))))
-(let ((@x480 (monotonicity (monotonicity (rewrite (= $x109 $x109)) (= ?x124 ?x124)) (= ?x132 ?x132))))
-(let ((@x482 (mp (mp (|and-elim| @x429 $x137) (|rewrite*| (= $x137 $x137)) $x137) (monotonicity @x480 (= $x137 $x137)) $x137)))
-(let ((@x607 (mp (mp @x482 (monotonicity @x480 (= $x137 $x137)) $x137) (trans @x585 @x604 (= $x137 $x600)) $x600)))
-(let ((@x967 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x600) $x835)) @x607 $x835)))
-(let (($x888 (<= ?x767 0)))
-(let ((@x977 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x768) $x888)) @x775 $x888)))
-(let ((@x1117 ((_ |th-lemma| arith farkas -1 1 -1 1 -1 -1 1 1 -1 1 1 -1 -2 1) @x1082 @x1116 @x978 @x977 @x967 @x963 @x962 @x958 @x934 @x1115 @x945 @x1114 @x1088 @x1113 false)))
-(let ((@x1121 (lemma @x1117 (or $x865 (not $x928) (not $x908) $x981 $x905 (not $x925) $x1119))))
-(let ((@x869 (|def-axiom| (or $x698 $x864))))
-(let ((@x1127 (|unit-resolution| @x869 (|unit-resolution| @x1121 @x1114 @x978 @x963 @x958 @x1115 @x1116 $x865) $x864)))
-(let ((@x1129 ((_ |th-lemma| arith farkas -1 1 -1 1 -1 -1 1 1 -1 1 1 -1 1) @x1082 @x1116 @x978 @x977 @x967 @x963 @x962 @x958 @x934 @x1115 @x945 @x1114 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1070 $x1026)) @x1127 $x1026) false)))
-(let ((@x1131 (lemma @x1129 (or $x1119 (not $x928) (not $x908) $x981 $x905 (not $x925)))))
-(let ((@x1192 (|unit-resolution| @x1131 @x1191 @x978 @x963 @x958 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x928 (not $x926) $x586)) @x1009 @x935 $x928) $x1119)))
-(let ((@x1139 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1094 $x1086)) (hypothesis $x855) (hypothesis $x1119) false)))
-(let ((@x1140 (lemma @x1139 (or $x1094 $x1086))))
-(let ((@x1195 (|unit-resolution| @x858 (|unit-resolution| @x860 (|unit-resolution| @x1140 @x1192 $x1094) $x670) $x854)))
-(let (($x1022 (<= (+ |x5$| ?x654) 0)))
-(let ((@x1201 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1) (or $x642 (not $x922) (not $x844) $x586 $x614)) @x1010 @x934 @x935 @x1188 $x642)))
-(let ((@x849 (|def-axiom| (or $x847 $x845))))
-(let ((@x1041 ((_ |th-lemma| arith triangle-eq) (or (not $x845) $x1022))))
-(let ((@x1207 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x698 (not $x1183) (not $x862) $x614 (not $x1022) (not $x853)))))
-(let ((@x1208 (|unit-resolution| @x1207 @x1010 @x1100 @x1046 (|unit-resolution| @x1041 (|unit-resolution| @x849 @x1201 $x845) $x1022) (|unit-resolution| @x1197 @x1195 $x1183) $x698)))
-(let (($x843 (<= ?x627 0)))
-(let ((@x1079 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x628) $x843)) @x635 $x843)))
-(let (($x1179 (>= (+ ?x149 ?x626) 0)))
-(let ((@x1213 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x837) $x1179)) (|unit-resolution| (|def-axiom| (or $x614 $x837)) @x1010 $x837) $x1179)))
-(let ((@x1214 ((_ |th-lemma| arith farkas -1 -1 1 1 -1 -1 1 1 1 -1 -1 1 1) @x1082 @x978 @x977 @x1009 @x967 @x963 @x962 @x958 (|unit-resolution| @x1197 @x1195 $x1183) @x1100 @x1213 @x1079 (|unit-resolution| @x1112 (|unit-resolution| @x867 @x1208 $x863) $x1087) false)))
-(let ((@x1221 (|unit-resolution| (lemma @x1214 (or $x614 (not $x908) $x981 $x905 $x586)) @x935 @x963 @x958 @x978 $x614)))
-(let ((@x1075 ((_ |th-lemma| arith triangle-eq) (or (not $x836) $x916))))
-(let ((@x1225 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1) (or $x642 (not $x844) $x586 $x838 (not $x925))) (|unit-resolution| @x940 (|unit-resolution| @x840 @x1221 $x836) $x925) @x934 @x935 @x1221 $x642)))
-(let ((@x1038 ((_ |th-lemma| arith triangle-eq) (or (not $x845) $x1023))))
-(let ((@x1228 (|unit-resolution| @x1131 (|unit-resolution| @x940 (|unit-resolution| @x840 @x1221 $x836) $x925) @x978 @x963 @x958 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x928 (not $x926) $x586)) @x1009 @x935 $x928) $x1119)))
-(let ((@x1231 (|unit-resolution| @x858 (|unit-resolution| @x860 (|unit-resolution| @x1140 @x1228 $x1094) $x670) $x854)))
-(let ((@x1055 ((_ |th-lemma| arith triangle-eq) (or (not $x854) $x920))))
-(let (($x1150 (not $x916)))
-(let (($x1064 (not $x1023)))
-(let (($x1060 (not $x926)))
-(let (($x980 (not $x908)))
-(let ((@x1147 (hypothesis $x916)))
-(let (($x852 (<= ?x655 0)))
-(let ((@x1059 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x656) $x852)) @x663 $x852)))
-(let ((@x946 (hypothesis $x920)))
-(let ((@x1181 (hypothesis $x926)))
-(let ((@x1182 ((_ |th-lemma| arith farkas -1 -1 1 1 -1 -1 1 1 -1 1 -2 2 -1 1 1) @x1082 @x978 @x977 @x1181 @x967 @x963 @x962 @x958 @x946 @x945 (hypothesis $x1023) @x1059 @x1147 @x1079 (hypothesis $x1026) false)))
-(let ((@x1233 (|unit-resolution| (lemma @x1182 (or $x1149 $x980 $x1060 $x981 $x905 $x953 $x1064 $x1150)) @x1009 @x978 @x963 @x958 (|unit-resolution| @x1055 @x1231 $x920) (|unit-resolution| @x1038 (|unit-resolution| @x849 @x1225 $x845) $x1023) (|unit-resolution| @x1075 (|unit-resolution| @x840 @x1221 $x836) $x916) $x1149)))
-(let ((@x1153 (hypothesis $x1149)))
-(let ((@x1155 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1070 $x1026)) (hypothesis $x864) @x1153 false)))
-(let ((@x1156 (lemma @x1155 (or $x1070 $x1026))))
-(let ((@x1236 (|unit-resolution| @x867 (|unit-resolution| @x869 (|unit-resolution| @x1156 @x1233 $x1070) $x698) $x863)))
-(let ((@x1238 ((_ |th-lemma| arith farkas -1 -1 1 1 -1 -1 1 1 -1 1 -2 2 -2 -1 1 1) @x1082 @x978 @x977 @x1009 @x967 @x963 @x962 @x958 (|unit-resolution| @x1055 @x1231 $x920) @x945 (|unit-resolution| @x1038 (|unit-resolution| @x849 @x1225 $x845) $x1023) @x1059 (|unit-resolution| @x869 (|unit-resolution| @x1156 @x1233 $x1070) $x698) (|unit-resolution| @x1075 (|unit-resolution| @x840 @x1221 $x836) $x916) @x1079 (|unit-resolution| @x1112 @x1236 $x1087) false)))
-(let ((@x1219 (|unit-resolution| (lemma @x1238 (or $x586 $x980 $x981 $x905)) @x963 @x978 @x958 $x586)))
-(let (($x827 (= |x3$| ?x589)))
-(let ((@x831 (|def-axiom| (or $x829 $x827))))
-(let ((@x972 ((_ |th-lemma| arith triangle-eq) (or (not $x827) $x928))))
-(let ((@x1241 (|unit-resolution| @x972 (|unit-resolution| @x831 @x1219 $x827) $x928)))
-(let ((@x1258 (|unit-resolution| @x1140 (|unit-resolution| @x1131 @x1191 @x978 @x963 @x958 @x1241 $x1119) $x1094)))
-(let ((@x1261 (|unit-resolution| @x1197 (|unit-resolution| @x858 (|unit-resolution| @x860 @x1258 $x670) $x854) $x1183)))
-(let ((@x1248 (hypothesis $x1183)))
-(let ((@x1251 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 2) (or $x698 (not $x1183) (not $x862) $x614 (not $x853) (not $x1180) $x642))))
-(let ((@x1253 (|unit-resolution| @x867 (|unit-resolution| @x1251 @x1091 @x1046 @x1100 @x1010 @x1248 @x1247 $x698) $x863)))
-(let ((@x1011 (hypothesis $x904)))
-(let ((@x1255 ((_ |th-lemma| arith farkas 1 1 1 2 1 1 1 1 1 1 1 1 1 2 1) @x1082 @x1248 @x1100 @x1091 @x978 @x977 @x967 @x963 @x962 @x1011 @x934 @x1188 @x1116 @x1010 (|unit-resolution| @x1112 @x1253 $x1087) false)))
-(let ((@x1262 (|unit-resolution| (lemma @x1255 (or $x642 (not $x1183) $x980 $x981 $x1013 (not $x928) $x614)) @x1261 @x978 @x963 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x905 $x904)) @x958 $x904) @x1241 @x1010 $x642)))
-(let ((@x1265 (|unit-resolution| @x1207 (|unit-resolution| @x1041 (|unit-resolution| @x849 @x1262 $x845) $x1022) @x1100 @x1010 @x1261 @x1046 $x698)))
-(let ((@x1268 ((_ |th-lemma| arith farkas -1/2 1/2 -1/2 1/2 -1/2 1/2 1/2 -1/2 1/2 1/2 -1/2 -1/2 -1/2 1) @x1079 @x1213 (|unit-resolution| @x1112 (|unit-resolution| @x867 @x1265 $x863) $x1087) @x1082 @x1261 @x1100 @x978 @x977 @x967 @x963 @x962 @x958 @x1241 @x1219 false)))
-(let ((@x1272 (|unit-resolution| (lemma @x1268 (or $x614 $x980 $x981 $x905)) @x963 @x978 @x958 $x614)))
-(let ((@x1282 (|unit-resolution| @x1131 (|unit-resolution| @x940 (|unit-resolution| @x840 @x1272 $x836) $x925) @x978 @x963 @x958 @x1241 $x1119)))
-(let ((@x1284 (|unit-resolution| @x860 (|unit-resolution| @x1140 @x1282 $x1094) $x670)))
-(let (($x1271 (>= (+ ?x180 ?x654) 0)))
-(let ((@x1287 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x846) $x1271)) (|unit-resolution| (|def-axiom| (or $x642 $x846)) @x1091 $x846) $x1271)))
-(let ((@x1290 (|unit-resolution| @x1112 (|unit-resolution| @x867 (|unit-resolution| @x1279 @x1091 @x1284 $x698) $x863) $x1087)))
-(let ((@x1293 ((_ |th-lemma| arith farkas -1 1 -1 1 1 -1 1 1 -1 -1 -1 1 -1 1 1) (|unit-resolution| @x1197 (|unit-resolution| @x858 @x1284 $x854) $x1183) @x1100 @x1290 @x1082 @x978 @x977 @x967 @x963 @x962 @x958 @x1241 @x1287 @x1059 @x1219 @x1284 false)))
-(let ((@x1298 (|unit-resolution| (lemma @x1293 (or $x642 $x980 $x981 $x905)) @x963 @x978 @x958 $x642)))
-(let ((@x1144 (|unit-resolution| @x972 (|unit-resolution| @x831 (hypothesis $x586) $x827) $x928)))
-(let ((@x1148 ((_ |th-lemma| arith farkas -1/2 1/2 1 -1 -1/2 1/2 -1/2 1/2 -1/2 1/2 1/2 -1/2 -1/2 -1/2 1/2 1) @x1079 @x1147 (hypothesis $x1023) @x1059 (hypothesis $x1026) @x1082 @x1144 @x978 @x977 @x967 @x963 @x962 @x958 @x945 @x946 (hypothesis $x586) false)))
-(let ((@x1301 (|unit-resolution| (lemma @x1148 (or $x1149 $x1150 $x1064 $x980 $x981 $x905 $x953 $x829)) (|unit-resolution| @x1038 (|unit-resolution| @x849 @x1298 $x845) $x1023) @x1219 @x978 @x963 @x958 (|unit-resolution| @x1075 (|unit-resolution| @x840 @x1272 $x836) $x916) (|unit-resolution| @x1055 (|unit-resolution| @x858 @x1284 $x854) $x920) $x1149)))
-(let ((@x1304 (|unit-resolution| @x867 (|unit-resolution| @x869 (|unit-resolution| @x1156 @x1301 $x1070) $x698) $x863)))
-(let ((@x1306 ((_ |th-lemma| arith farkas 1 -1 1/2 -1/2 1 1/2 -1/2 -1/2 1/2 1/2 -1/2 1/2 1/2 -1/2 -1/2 -1/2 1) (|unit-resolution| @x1038 (|unit-resolution| @x849 @x1298 $x845) $x1023) @x1059 (|unit-resolution| @x1075 (|unit-resolution| @x840 @x1272 $x836) $x916) @x1079 (|unit-resolution| @x869 (|unit-resolution| @x1156 @x1301 $x1070) $x698) (|unit-resolution| @x1055 (|unit-resolution| @x858 @x1284 $x854) $x920) @x945 (|unit-resolution| @x1112 @x1304 $x1087) @x1082 @x978 @x977 @x967 @x963 @x962 @x958 @x1241 @x1219 false)))
-(let ((@x1414 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1411 $x911)) (hypothesis $x890) (hypothesis $x981) false)))
-(let ((@x1415 (lemma @x1414 (or $x1411 $x911))))
-(let ((@x1417 (|unit-resolution| @x1415 (|unit-resolution| (lemma @x1306 (or $x981 $x980 $x905)) @x958 @x1394 $x981) $x1411)))
-(let ((@x894 (|def-axiom| (or $x892 $x890))))
-(let ((@x1418 (|unit-resolution| @x894 @x1417 $x892)))
-(let ((@x1440 ((_ |th-lemma| arith assign-bounds 1 1 1 1) (or $x726 $x782 (not $x907) (not $x889) $x883))))
-(let ((@x1465 (|unit-resolution| @x876 (|unit-resolution| @x1440 @x1418 @x1385 @x1325 @x1399 $x726) $x872)))
-(let ((@x1376 ((_ |th-lemma| arith triangle-eq) (or (not $x872) $x910))))
-(let ((@x1466 (|unit-resolution| @x1376 @x1465 $x910)))
-(let (($x1031 (not $x925)))
-(let (($x992 (not $x922)))
-(let ((@x1092 (hypothesis $x856)))
-(let ((@x1050 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x670 (not $x1022) (not $x844) $x586 $x1031 (not $x853)))))
-(let ((@x1317 (|unit-resolution| @x1050 @x1092 @x1046 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x1022 (not $x1180) $x642)) @x1247 @x1091 $x1022) @x935 @x934 $x1031)))
-(let ((@x1320 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1) (or $x614 (not $x1180) $x642 (not $x853) $x670)) @x1092 @x1046 @x1091 @x1247 $x614)))
-(let ((@x1324 (lemma (|unit-resolution| @x940 (|unit-resolution| @x840 @x1320 $x836) @x1317 false) (or $x670 $x586 $x642))))
-(let ((@x1330 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 1 -1 1 -1) (or $x992 (not $x844) $x586 (not $x1271) (not $x852) $x856)) (|unit-resolution| @x1324 @x935 @x1091 $x670) @x1059 @x934 @x935 @x1287 $x992)))
-(let ((@x1332 (|unit-resolution| @x1055 (|unit-resolution| @x858 (|unit-resolution| @x1324 @x935 @x1091 $x670) $x854) $x920)))
-(let ((@x1337 (|unit-resolution| @x1197 (|unit-resolution| @x858 (|unit-resolution| @x1324 @x935 @x1091 $x670) $x854) $x1183)))
-(let ((@x930 (hypothesis $x917)))
-(let ((@x941 (|unit-resolution| @x940 (|unit-resolution| @x840 (hypothesis $x614) $x836) $x925)))
-(let ((@x952 ((_ |th-lemma| arith farkas 1 -1 1 -1 1 -1 -1 1 1) (hypothesis $x726) @x950 @x946 @x945 (hypothesis $x614) @x941 @x935 @x934 @x930 false)))
-(let ((@x1343 (|unit-resolution| (lemma @x952 (or $x586 (not $x726) $x953 $x838 $x954)) (|unit-resolution| @x1341 @x1337 @x1082 @x1091 @x1100 @x1336 $x726) @x1335 @x935 @x1332 $x838)))
-(let ((@x1345 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x837) $x922)) (|unit-resolution| (|def-axiom| (or $x614 $x837)) @x1343 $x837) @x1330 false)))
-(let ((@x1379 (|unit-resolution| @x831 (|unit-resolution| (lemma @x1345 (or $x586 $x642)) @x1091 $x586) $x827)))
-(let ((@x1380 (|unit-resolution| @x972 @x1379 $x928)))
-(let (($x1352 (>= (+ ?x335 ?x794) 0)))
-(let ((@x1407 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1368 $x1352)) (hypothesis $x891) (hypothesis (not $x1352)) false)))
-(let ((@x1408 (lemma @x1407 (or $x1368 $x1352))))
-(let ((@x1420 (|unit-resolution| @x1408 (|unit-resolution| (|def-axiom| (or $x782 $x891)) @x1418 $x891) $x1352)))
-(let ((@x1097 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1094 $x1027)) (|unit-resolution| @x860 @x1092 $x855) $x1027)))
-(let ((@x1359 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x1183 $x920)) (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x953 (not $x1027) $x670)) @x1097 @x1092 $x953) $x1183)))
-(let ((@x1361 (|unit-resolution| @x876 (|unit-resolution| @x1341 @x1359 @x1082 @x1100 @x1091 @x1336 $x726) $x872)))
-(let ((@x1106 ((_ |th-lemma| arith farkas 1 1 1 1 1 1 1 1 1) @x1105 @x1104 @x1100 @x1092 @x978 @x977 @x1097 @x1091 (hypothesis $x782) false)))
-(let ((@x1366 (|unit-resolution| (lemma @x1106 (or $x642 $x1107 $x670 $x980 $x892)) (|unit-resolution| @x1364 @x1361 $x914) @x1091 @x978 @x1092 $x892)))
-(let ((@x896 (|def-axiom| (or $x782 $x891))))
-(let ((@x1371 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1368 $x1352)) (|unit-resolution| @x896 @x1366 $x891) $x1352)))
-(let (($x880 (>= ?x739 0)))
-(let ((@x1374 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x740) $x880)) @x747 $x880)))
-(let ((@x1382 (|unit-resolution| @x1140 (|unit-resolution| @x860 @x1092 $x855) $x1086)))
-(let ((@x1386 (hypothesis $x907)))
-(let ((@x1387 ((_ |th-lemma| arith farkas 1 -1 1 -1 -1 1 -1 -1 1 -1 1 -1 -2 2 1) @x1082 @x1386 @x1385 @x1336 @x945 @x1382 @x962 @x958 @x967 (|unit-resolution| @x940 (|unit-resolution| @x840 @x1320 $x836) $x925) @x934 @x1380 (|unit-resolution| @x1376 @x1361 $x910) @x1374 @x1371 false)))
-(let ((@x1421 (|unit-resolution| (lemma @x1387 (or $x670 (not $x907) $x905 $x642 $x980)) @x1091 @x958 @x1399 @x1394 $x670)))
-(let ((@x1401 ((_ |th-lemma| arith farkas -1/2 1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 -1/2 1/2 -1/2 1/2 -1/2 1) @x950 @x930 @x946 @x945 (hypothesis $x1352) @x1399 @x1385 @x962 @x958 @x967 @x1115 @x934 @x1116 @x1325 false)))
-(let ((@x1424 (|unit-resolution| (lemma @x1401 (or (not $x1352) $x954 $x953 $x905 $x1031 (not $x928) $x883)) (|unit-resolution| @x1055 (|unit-resolution| @x858 @x1421 $x854) $x920) @x1420 @x958 @x1380 @x1335 @x1325 $x1031)))
-(let ((@x1426 (|unit-resolution| @x1341 @x1336 @x1082 @x1091 (|unit-resolution| @x1197 (|unit-resolution| @x858 @x1421 $x854) $x1183) @x1100 $x726)))
-(let ((@x1429 (|unit-resolution| @x1351 (|unit-resolution| @x1364 (|unit-resolution| @x876 @x1426 $x872) $x914) @x1091 @x1325 $x614)))
-(let ((@x1433 (lemma (|unit-resolution| @x940 (|unit-resolution| @x840 @x1429 $x836) @x1424 false) (or $x642 $x883 $x905))))
-(let ((@x1469 (|unit-resolution| @x1038 (|unit-resolution| @x849 (|unit-resolution| @x1433 @x958 @x1325 $x642) $x845) $x1023)))
-(let ((@x1436 (|unit-resolution| @x1041 (|unit-resolution| @x849 (hypothesis $x642) $x845) $x1022)))
-(let ((@x1442 (|unit-resolution| @x876 (|unit-resolution| @x1440 (hypothesis $x892) @x1385 @x1325 @x1399 $x726) $x872)))
-(let ((@x1448 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x698 $x782 (not $x910) (not $x880) (not $x907) (not $x889)))))
-(let ((@x1449 (|unit-resolution| @x1448 (|unit-resolution| @x1376 @x1442 $x910) @x1385 (hypothesis $x892) @x1399 @x1374 $x698)))
-(let ((@x1434 (hypothesis $x642)))
-(let ((@x1452 ((_ |th-lemma| arith farkas -1 1 -1 -1 -1 1 1 -1 1) @x1434 @x950 (|unit-resolution| @x1173 (|unit-resolution| @x867 @x1449 $x863) $x917) @x1325 (|unit-resolution| @x1364 @x1442 $x914) @x1104 @x1010 @x1046 @x1436 false)))
-(let ((@x1470 (|unit-resolution| (lemma @x1452 (or $x614 $x847 $x883 $x782)) (|unit-resolution| @x1433 @x958 @x1325 $x642) @x1325 @x1418 $x614)))
-(let (($x1065 (not $x852)))
-(let (($x1446 (not $x880)))
-(let (($x1445 (not $x910)))
-(let (($x1438 (not $x889)))
-(let (($x1388 (not $x907)))
-(let (($x990 (not $x861)))
-(let ((@x1473 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1 -1 1 1 -1 1 1 -1) (or $x953 $x990 $x782 $x1388 $x1438 $x1064 $x1445 $x1446 $x838 $x1065)) @x1418 @x945 @x1374 @x1385 @x1059 @x1399 @x1470 @x1469 @x1466 $x953)))
-(let ((@x1474 (|unit-resolution| @x1041 (|unit-resolution| @x849 (|unit-resolution| @x1433 @x958 @x1325 $x642) $x845) $x1022)))
-(let ((@x1478 (|unit-resolution| @x867 (|unit-resolution| @x1448 @x1466 @x1385 @x1418 @x1399 @x1374 $x698) $x863)))
-(let ((@x1455 (hypothesis $x1087)))
-(let ((@x1458 (|unit-resolution| @x831 (|unit-resolution| @x1050 @x1092 @x1046 (hypothesis $x1022) @x1115 @x934 $x586) $x827)))
-(let ((@x1460 (hypothesis $x910)))
-(let ((@x1461 ((_ |th-lemma| arith farkas -1 -2 2 -1 1 1 -1 -1 1 -1 1 -1 -1 1 1) @x945 @x1460 @x1374 @x1386 @x1385 (hypothesis $x1352) @x962 @x958 @x967 (|unit-resolution| @x972 @x1458 $x928) @x1082 @x1455 @x1115 @x934 @x1382 false)))
-(let ((@x1463 (lemma @x1461 (or $x670 $x1445 $x1388 (not $x1352) $x905 (not $x1087) $x1031 (not $x1022)))))
-(let ((@x1480 (|unit-resolution| @x1463 @x1466 @x1399 @x1420 @x958 (|unit-resolution| @x1112 @x1478 $x1087) (|unit-resolution| @x940 (|unit-resolution| @x840 @x1470 $x836) $x925) @x1474 $x670)))
-(let ((@x1484 (lemma (|unit-resolution| @x1055 (|unit-resolution| @x858 @x1480 $x854) @x1473 false) (or $x905 $x883))))
-(let (($x820 (not $x70)))
-(let ((@x1514 (|unit-resolution| @x876 (|unit-resolution| @x1341 @x1359 @x1082 @x1091 @x1336 @x1100 $x726) $x872)))
-(let (($x919 (>= (+ |x3$| ?x598) 0)))
-(let ((@x1517 ((_ |th-lemma| arith triangle-eq) (or (not $x827) $x919))))
-(let ((@x1518 (|unit-resolution| @x1517 @x1379 $x919)))
-(let ((@x1519 (|unit-resolution| (lemma @x1106 (or $x642 $x1107 $x670 $x980 $x892)) (|unit-resolution| @x1364 @x1514 $x914) @x1091 @x978 @x1092 $x892)))
-(let ((@x1523 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1368 $x1496)) (|unit-resolution| @x896 @x1519 $x891) $x1496)))
-(let ((@x1497 (hypothesis $x1027)))
-(let ((@x1498 (hypothesis $x919)))
-(let (($x834 (<= ?x599 0)))
-(let ((@x1501 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x600) $x834)) @x607 $x834)))
-(let ((@x1502 (hypothesis $x1013)))
-(let (($x898 (>= ?x795 0)))
-(let ((@x1505 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x796) $x898)) @x803 $x898)))
-(let ((@x1507 ((_ |th-lemma| arith farkas 1/2 -1 -1/2 -1/2 1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 1) @x930 @x1104 @x950 (hypothesis $x1496) @x1505 @x1502 @x1501 @x1498 @x1079 @x978 @x977 @x1147 @x1497 @x1100 @x1105 false)))
-(let ((@x1511 (lemma @x1507 (or $x904 $x954 $x1508 (not $x919) $x980 $x1150 (not $x1027) $x1107))))
-(let ((@x1524 (|unit-resolution| @x1511 @x1523 @x1335 @x1518 @x978 @x1147 @x1097 (|unit-resolution| @x1364 @x1514 $x914) $x904)))
-(let ((@x1526 ((_ |th-lemma| arith triangle-eq) (or $x71 $x1013 $x957))))
-(let (($x809 (or $x820 $x808)))
-(let ((@x816 (monotonicity (rewrite (= $x72 (not $x809))) (= (not $x72) (not (not $x809))))))
-(let ((@x806 (trans @x816 (rewrite (= (not (not $x809)) $x809)) (= (not $x72) $x809))))
-(let (($x439 (not $x72)))
-(let ((@x807 (mp (mp (|not-or-elim| @x428 $x439) (|rewrite*| (= $x439 $x439)) $x439) @x806 $x809)))
-(let ((@x1528 (|unit-resolution| @x807 (|unit-resolution| @x1526 @x1524 (hypothesis $x905) $x71) $x820)))
-(let (($x901 (>= (+ |x1$| ?x335) 0)))
-(let (($x558 (>= |x2$| 0)))
-(let ((?x561 (ite $x558 |x2$| ?x86)))
-(let ((?x570 (* (~ 1) ?x561)))
-(let ((?x571 (+ |x3$| |x1$| ?x570)))
-(let (($x826 (>= ?x571 0)))
-(let (($x572 (= ?x571 0)))
-(let ((@x566 (monotonicity (monotonicity (rewrite (= $x76 $x558)) (= ?x92 ?x561)) (= (+ ?x100 ?x92) (+ ?x100 ?x561)))))
-(let ((@x569 (monotonicity @x566 (= (= |x3$| (+ ?x100 ?x92)) (= |x3$| (+ ?x100 ?x561))))))
-(let ((@x576 (trans @x569 (rewrite (= (= |x3$| (+ ?x100 ?x561)) $x572)) (= (= |x3$| (+ ?x100 ?x92)) $x572))))
-(let ((@x557 (monotonicity (rewrite (= ?x101 (+ ?x100 ?x92))) (= $x106 (= |x3$| (+ ?x100 ?x92))))))
-(let ((@x474 (monotonicity (monotonicity (rewrite (= $x76 $x76)) (= ?x92 ?x92)) (= ?x101 ?x101))))
-(let ((@x476 (mp (mp (|and-elim| @x429 $x106) (|rewrite*| (= $x106 $x106)) $x106) (monotonicity @x474 (= $x106 $x106)) $x106)))
-(let ((@x579 (mp (mp @x476 (monotonicity @x474 (= $x106 $x106)) $x106) (trans @x557 @x576 (= $x106 $x572)) $x572)))
-(let ((@x1533 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x572) $x826)) @x579 $x826)))
-(let (($x1485 (<= (+ |x2$| ?x570) 0)))
-(let (($x822 (= |x2$| ?x561)))
-(let ((@x1535 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x558 (not $x835) $x642 $x1031 (not $x844) (not $x928)))))
-(let ((@x812 (|def-axiom| (or (not $x558) $x822))))
-(let ((@x1537 (|unit-resolution| @x812 (|unit-resolution| @x1535 @x1115 @x934 @x1091 @x1380 @x967 $x558) $x822)))
-(let ((@x1540 ((_ |th-lemma| arith triangle-eq) (or (not $x822) $x1485))))
-(let ((@x1542 ((_ |th-lemma| arith assign-bounds 1 -3/2 3/2 -1 1/2 -1/2 1/2 -1/2 -1 1 1/2 -1/2 -1/2 1/2 1/2 -1/2 1/2) (|unit-resolution| @x1540 @x1537 $x1485) @x967 @x1380 @x1533 @x1336 @x978 @x977 @x1082 @x1287 @x1059 @x1097 @x1100 (|unit-resolution| @x1408 (|unit-resolution| @x896 @x1519 $x891) $x1352) @x962 @x1524 @x934 @x1115 $x901)))
-(let (($x825 (<= ?x571 0)))
-(let ((@x1545 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x572) $x825)) @x579 $x825)))
-(let (($x1486 (>= (+ |x2$| ?x570) 0)))
-(let ((@x1547 ((_ |th-lemma| arith triangle-eq) (or (not $x822) $x1486))))
-(let ((@x1549 ((_ |th-lemma| arith assign-bounds 1 -3/2 3/2 -1 1/2 -1/2 1/2 -1/2 -1 1 1/2 -1/2 -1/2 1/2 1/2 -1/2 1/2) (|unit-resolution| @x1547 @x1537 $x1486) @x1501 @x1518 @x1545 @x1335 @x1386 @x1385 @x950 @x1247 @x1046 @x1382 @x945 @x1523 @x1505 (hypothesis $x905) @x1079 @x1147 $x900)))
-(let ((@x1553 ((_ |th-lemma| arith triangle-eq) (or $x70 (not $x900) (not $x901)))))
-(let ((@x1556 (lemma (|unit-resolution| @x1553 @x1549 @x1542 @x1528 false) (or $x670 $x1388 $x957 $x1150 $x980 $x1031 $x642))))
-(let ((@x1578 (|unit-resolution| @x1556 (|unit-resolution| @x1075 @x1574 $x916) (|unit-resolution| @x1484 @x1325 $x905) @x1399 @x1394 (|unit-resolution| @x940 @x1574 $x925) @x1091 $x670)))
-(let (($x1551 (not $x901)))
-(let ((@x1580 (|unit-resolution| @x1197 (|unit-resolution| @x858 @x1578 $x854) $x1183)))
-(let ((@x1585 (|unit-resolution| @x876 (|unit-resolution| @x1341 @x1580 @x1082 @x1091 @x1336 @x1100 $x726) $x872)))
-(let ((@x1586 (|unit-resolution| @x1364 @x1585 $x914)))
-(let ((@x1562 (|unit-resolution| @x876 (|unit-resolution| @x1341 @x1276 @x1082 @x1091 @x1336 @x1100 $x726) $x872)))
-(let ((@x1564 ((_ |th-lemma| arith farkas -1 -1 -1 1 -1 1 -1 1 1) @x1273 (hypothesis $x782) @x978 @x977 @x1100 @x1091 (|unit-resolution| @x1364 @x1562 $x914) @x1104 @x1276 false)))
-(let ((@x1587 (|unit-resolution| (lemma @x1564 (or $x892 $x856 $x980 $x642)) @x1578 @x1394 @x1091 $x892)))
-(let ((@x1558 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1368 $x1496)) (hypothesis $x891) (hypothesis $x1508) false)))
-(let ((@x1559 (lemma @x1558 (or $x1368 $x1496))))
-(let ((@x1590 (|unit-resolution| @x1511 (|unit-resolution| @x1559 (|unit-resolution| @x896 @x1587 $x891) $x1496) @x1586 @x1518 @x1394 (|unit-resolution| @x1075 @x1574 $x916) (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x1027 $x856 (not $x1183))) @x1580 @x1578 $x1027) @x1335 $x904)))
-(let ((@x1592 (|unit-resolution| @x807 (|unit-resolution| @x1526 @x1590 (|unit-resolution| @x1484 @x1325 $x905) $x71) $x820)))
-(let ((@x1593 (|unit-resolution| @x1535 (|unit-resolution| @x940 @x1574 $x925) @x934 @x1091 @x1380 @x967 $x558)))
-(let ((@x1567 (hypothesis (not $x900))))
-(let ((@x1569 ((_ |th-lemma| arith farkas 1 -1 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 1) @x930 @x950 @x1105 @x1104 @x946 @x1399 @x1385 @x945 (hypothesis $x1486) @x1501 @x1498 @x1545 @x1567 (hypothesis $x1180) @x1046 @x1325 false)))
-(let ((@x1572 (lemma @x1569 (or $x900 $x954 $x1107 $x953 (not $x1486) (not $x919) (not $x1180) $x883))))
-(let ((@x1597 (|unit-resolution| @x1572 @x1335 @x1586 (|unit-resolution| @x1055 (|unit-resolution| @x858 @x1578 $x854) $x920) (|unit-resolution| @x1547 (|unit-resolution| @x812 @x1593 $x822) $x1486) @x1518 @x1247 @x1325 $x900)))
-(let ((@x1600 ((_ |th-lemma| arith farkas -1/2 1/2 -1/2 1/2 1/2 -1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1) @x1580 @x1394 @x977 @x1100 @x1586 @x1104 (|unit-resolution| @x1540 (|unit-resolution| @x812 @x1593 $x822) $x1485) @x967 @x1380 @x1533 (|unit-resolution| @x1553 @x1597 @x1592 $x1551) @x1287 @x1059 @x1578 false)))
-(let ((@x887 (|def-axiom| (or $x754 $x882))))
-(let ((@x1646 (|unit-resolution| @x887 (|unit-resolution| (lemma @x1600 (or $x642 $x883)) @x1091 $x883) $x882)))
-(let ((@x1652 ((_ |th-lemma| arith triangle-eq) (or (not $x882) $x1616))))
-(let ((@x1653 (|unit-resolution| @x1652 @x1646 $x1616)))
-(let ((@x1617 (hypothesis $x883)))
-(let ((@x1620 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x1445 (not $x1087) $x1446 $x754 (not $x871) $x670)) @x1092 @x1374 @x1617 @x1113 @x1082 $x1445)))
-(let ((@x1623 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1) (or $x726 $x865 (not $x1087) (not $x871) $x670)) @x1092 @x1082 @x1088 @x1113 $x726)))
-(let ((@x1627 (lemma (|unit-resolution| @x1376 (|unit-resolution| @x876 @x1623 $x872) @x1620 false) (or $x670 $x865 $x754))))
-(let ((@x1637 (|unit-resolution| @x1627 (|unit-resolution| (lemma @x1311 (or $x698 $x642)) @x1091 $x698) (|unit-resolution| (lemma @x1600 (or $x642 $x883)) @x1091 $x883) $x670)))
-(let ((@x1639 (|unit-resolution| @x1197 (|unit-resolution| @x858 @x1637 $x854) $x1183)))
-(let ((@x1642 (|unit-resolution| (|unit-resolution| @x1341 @x1082 @x1100 (or $x726 (not $x1087) (not $x1183) $x642)) @x1639 @x1091 @x1336 $x726)))
-(let ((@x1644 (|unit-resolution| @x1364 (|unit-resolution| @x876 @x1642 $x872) $x914)))
-(let ((@x1645 (|unit-resolution| @x1055 (|unit-resolution| @x858 @x1637 $x854) $x920)))
-(let (($x1607 (<= (+ ?x304 ?x766) 0)))
-(let ((@x1649 ((_ |th-lemma| arith triangle-eq) (or (not $x882) $x1607))))
-(let ((@x1650 (|unit-resolution| @x1649 @x1646 $x1607)))
-(let ((@x1654 (|unit-resolution| @x1376 (|unit-resolution| @x876 @x1642 $x872) $x910)))
-(let ((@x1658 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 2) (or $x558 (not $x835) $x642 (not $x844) $x992 (not $x928) $x614)) @x934 @x967 (or $x558 $x642 $x992 (not $x928) $x614))))
-(let ((@x1660 (|unit-resolution| @x812 (|unit-resolution| @x1658 @x1188 @x1380 @x1091 @x1010 $x558) $x822)))
-(let (($x1205 (not $x862)))
-(let (($x1204 (not $x1183)))
-(let (($x1338 (not $x871)))
-(let (($x1339 (not $x1087)))
-(let (($x1061 (not $x888)))
-(let (($x1633 (not $x1616)))
-(let (($x1327 (not $x1271)))
-(let (($x1118 (not $x928)))
-(let (($x1663 (not $x826)))
-(let (($x1062 (not $x835)))
-(let (($x1662 (not $x1485)))
-(let (($x1664 (or $x901 $x1662 $x1062 $x1663 $x1118 $x1327 $x1065 $x1633 $x1061 $x1339 $x1338 $x1204 $x1205 $x1445 $x1446)))
-(let ((@x1666 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 -1 1 -1 1 2 -2 1 -1 1 -1) $x1664) (|unit-resolution| @x1540 @x1660 $x1485) @x1059 @x1100 @x1082 @x1374 @x977 @x1533 @x1380 @x1639 @x1336 @x1287 @x1654 @x1653 @x967 $x901)))
-(let (($x1671 (not $x879)))
-(let (($x989 (not $x870)))
-(let (($x1670 (not $x1607)))
-(let (($x1048 (not $x853)))
-(let (($x1249 (not $x1180)))
-(let (($x1509 (not $x919)))
-(let (($x1669 (not $x825)))
-(let (($x1668 (not $x834)))
-(let (($x1570 (not $x1486)))
-(let (($x1672 (or $x900 $x1570 $x1668 $x1669 $x1509 $x1249 $x1048 $x1670 $x1438 $x954 $x989 $x953 $x990 $x1107 $x1671)))
-(let ((@x1673 ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 -1 1 -1 1 2 -2 1 -1 1 -1) $x1672)))
-(let ((@x1674 (|unit-resolution| @x1673 (|unit-resolution| @x1547 @x1660 $x1486) @x1046 @x945 @x950 @x1104 @x1385 @x1545 @x1645 @x1335 @x1644 @x1518 @x1247 @x1501 @x1650 $x900)))
-(let ((@x1678 ((_ |th-lemma| arith assign-bounds 1 1 2 2 1 1 1 1 1 1 1) (or $x782 $x1670 $x1438 $x954 $x989 $x953 $x990 $x1249 $x1048 $x614 $x1107 $x1671))))
-(let ((@x1679 (|unit-resolution| @x1678 @x1010 @x945 @x950 @x1104 @x1385 @x1046 @x1645 @x1335 @x1644 @x1247 @x1650 $x782)))
-(let ((@x1629 (hypothesis $x922)))
-(let ((@x1632 ((_ |th-lemma| arith farkas -1 1 1 -1 1 -1 -2 2 -1 1 3 -3 1 -1 2 -2 1) @x963 @x962 @x958 @x967 @x1116 @x934 (hypothesis $x1271) @x1059 (hypothesis $x1616) @x977 @x1455 @x1082 @x1248 @x1100 @x1460 @x1374 @x1629 false)))
-(let ((@x1682 (|unit-resolution| (lemma @x1632 (or $x905 $x981 $x1118 $x1327 $x1633 $x1339 $x1204 $x1445 $x992)) (|unit-resolution| @x1415 (|unit-resolution| @x894 @x1679 $x890) $x911) @x1380 @x1287 @x1653 @x1336 @x1639 @x1654 @x1188 $x905)))
-(let ((@x1683 (|unit-resolution| @x1526 @x1682 (|unit-resolution| @x807 (|unit-resolution| @x1553 @x1674 @x1666 $x70) $x808) $x1013)))
-(let ((@x1685 ((_ |th-lemma| arith triangle-eq) (or $x1411 $x1628))))
-(let ((@x1687 ((_ |th-lemma| arith farkas -1 1 1 -1 1 -1 -2 2 -1 1 3 -3 1 -1 2 -2 1) (|unit-resolution| @x1685 (|unit-resolution| @x894 @x1679 $x890) $x1628) @x1505 @x1683 @x1501 @x1518 @x1079 @x1247 @x1046 @x1650 @x1385 @x1335 @x950 @x1645 @x945 @x1644 @x1104 @x1213 false)))
-(let ((@x1700 (|unit-resolution| @x840 (|unit-resolution| (lemma @x1687 (or $x614 $x642)) @x1091 $x614) $x836)))
-(let ((@x1702 (|unit-resolution| @x940 @x1700 $x925)))
-(let ((@x1705 (|unit-resolution| (|unit-resolution| @x1535 @x934 @x967 (or $x558 $x642 $x1031 $x1118)) @x1702 @x1091 @x1380 $x558)))
-(let ((@x1708 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 -1 1 -1 1 2 -2 1 -1 1 -1) $x1664) (|unit-resolution| @x1540 (|unit-resolution| @x812 @x1705 $x822) $x1485) @x1059 @x1100 @x1082 @x1374 @x977 @x967 @x1380 @x1639 @x1336 @x1287 @x1654 @x1653 @x1533 $x901)))
-(let ((@x1710 (|unit-resolution| @x1673 (|unit-resolution| @x1547 (|unit-resolution| @x812 @x1705 $x822) $x1486) @x1046 @x945 @x950 @x1104 @x1385 @x1501 @x1645 @x1335 @x1644 @x1518 @x1247 @x1545 @x1650 $x900)))
-(let ((@x1715 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x922 $x838 $x1031)) @x1702 (|unit-resolution| (lemma @x1687 (or $x614 $x642)) @x1091 $x614) $x922)))
-(let ((@x1690 (|unit-resolution| (lemma @x1632 (or $x905 $x981 $x1118 $x1327 $x1633 $x1339 $x1204 $x1445 $x992)) @x958 @x1116 (hypothesis $x1271) (hypothesis $x1616) @x1455 @x1248 @x1460 @x1629 $x981)))
-(let ((@x1693 (|unit-resolution| @x896 (|unit-resolution| @x894 (|unit-resolution| @x1415 @x1690 $x1411) $x892) $x891)))
-(let ((@x1696 ((_ |th-lemma| arith farkas -1 -1 -1 1 1 -1 1 -1 -1 1 1 -1 1) @x962 @x958 @x1115 @x934 @x967 @x1116 @x930 @x950 (hypothesis $x1607) @x1385 @x946 @x945 (|unit-resolution| @x1408 @x1693 $x1352) false)))
-(let ((@x1698 (lemma @x1696 (or $x905 $x1031 $x1118 $x954 $x1670 $x953 $x1327 $x1633 $x1339 $x1204 $x1445 $x992))))
-(let ((@x1716 (|unit-resolution| @x1698 @x1702 @x1380 @x1335 @x1650 @x1645 @x1287 @x1653 @x1336 @x1639 @x1654 @x1715 $x905)))
-(let ((@x1717 (|unit-resolution| @x1526 @x1716 (|unit-resolution| @x807 (|unit-resolution| @x1553 @x1710 @x1708 $x70) $x808) $x1013)))
-(let (($x1719 (not $x843)))
-(let (($x1718 (not $x898)))
-(let (($x1720 (or $x1508 $x1718 $x904 $x1150 $x1719 $x1668 $x1509 $x1339 $x1338 $x1633 $x1061 $x1204 $x1205)))
-(let ((@x1722 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1 -1 1 1 -1 1 -1 -1 1 1 -1) $x1720) @x1717 @x1100 @x1082 @x977 @x1505 @x1079 (|unit-resolution| @x1075 @x1700 $x916) @x1518 @x1639 @x1336 @x1501 @x1653 $x1508)))
-(let ((@x1725 (|unit-resolution| @x894 (|unit-resolution| @x896 (|unit-resolution| @x1559 @x1722 $x1368) $x782) $x890)))
-(let ((@x1727 ((_ |th-lemma| arith farkas -1 -1 -2 -1 1 1 -1 1 -1 -1 1 1 -1 1) @x1505 @x1717 (|unit-resolution| @x896 (|unit-resolution| @x1559 @x1722 $x1368) $x782) (|unit-resolution| @x1075 @x1700 $x916) @x1079 @x1501 @x1518 @x1336 @x1082 @x1653 @x977 @x1639 @x1100 (|unit-resolution| @x1685 @x1725 $x1628) false)))
-(let ((@x1728 (lemma @x1727 $x642)))
-(let ((@x1785 (|unit-resolution| @x1038 (|unit-resolution| @x849 @x1728 $x845) $x1023)))
-(let (($x1946 (>= (+ ?x273 ?x738) 0)))
-(let (($x873 (= ?x273 ?x729)))
-(let (($x874 (not $x726)))
-(let ((@x1948 (hypothesis $x874)))
-(let ((@x878 (|def-axiom| (or $x726 $x873))))
-(let ((@x1959 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x873) $x1946)) (|unit-resolution| @x878 @x1948 $x873) $x1946)))
-(let (($x1122 (<= (+ ?x273 ?x738) 0)))
-(let ((@x1882 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x873) $x1122)) (hypothesis $x873) (hypothesis (not $x1122)) false)))
-(let ((@x1883 (lemma @x1882 (or (not $x873) $x1122))))
-(let ((@x1950 (|unit-resolution| @x1883 (|unit-resolution| @x878 @x1948 $x873) $x1122)))
-(let (($x1879 (not $x873)))
-(let (($x1876 (not $x1122)))
-(let ((@x1764 (|unit-resolution| @x1041 (|unit-resolution| @x849 @x1728 $x845) $x1022)))
-(let ((@x1606 (lemma ((_ |th-lemma| arith farkas 1 1 1 1 1) @x1434 @x1046 @x1010 @x1092 @x1436 false) (or $x614 $x847 $x670))))
-(let ((@x1767 (|unit-resolution| @x940 (|unit-resolution| @x840 (|unit-resolution| @x1606 @x1092 @x1728 $x614) $x836) $x925)))
-(let ((@x1770 (|unit-resolution| (|unit-resolution| @x1050 @x1046 @x934 (or $x670 (not $x1022) $x586 $x1031)) @x1767 @x1764 @x1092 $x586)))
-(let ((@x1772 (|unit-resolution| @x1517 (|unit-resolution| @x831 @x1770 $x827) $x919)))
-(let ((@x1773 (|unit-resolution| @x1075 (|unit-resolution| @x840 (|unit-resolution| @x1606 @x1092 @x1728 $x614) $x836) $x916)))
-(let ((@x1612 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x1026 $x865 $x1339)) (|unit-resolution| @x869 (|unit-resolution| @x1156 @x1153 $x1070) $x698) @x1153 $x1339)))
-(let ((@x1613 (|unit-resolution| @x867 (|unit-resolution| @x869 (|unit-resolution| @x1156 @x1153 $x1070) $x698) $x863)))
-(let ((@x1733 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 1 -1 1 -1) (or $x1149 $x1338 $x726 $x1119 $x990 $x847)) @x1082 (lemma (|unit-resolution| @x1112 @x1613 @x1612 false) $x1026) @x945 (or $x726 $x1119 $x847))))
-(let ((@x1736 (|unit-resolution| @x1376 (|unit-resolution| @x876 (|unit-resolution| @x1733 @x1382 @x1728 $x726) $x872) $x910)))
-(let ((@x1738 ((_ |th-lemma| arith assign-bounds 1 2 2 2 2 2) (or $x1119 $x1204 $x1445 $x1339 $x1446 $x754 $x1338))))
-(let ((@x1742 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x1087 $x917)) (|unit-resolution| @x1738 @x1617 @x1374 @x1082 @x1382 @x1359 @x1736 $x1339) $x917)))
-(let ((@x1746 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1) (or $x954 $x698 $x1149)) (lemma (|unit-resolution| @x1112 @x1613 @x1612 false) $x1026) (or $x954 $x698))))
-(let ((@x1747 (|unit-resolution| @x1746 @x1742 (|unit-resolution| @x1627 @x1617 @x1092 $x865) false)))
-(let ((@x1756 (|unit-resolution| @x885 (|unit-resolution| (lemma @x1747 (or $x754 $x670)) @x1092 $x754) $x881)))
-(let ((@x1757 (|unit-resolution| @x1398 @x1756 $x907)))
-(let ((@x1755 (|unit-resolution| @x1484 (|unit-resolution| (lemma @x1747 (or $x754 $x670)) @x1092 $x754) $x905)))
-(let (($x823 (= ?x86 ?x561)))
-(let (($x1793 (not $x823)))
-(let (($x1753 (>= (+ ?x86 ?x570) 0)))
-(let (($x1805 (not $x1753)))
-(let ((@x1819 (|unit-resolution| @x1376 (|unit-resolution| @x876 (|unit-resolution| @x1733 @x1114 @x1728 $x726) $x872) $x910)))
-(let (($x1047 (not $x1022)))
-(let (($x991 (not $x844)))
-(let (($x1806 (or $x900 $x1805 $x1031 $x991 $x1062 $x1118 $x1669 $x1047 $x1048 $x1388 $x1438 $x990 $x1445 $x1446 $x1119)))
-(let ((@x1820 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -2 2 1 -1 -1 -1 1 -1 1 -1 -1 1 1) $x1806) @x1567 @x934 @x1046 @x945 @x1374 @x1385 @x967 @x1386 @x1115 @x1764 @x1116 @x1114 @x1819 @x1545 $x1805)))
-(let ((@x1815 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1793 $x1753)) (hypothesis $x823) (hypothesis $x1805) false)))
-(let ((@x824 (|def-axiom| (or $x558 $x823))))
-(let ((@x1822 (|unit-resolution| @x824 (|unit-resolution| (lemma @x1815 (or $x1793 $x1753)) @x1820 $x1793) $x558)))
-(let ((@x1825 ((_ |th-lemma| arith farkas -1/2 1/2 -1/2 1/2 -1/2 1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 1) @x945 @x1114 @x1386 @x1385 @x1819 @x1374 (|unit-resolution| @x1547 (|unit-resolution| @x812 @x1822 $x822) $x1486) @x1545 @x1567 @x1764 @x1046 @x1501 @x1498 @x1728 false)))
-(let ((@x1840 (|unit-resolution| (lemma @x1825 (or $x900 $x1119 $x1388 $x1509 $x1031 $x1118)) @x1382 @x1757 @x1772 @x1767 (|unit-resolution| @x972 (|unit-resolution| @x831 @x1770 $x827) $x928) $x900)))
-(let ((@x1784 (|unit-resolution| @x1364 (|unit-resolution| @x876 (|unit-resolution| @x1733 @x1382 @x1728 $x726) $x872) $x914)))
-(let ((@x1786 (|unit-resolution| @x1393 @x1756 $x908)))
-(let (($x1752 (<= (+ ?x86 ?x570) 0)))
-(let (($x1797 (not $x1752)))
-(let (($x1353 (not $x1027)))
-(let (($x1798 (or $x901 $x1797 $x1150 $x1719 $x1668 $x1509 $x1663 $x1064 $x1065 $x980 $x1061 $x1205 $x1107 $x1671 $x1353)))
-(let ((@x1832 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -2 2 1 -1 -1 -1 1 -1 1 -1 -1 1 1) $x1798) (hypothesis $x1551) @x1079 @x1059 @x1100 @x1104 @x977 @x1501 @x978 @x1785 @x1105 @x1497 @x1147 @x1498 @x1533 $x1797)))
-(let ((@x1829 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1793 $x1752)) (hypothesis $x823) (hypothesis $x1797) false)))
-(let ((@x1834 (|unit-resolution| @x824 (|unit-resolution| (lemma @x1829 (or $x1793 $x1752)) @x1832 $x1793) $x558)))
-(let ((@x1837 ((_ |th-lemma| arith farkas 1/2 -1/2 1 -1 -1/2 1/2 1/2 -1/2 1/2 -1/2 -1/2 1/2 -1/2 1/2 -1/2 1) @x1100 @x1497 @x1147 @x1079 @x1501 @x1498 @x978 @x977 @x1105 @x1104 (|unit-resolution| @x1540 (|unit-resolution| @x812 @x1834 $x822) $x1485) @x1533 (hypothesis $x1551) @x1785 @x1059 @x1834 false)))
-(let ((@x1841 (|unit-resolution| (lemma @x1837 (or $x901 $x1353 $x1150 $x1509 $x980 $x1107)) @x1097 @x1773 @x1772 @x1786 @x1784 $x901)))
-(let ((@x1844 (|unit-resolution| @x1526 (|unit-resolution| @x807 (|unit-resolution| @x1553 @x1841 @x1840 $x70) $x808) @x1755 $x1013)))
-(let ((@x1760 (|unit-resolution| (|unit-resolution| @x1448 @x1385 @x1374 (or $x698 $x782 $x1445 $x1388)) @x1274 @x1736 @x1757 $x782)))
-(let (($x1750 (>= (+ ?x242 ?x710) 0)))
-(let ((@x1777 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1070 $x1750)) (|unit-resolution| @x869 @x1274 $x864) $x1750)))
-(let (($x1779 (not $x1628)))
-(let (($x1778 (not $x1750)))
-(let (($x1780 (or $x904 $x1778 $x1779 $x1718 $x989 $x1150 $x1719 $x1668 $x1509 $x1388 $x1438 $x1205 $x1353)))
-(let ((@x1781 ((_ |th-lemma| arith assign-bounds 1 -1 1 -1 1 -1 -1 1 -1 1 1 -1) $x1780)))
-(let ((@x1782 (|unit-resolution| @x1781 @x1777 @x1100 @x950 @x1385 @x1505 @x1501 @x1757 @x1097 @x1773 @x1772 @x1079 (|unit-resolution| @x1685 (|unit-resolution| @x894 @x1760 $x890) $x1628) $x904)))
-(let (($x810 (not $x558)))
-(let ((@x1790 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1 1 1) (or $x810 $x1509 $x1668 $x1719 $x1150 $x698 $x1205 $x670 $x1353)) @x1079 @x1100 @x1501 (or $x810 $x1509 $x1150 $x698 $x670 $x1353))))
-(let ((@x1792 (|unit-resolution| @x824 (|unit-resolution| @x1790 @x1274 @x1092 @x1097 @x1773 @x1772 $x810) $x823)))
-(let ((@x1800 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -2 2 1 -1 -1 -1 1 -1 1 -1 -1 1 1) $x1798) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1793 $x1752)) @x1792 $x1752) @x1079 @x1059 @x1100 @x1104 @x977 @x1533 @x1786 @x1785 @x1784 @x1097 @x1773 @x1772 @x1501 $x901)))
-(let ((@x1808 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -2 2 1 -1 -1 -1 1 -1 1 -1 -1 1 1) $x1806) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1793 $x1753)) @x1792 $x1753) @x934 @x1046 @x945 @x1374 @x1385 @x1545 @x1757 @x1767 @x1764 (|unit-resolution| @x972 (|unit-resolution| @x831 @x1770 $x827) $x928) @x1382 @x1736 @x967 $x900)))
-(let ((@x1810 (|unit-resolution| @x807 (|unit-resolution| @x1553 @x1808 @x1800 $x70) (|unit-resolution| @x1526 @x1782 @x1755 $x71) false)))
-(let ((@x1846 (|unit-resolution| @x867 (|unit-resolution| (lemma @x1810 (or $x698 $x670)) @x1092 $x698) $x863)))
-(let ((@x1848 (|unit-resolution| @x1511 @x1844 @x1784 @x1772 @x1786 @x1773 @x1097 (|unit-resolution| @x1173 @x1846 $x917) $x1508)))
-(let ((@x1851 (|unit-resolution| @x894 (|unit-resolution| @x896 (|unit-resolution| @x1559 @x1848 $x1368) $x782) $x890)))
-(let ((@x1855 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -2 2 -2 2 -1 -2) (or $x1750 $x980 $x1061 $x1107 $x1671 $x954 $x892)) (|unit-resolution| @x896 (|unit-resolution| @x1559 @x1848 $x1368) $x782) @x977 @x1786 (|unit-resolution| @x1173 @x1846 $x917) @x1784 @x1104 $x1750)))
-(let ((@x1856 (|unit-resolution| @x1781 @x1855 (|unit-resolution| @x1685 @x1851 $x1628) @x1100 @x950 @x1385 @x1505 @x1844 @x1757 @x1097 @x1773 @x1772 @x1079 @x1501 false)))
-(let ((@x1857 (lemma @x1856 $x670)))
-(let ((@x1884 ((_ |th-lemma| arith assign-bounds -1 -1 1 1 -1) (or $x1876 $x1446 $x1778 $x989 $x754 $x856))))
-(let ((@x1886 (|unit-resolution| @x1883 (|unit-resolution| @x1884 @x1777 @x1374 @x1617 @x1857 @x950 $x1876) $x1879)))
-(let ((@x1889 (|unit-resolution| @x1376 (|unit-resolution| @x876 (|unit-resolution| @x878 @x1886 $x726) $x872) $x910)))
-(let ((@x1890 ((_ |th-lemma| arith farkas 1 1 1 1 1) @x1617 @x1889 @x1374 @x1274 (|unit-resolution| @x878 @x1886 $x726) false)))
-(let ((@x1135 (|unit-resolution| @x867 (|unit-resolution| (lemma @x1890 (or $x698 $x754)) @x1617 $x698) $x863)))
-(let ((@x1895 (|unit-resolution| @x1484 @x958 $x883)))
-(let ((@x1897 (|unit-resolution| @x867 (|unit-resolution| (lemma @x1890 (or $x698 $x754)) @x1895 $x698) $x863)))
-(let ((@x1919 (|unit-resolution| @x1197 (|unit-resolution| @x858 @x1857 $x854) $x1183)))
-(let ((@x1894 (hypothesis $x1122)))
-(let ((@x1864 (|unit-resolution| @x1055 (|unit-resolution| @x858 @x1857 $x854) $x920)))
-(let ((@x1898 (|unit-resolution| @x1173 @x1897 $x917)))
-(let ((@x1903 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1 1 1) (or $x782 $x1438 $x1670 $x754 $x954 $x953 $x847 $x990 $x989))))
-(let ((@x1904 (|unit-resolution| @x1903 @x1895 @x950 @x945 @x1385 @x1728 @x1864 @x1898 (|unit-resolution| @x1649 (|unit-resolution| @x887 @x1895 $x882) $x1607) $x782)))
-(let ((@x1907 ((_ |th-lemma| arith assign-bounds -1 1 1 -1 -1 1 -1 -1 -3 3 1 1 2 -2 -2 2) (|unit-resolution| @x1415 (|unit-resolution| @x894 @x1904 $x890) $x911) @x962 @x958 @x934 @x967 @x977 (|unit-resolution| @x1652 (|unit-resolution| @x887 @x1895 $x882) $x1616) @x1898 @x1864 @x945 @x950 @x1629 @x1894 @x1374 @x1785 @x1059 $x1118)))
-(let ((@x1909 ((_ |th-lemma| arith assign-bounds 1 1 1 2 2 1 1 1 1 1 1) (or $x586 $x991 $x992 $x954 $x953 $x990 $x989 $x1876 $x1446 $x754 $x1064 $x1065))))
-(let ((@x1910 (|unit-resolution| @x1909 @x1894 @x1059 @x945 @x950 @x1374 @x1895 @x1864 @x1898 @x1629 @x1785 @x934 $x586)))
-(let ((@x1914 (lemma (|unit-resolution| @x972 (|unit-resolution| @x831 @x1910 $x827) @x1907 false) (or $x1876 $x905 $x992))))
-(let ((@x1916 (|unit-resolution| @x878 (|unit-resolution| @x1883 (|unit-resolution| @x1914 @x1188 @x958 $x1876) $x1879) $x726)))
-(let ((@x1922 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1 1 1) (or $x586 $x954 $x874 $x989 $x953 $x990 $x991 $x992 $x614)) @x934 @x945 @x950 (or $x586 $x954 $x874 $x953 $x992 $x614))))
-(let ((@x1924 (|unit-resolution| @x831 (|unit-resolution| @x1922 @x1916 @x1898 @x1188 @x1864 @x1010 $x586) $x827)))
-(let ((@x1928 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -2 -2 -2 2 2) (or $x1271 $x1064 $x874 $x954 $x953 $x990 $x989)) @x1916 @x950 @x1864 @x1898 @x1785 @x945 $x1271)))
-(let ((@x1929 (|unit-resolution| @x1698 @x1928 (|unit-resolution| @x972 @x1924 $x928) @x958 (|unit-resolution| @x1649 (|unit-resolution| @x887 @x1895 $x882) $x1607) @x1898 @x1864 @x1188 (|unit-resolution| @x1652 (|unit-resolution| @x887 @x1895 $x882) $x1616) (|unit-resolution| @x1112 @x1897 $x1087) @x1919 (|unit-resolution| @x1376 (|unit-resolution| @x876 @x1916 $x872) $x910) @x1191 false)))
-(let ((@x1935 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -2 2 -2 -2 2) (or $x1750 $x954 $x953 $x990 $x838 $x1064 $x1065)) @x1898 @x945 @x1864 @x1059 @x1785 (|unit-resolution| (lemma @x1929 (or $x614 $x905)) @x958 $x614) $x1750)))
-(let ((@x1937 (|unit-resolution| @x1883 (|unit-resolution| @x1884 @x1935 @x1374 @x1895 @x1857 @x950 $x1876) $x1879)))
-(let ((@x1940 (|unit-resolution| @x1376 (|unit-resolution| @x876 (|unit-resolution| @x878 @x1937 $x726) $x872) $x910)))
-(let ((@x1943 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -3 -2 -2 2 2 -2 -2 2) (or $x1086 $x953 $x874 $x954 $x989 $x990 $x838 $x1064 $x1065)) (|unit-resolution| @x878 @x1937 $x726) @x945 @x950 @x1059 @x1864 @x1898 @x1785 (|unit-resolution| (lemma @x1929 (or $x614 $x905)) @x958 $x614) $x1086)))
-(let ((@x1944 (|unit-resolution| @x1738 @x1943 @x1940 @x1374 @x1082 @x1895 @x1919 (|unit-resolution| @x1112 @x1897 $x1087) false)))
-(let ((@x1945 (lemma @x1944 $x905)))
-(let ((@x1859 (|unit-resolution| @x1649 (|unit-resolution| @x887 @x1617 $x882) $x1607)))
-(let ((@x1988 (|unit-resolution| (|unit-resolution| @x1207 @x1100 @x1046 (or $x698 $x1204 $x614 $x1047)) @x1010 @x1919 @x1764 $x698)))
-(let ((@x1990 (|unit-resolution| @x1173 (|unit-resolution| @x867 @x1988 $x863) $x917)))
-(let ((@x1947 (hypothesis $x1179)))
-(let ((@x1951 (|unit-resolution| @x1909 @x1950 @x1059 @x945 @x950 @x1374 @x1617 @x1864 @x930 @x1629 @x1785 @x934 $x586)))
-(let ((@x1955 (|unit-resolution| @x894 (|unit-resolution| @x1903 @x1859 @x950 @x945 @x1385 @x1728 @x1864 @x930 @x1617 $x782) $x890)))
-(let ((@x1956 (|unit-resolution| @x1685 @x1955 $x1628)))
-(let ((@x1960 ((_ |th-lemma| arith assign-bounds 1 -1 -3/2 3/2 -1 1 -1/2 1/2 -1/2 -1/2 1/2 1/2 -1/2 -1/2 1/2 1/2) @x1959 @x1104 @x1919 @x1100 @x1764 @x1046 @x1956 @x1505 @x1079 @x1501 (|unit-resolution| @x1517 (|unit-resolution| @x831 @x1951 $x827) $x919) @x1385 @x1859 @x1455 @x1082 @x1947 $x904)))
-(let ((@x1965 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1 1 1 1 1 1) (or $x558 $x754 $x1779 $x1718 $x957 $x1438 $x1670 $x726)) @x1948 @x1617 @x1385 @x1505 @x1945 @x1859 @x1956 $x558)))
-(let (($x1970 (not $x1179)))
-(let (($x1971 (or $x901 $x1662 $x1663 $x1779 $x1718 $x957 $x1719 $x1970 $x1339 $x1204 $x1205 $x1338 $x1062 $x1118 $x1061 $x1633)))
-(let ((@x1973 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 1/2 -1/2 -1/2 1/2 -1/2 1/2 1/2 -1/2 -1/2 -1/2 1/2 1/2 -1/2) $x1971) (|unit-resolution| @x972 (|unit-resolution| @x831 @x1951 $x827) $x928) @x1079 @x1100 @x1082 @x977 @x1505 @x1533 @x1945 @x967 @x1919 @x1947 @x1455 (|unit-resolution| @x1652 (|unit-resolution| @x887 @x1617 $x882) $x1616) (|unit-resolution| @x1540 (|unit-resolution| @x812 @x1965 $x822) $x1485) @x1956 $x901)))
-(let (($x1063 (not $x897)))
-(let (($x1976 (or $x900 $x1570 $x1669 $x981 $x1063 $x1013 $x991 $x992 $x954 $x953 $x990 $x989 $x1668 $x1509 $x1438 $x1670)))
-(let ((@x1978 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 1/2 -1/2 -1/2 1/2 -1/2 1/2 1/2 -1/2 -1/2 -1/2 1/2 1/2 -1/2) $x1976) @x1960 @x934 @x945 @x950 @x1385 @x962 @x1545 @x1501 (|unit-resolution| @x1415 @x1955 $x911) @x1864 @x930 @x1629 (|unit-resolution| @x1517 (|unit-resolution| @x831 @x1951 $x827) $x919) (|unit-resolution| @x1547 (|unit-resolution| @x812 @x1965 $x822) $x1486) @x1859 $x900)))
-(let ((@x1979 (|unit-resolution| @x1553 @x1978 @x1973 (|unit-resolution| @x807 (|unit-resolution| @x1526 @x1960 @x1945 $x71) $x820) false)))
-(let ((@x1992 (|unit-resolution| (lemma @x1979 (or $x726 $x954 $x992 $x1970 $x1339 $x754)) @x1617 @x1188 @x1213 (|unit-resolution| @x1112 (|unit-resolution| @x867 @x1988 $x863) $x1087) @x1990 $x726)))
-(let ((@x1994 (|unit-resolution| @x831 (|unit-resolution| @x1922 @x1992 @x1010 @x1188 @x1864 @x1990 $x586) $x827)))
-(let ((@x1997 (|unit-resolution| @x894 (|unit-resolution| @x1903 @x1859 @x950 @x945 @x1385 @x1728 @x1864 @x1990 @x1617 $x782) $x890)))
-(let ((@x1998 (|unit-resolution| @x1685 @x1997 $x1628)))
-(let ((@x1982 (hypothesis $x1628)))
-(let ((@x1983 ((_ |th-lemma| arith farkas 3/4 1/4 -1/4 -3/4 1/2 -1/2 -1/2 1/2 -1/4 1/4 1/4 -1/4 -1/4 1/4 1/4 -1/4 1/4 1) @x930 @x1864 @x945 @x950 @x1105 @x1104 @x1764 @x1046 @x1982 @x1505 @x1502 @x1079 @x1501 @x1498 @x1385 (hypothesis $x1607) @x1947 @x1728 false)))
-(let ((@x2001 (|unit-resolution| (lemma @x1983 (or $x904 $x954 $x1107 $x1779 $x1509 $x1670 $x1970)) (|unit-resolution| @x1364 (|unit-resolution| @x876 @x1992 $x872) $x914) @x1990 @x1998 (|unit-resolution| @x1517 @x1994 $x919) @x1859 @x1213 $x904)))
-(let ((@x2006 ((_ |th-lemma| arith assign-bounds 2 3/4 3/4 3/4 3/4 3/4 1/2 1/2 3/4 3/4 1/2 1/2 1/4 1/4 1/4 1/4 1/4 1/4) @x1617 @x1998 @x1505 @x1945 @x1385 @x1859 (|unit-resolution| @x1376 (|unit-resolution| @x876 @x1992 $x872) $x910) @x1374 @x1864 @x945 @x1785 @x1059 @x934 @x967 (|unit-resolution| @x972 @x1994 $x928) @x1990 @x950 @x1188 $x558)))
-(let ((@x2009 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 1/2 -1/2 -1/2 1/2 -1/2 1/2 1/2 -1/2 -1/2 -1/2 1/2 1/2 -1/2) $x1971) (|unit-resolution| @x1540 (|unit-resolution| @x812 @x2006 $x822) $x1485) @x1079 @x1100 @x1082 @x977 @x1505 @x1533 @x1945 @x967 @x1919 @x1213 (|unit-resolution| @x1112 (|unit-resolution| @x867 @x1988 $x863) $x1087) (|unit-resolution| @x1652 (|unit-resolution| @x887 @x1617 $x882) $x1616) (|unit-resolution| @x972 @x1994 $x928) @x1998 $x901)))
-(let ((@x2014 (|unit-resolution| @x1673 (|unit-resolution| @x1547 (|unit-resolution| @x812 @x2006 $x822) $x1486) @x1046 @x945 @x950 @x1104 @x1385 @x1864 @x1859 @x1990 (|unit-resolution| @x1364 (|unit-resolution| @x876 @x1992 $x872) $x914) (|unit-resolution| @x1517 @x1994 $x919) (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x1180 $x847 $x1047)) @x1764 @x1728 $x1180) @x1501 @x1545 $x900)))
-(let ((@x2015 (|unit-resolution| @x1553 @x2014 @x2009 (|unit-resolution| @x807 (|unit-resolution| @x1526 @x2001 @x1945 $x71) $x820) false)))
-(let ((@x1138 (|unit-resolution| (lemma @x2015 (or $x754 $x614)) @x1617 $x614)))
-(let ((@x1030 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -2 2 -2 -2 2 -1) (or $x1179 $x1064 $x1065 $x953 $x865 $x990 $x1150)) @x945 @x1059 (or $x1179 $x1064 $x953 $x865 $x1150))))
-(let ((@x1042 (|unit-resolution| (|unit-resolution| @x1030 @x1785 @x1864 (or $x1179 $x865 $x1150)) (|unit-resolution| @x1075 (|unit-resolution| @x840 @x1138 $x836) $x916) (|unit-resolution| (lemma @x1890 (or $x698 $x754)) @x1617 $x698) $x1179)))
-(let ((@x1052 (|unit-resolution| (lemma @x952 (or $x586 $x874 $x953 $x838 $x954)) @x1864 (or $x586 $x874 $x838 $x954))))
-(let ((@x1068 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x922 $x838 $x1031)) (|unit-resolution| @x940 (|unit-resolution| @x840 @x1138 $x836) $x925) @x1138 $x922)))
-(let ((@x1069 (|unit-resolution| (lemma @x1979 (or $x726 $x954 $x992 $x1970 $x1339 $x754)) @x1068 (|unit-resolution| @x1052 (|unit-resolution| @x1173 @x1135 $x917) @x935 @x1138 $x874) @x1617 @x1042 (|unit-resolution| @x1112 @x1135 $x1087) (|unit-resolution| @x1173 @x1135 $x917) false)))
-(let ((@x1165 (|unit-resolution| (lemma @x1069 (or $x754 $x586)) @x935 $x754)))
-(let ((@x969 (|unit-resolution| @x1398 (|unit-resolution| @x885 @x1165 $x881) $x907)))
-(let ((@x2054 (|unit-resolution| (|unit-resolution| @x1440 @x1385 (or $x726 $x782 $x1388 $x883)) @x1948 @x1165 @x969 $x782)))
-(let ((@x1085 (|unit-resolution| (|unit-resolution| @x1207 @x1100 @x1046 (or $x698 $x1204 $x614 $x1047)) @x1919 @x1764 (or $x698 $x614))))
-(let ((@x1157 (|unit-resolution| @x867 (|unit-resolution| @x1085 @x1010 $x698) $x863)))
-(let ((@x1167 (|unit-resolution| @x1393 (|unit-resolution| @x885 @x1165 $x881) $x908)))
-(let ((@x1163 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1) (or $x558 $x586 $x1060 $x1062 $x614)) @x967 (or $x558 $x586 $x1060 $x614))))
-(let ((@x1170 (|unit-resolution| @x1540 (|unit-resolution| @x812 (|unit-resolution| @x1163 @x1010 @x935 @x1009 $x558) $x822) $x1485)))
-(let ((@x1171 ((_ |th-lemma| arith assign-bounds 1 -1 1 -1 1 -1 1 3 -3 1 -1 -1 2 -2 2 -2) @x1170 @x1533 @x1009 @x967 @x977 (hypothesis $x1946) @x1104 @x1919 @x1100 @x1764 @x1046 @x1167 @x1079 @x1213 (|unit-resolution| @x1112 @x1157 $x1087) @x1082 $x901)))
-(let (($x1133 (>= (+ ?x118 ?x598) 0)))
-(let ((@x982 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x828) $x1133)) @x1005 $x1133)))
-(let ((@x983 (|unit-resolution| @x1547 (|unit-resolution| @x812 (|unit-resolution| @x1163 @x1010 @x935 @x1009 $x558) $x822) $x1486)))
-(let ((@x929 ((_ |th-lemma| arith assign-bounds 1 -1 1 -1 1 -1 1 3 -3 1 -1 -1 2 -2 2 -2) @x983 @x1545 @x982 @x1501 @x1385 @x1894 @x1374 @x1864 @x945 @x1785 @x1059 @x969 @x934 @x1188 (|unit-resolution| @x1173 @x1157 $x917) @x950 $x900)))
-(let (($x988 (not $x1133)))
-(let (($x995 (or $x904 $x988 $x1779 $x1718 $x1668 $x1438 $x953 $x990 $x991 $x992 $x954 $x989 $x1388)))
-(let ((@x997 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 1 -1 1 1 -1 1 -1 1 -1 -1) $x995) (|unit-resolution| @x1173 @x1157 $x917) @x945 @x950 @x1385 @x1505 @x1501 @x969 @x1864 @x934 @x1188 @x1982 @x982 $x904)))
-(let ((@x1002 (|unit-resolution| @x1526 @x1945 (or $x71 $x1013))))
-(let ((@x1164 (|unit-resolution| @x807 (|unit-resolution| @x1002 @x997 $x71) (|unit-resolution| @x1553 @x929 @x1171 $x70) false)))
-(let ((@x2057 (|unit-resolution| (lemma @x1164 (or $x614 $x1779 $x1876 (not $x1946) $x586)) (|unit-resolution| @x1685 (|unit-resolution| @x894 @x2054 $x890) $x1628) @x1950 @x1959 @x935 $x614)))
-(let ((@x2027 (hypothesis $x1133)))
-(let (($x2029 (or $x904 $x1778 $x988 $x1779 $x1718 $x1668 $x1438 $x1204 $x1205 $x991 $x989 $x1388 $x1031 $x1047 $x1048)))
-(let ((@x2031 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 -1 1 -1 1 -1 1 1 -1 -1 -1 -2 2) $x2029) (hypothesis $x1750) @x1046 @x1100 @x950 @x1385 @x1505 @x1501 @x1386 @x1115 @x1764 @x1919 @x934 @x1982 @x2027 $x904)))
-(let ((@x2036 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1) (or $x558 $x726 $x1779 $x1718 $x957 $x1438 $x1388)) @x1948 @x1385 @x1505 @x1945 @x1386 @x1982 $x558)))
-(let (($x1174 (not $x1946)))
-(let (($x2039 (or $x901 $x1662 $x1663 $x988 $x1668 $x1438 $x1174 $x1671 $x1204 $x1205 $x1047 $x1048 $x1388 $x1779 $x1718 $x957)))
-(let ((@x2041 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 -1 -1 1 1 -1 1 -1 1 2 -2 -2) $x2039) (|unit-resolution| @x1540 (|unit-resolution| @x812 @x2036 $x822) $x1485) @x1046 @x1100 @x1104 @x1385 @x1505 @x1533 @x1945 @x1386 @x1764 @x1919 @x1501 @x1982 @x2027 @x1959 $x901)))
-(let (($x2043 (or $x900 $x1570 $x1669 $x1060 $x1062 $x1061 $x1876 $x1446 $x953 $x990 $x1064 $x1065 $x980 $x981 $x1063 $x1013)))
-(let ((@x2045 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 -1 -1 1 1 -1 1 -1 1 2 -2 -2) $x2043) @x2031 @x1059 @x945 @x1374 @x977 @x962 @x1545 @x967 @x978 @x963 @x1864 @x1181 @x1785 @x1950 (|unit-resolution| @x1547 (|unit-resolution| @x812 @x2036 $x822) $x1486) $x900)))
-(let ((@x2046 (|unit-resolution| @x1553 @x2045 @x2041 (|unit-resolution| @x807 (|unit-resolution| @x1002 @x2031 $x71) $x820) false)))
-(let ((@x2061 (|unit-resolution| (lemma @x2046 (or $x1778 $x980 $x981 $x1060 $x1388 $x1779 $x988 $x1031 $x726)) (|unit-resolution| @x1415 (|unit-resolution| @x894 @x2054 $x890) $x911) @x1167 @x1009 @x969 (|unit-resolution| @x1685 (|unit-resolution| @x894 @x2054 $x890) $x1628) @x982 (|unit-resolution| @x940 (|unit-resolution| @x840 @x2057 $x836) $x925) @x1948 $x1778)))
-(let ((@x2063 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -2 2 -2 -2 2) (or $x1750 $x954 $x953 $x990 $x838 $x1064 $x1065)) @x945 @x1864 @x1059 @x1785 (or $x1750 $x954 $x838))))
-(let ((@x2050 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1070 $x1750)) (hypothesis $x864) (hypothesis $x1778) false)))
-(let ((@x2051 (lemma @x2050 (or $x1070 $x1750))))
-(let ((@x2067 (|unit-resolution| @x867 (|unit-resolution| @x869 (|unit-resolution| @x2051 @x2061 $x1070) $x698) $x863)))
-(let ((@x2068 (|unit-resolution| @x1173 @x2067 (|unit-resolution| @x2063 @x2061 @x2057 $x954) false)))
-(let ((@x2108 (|unit-resolution| (lemma @x2068 (or $x726 $x586)) @x935 $x726)))
-(let ((@x2074 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 -1 -1 -1 1 1 -1) (or $x1107 $x954 $x847 $x989 $x1671 $x1047 $x1048 $x883 $x614)) @x1046 @x950 @x1104 @x1728 @x1764 (or $x1107 $x954 $x883 $x614))))
-(let ((@x2076 (|unit-resolution| @x1173 @x1157 (|unit-resolution| @x2074 @x1010 @x1325 @x1105 $x954) false)))
-(let ((@x2111 (|unit-resolution| (lemma @x2076 (or $x614 $x883 $x1107)) @x1165 (|unit-resolution| @x1364 (|unit-resolution| @x876 @x2108 $x872) $x914) $x614)))
-(let ((@x2115 (|unit-resolution| @x1376 (|unit-resolution| @x876 @x2108 $x872) $x910)))
-(let ((@x1866 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1 -1 1 1 -1 1 1 -1) (or $x953 $x990 $x782 $x1388 $x1438 $x1064 $x1445 $x1446 $x838 $x1065)) @x945 @x1374 @x1385 @x1059 (or $x953 $x782 $x1388 $x1064 $x1445 $x838))))
-(let ((@x2118 (|unit-resolution| (|unit-resolution| @x1866 @x1785 @x1864 (or $x782 $x1388 $x1445 $x838)) @x2111 @x969 @x2115 $x782)))
-(let ((@x2083 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 -1 -1 1 1 -1 1 -1 1 2 -2 -2) $x2043) @x1567 @x1059 @x945 @x1374 @x977 @x962 @x1545 @x967 @x978 @x963 @x1864 @x1181 @x1785 @x1894 @x1011 $x1570)))
-(let ((@x2080 ((_ |th-lemma| arith farkas 1 -1 -1 1 -1 1 1 1 -1 1 -1 -1 1) @x1385 @x1386 @x1545 @x1567 @x1181 @x967 @x1374 @x1864 @x945 @x1785 @x1059 @x1460 (hypothesis $x1753) false)))
-(let ((@x2084 (|unit-resolution| (lemma @x2080 (or $x1805 $x1388 $x900 $x1060 $x1445)) @x1567 @x1386 @x1181 @x1460 $x1805)))
-(let ((@x2086 (|unit-resolution| @x824 (|unit-resolution| (lemma @x1815 (or $x1793 $x1753)) @x2084 $x1793) $x558)))
-(let ((@x2090 (lemma (|unit-resolution| @x1547 (|unit-resolution| @x812 @x2086 $x822) @x2083 false) (or $x900 $x1388 $x1060 $x1445 $x980 $x981 $x1876 $x1013))))
-(let ((@x2094 (|unit-resolution| @x1553 (|unit-resolution| @x2090 @x1011 @x1181 @x1460 @x978 @x963 @x1894 @x1386 $x900) (|unit-resolution| @x807 (|unit-resolution| @x1002 @x1011 $x71) $x820) $x1551)))
-(let (($x2095 (or $x1797 $x1061 $x980 $x1663 $x901 $x988 $x1668 $x1671 $x1204 $x1205 $x1047 $x1048 $x1107)))
-(let ((@x2097 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 -1 1 1 1 -1 1 -1 -1) $x2095) @x2094 @x1046 @x1100 @x1104 @x977 @x1501 @x978 @x1764 @x1105 @x1919 @x1533 @x2027 $x1797)))
-(let ((@x2099 (|unit-resolution| @x824 (|unit-resolution| (lemma @x1829 (or $x1793 $x1752)) @x2097 $x1793) $x558)))
-(let ((@x2104 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -2 -2 2 2 2 -2) (or $x1946 $x1107 $x810 $x981 $x1063 $x1013 $x1061 $x980)) @x1011 @x962 @x977 @x978 @x963 @x1105 @x2099 $x1946)))
-(let ((@x2105 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 -1 -1 1 1 -1 1 -1 1 2 -2 -2) $x2039) @x2104 (|unit-resolution| @x1540 (|unit-resolution| @x812 @x2099 $x822) $x1485) @x1046 @x1100 @x1104 @x1385 @x1505 @x1982 @x1945 @x1386 @x1764 @x1919 @x2094 @x1501 @x2027 @x1533 false)))
-(let ((@x2125 (|unit-resolution| (lemma @x2105 (or $x1013 $x1779 $x1388 $x988 $x980 $x981 $x1107 $x1060 $x1445 $x1876)) (|unit-resolution| @x1685 (|unit-resolution| @x894 @x2118 $x890) $x1628) @x969 @x982 @x1167 (|unit-resolution| @x1415 (|unit-resolution| @x894 @x2118 $x890) $x911) (|unit-resolution| @x1364 (|unit-resolution| @x876 @x2108 $x872) $x914) @x1009 @x2115 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -2) (or $x1122 $x1445 $x874)) @x2108 @x2115 $x1122) $x1013)))
-(let ((@x2126 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 -1 1 -1 1 -1 1 1 -1 -1 -1 -2 2) $x2029) @x2125 @x1046 @x1100 @x950 @x1385 @x1505 (|unit-resolution| @x1685 (|unit-resolution| @x894 @x2118 $x890) $x1628) @x969 (|unit-resolution| @x940 (|unit-resolution| @x840 @x2111 $x836) $x925) @x1764 @x1919 @x934 @x1501 @x982 $x1778)))
-(let ((@x2129 (|unit-resolution| @x867 (|unit-resolution| @x869 (|unit-resolution| @x2051 @x2126 $x1070) $x698) $x863)))
-(let ((@x2130 (|unit-resolution| @x1173 @x2129 (|unit-resolution| @x1052 @x2111 @x935 @x2108 $x954) false)))
-(let ((@x2131 (lemma @x2130 $x586)))
-(let ((@x2190 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 1 -1 1) (or $x925 $x856 $x1719 $x1064 $x1065 $x829)) @x1079 @x1059 @x1857 @x2131 @x1785 $x925)))
-(let ((@x2153 (|unit-resolution| (lemma @x2015 (or $x754 $x614)) @x1010 $x754)))
-(let ((@x2156 (|unit-resolution| (lemma @x1452 (or $x614 $x847 $x883 $x782)) @x1728 (or $x614 $x883 $x782))))
-(let ((@x2159 (|unit-resolution| @x1415 (|unit-resolution| @x894 (|unit-resolution| @x2156 @x1010 @x2153 $x782) $x890) $x911)))
-(let ((@x2162 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x910 $x914)) (|unit-resolution| (lemma @x2076 (or $x614 $x883 $x1107)) @x2153 @x1010 $x1107) $x910)))
-(let ((@x2163 (|unit-resolution| @x1685 (|unit-resolution| @x894 (|unit-resolution| @x2156 @x1010 @x2153 $x782) $x890) $x1628)))
-(let ((@x2133 (|unit-resolution| @x1517 (|unit-resolution| @x831 @x2131 $x827) $x919)))
-(let ((@x2134 ((_ |th-lemma| arith farkas -1 1 -1 1 -3/2 3/2 -1/2 1/2 1/2 -1/2 1/2 -1/2 1/2 1/2 -1/2 -1/2 1/2 1) @x1104 @x1325 @x1764 @x1046 @x1919 @x1100 @x1982 @x1505 @x1502 @x1501 @x1947 @x1079 @x2133 @x1385 @x1399 @x1455 @x1082 (hypothesis $x1946) false)))
-(let ((@x2137 (|unit-resolution| (lemma @x2134 (or $x904 $x883 $x1779 $x1970 $x1339 $x1174)) @x1959 @x1982 @x1947 @x1455 @x1325 $x904)))
-(let ((@x2019 (hypothesis $x1118)))
-(let ((@x2021 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x828) $x926)) @x1005 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x928 $x1060 $x586)) @x935 @x2019 $x1060) false)))
-(let ((@x2024 (|unit-resolution| @x831 (|unit-resolution| (lemma @x2021 (or $x586 $x928)) @x2019 $x586) $x827)))
-(let ((@x2143 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x926 $x829 $x1118)) (lemma (|unit-resolution| @x972 @x2024 @x2019 false) $x928) (or $x926 $x829))))
-(let ((@x2145 (|unit-resolution| @x2090 @x2137 (|unit-resolution| @x2143 @x2131 $x926) @x1460 @x1394 @x963 @x1950 @x1399 $x900)))
-(let ((@x2146 (|unit-resolution| @x1553 @x2145 (|unit-resolution| @x807 (|unit-resolution| @x1002 @x2137 $x71) $x820) $x1551)))
-(let ((@x2147 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1) (or $x558 $x726 $x1779 $x1718 $x957 $x1438 $x1388)) @x1948 @x1385 @x1505 @x1945 @x1399 @x1982 $x558)))
-(let ((@x2150 ((_ |th-lemma| arith farkas -1 -1 1 -2 2 -1 1 1 1 -1 -1 1 -1 1 -1 1) @x1104 @x1764 @x1046 @x1919 @x1100 @x1982 @x1505 @x1945 @x1947 @x1079 @x1455 @x1082 (|unit-resolution| @x1540 (|unit-resolution| @x812 @x2147 $x822) $x1485) @x1533 @x2146 @x1959 false)))
-(let ((@x2164 (|unit-resolution| (lemma @x2150 (or $x726 $x1779 $x1970 $x1339 $x1445 $x981 $x883)) @x2163 @x1213 (|unit-resolution| @x1112 @x1157 $x1087) @x2162 @x2159 @x2153 $x726)))
-(let ((@x2166 (|unit-resolution| @x1364 (|unit-resolution| @x876 @x2164 $x872) (|unit-resolution| (lemma @x2076 (or $x614 $x883 $x1107)) @x2153 @x1010 $x1107) false)))
-(let ((@x2167 (lemma @x2166 $x614)))
-(let ((@x2169 (|unit-resolution| @x1075 (|unit-resolution| @x840 @x2167 $x836) $x916)))
-(let ((@x2172 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -2 2 -2 -2 2) (or $x1086 $x953 $x1064 $x1065 $x829 $x1150 $x1719)) @x1079 @x1059 @x1864 @x1785 @x2131 @x2169 $x1086)))
-(let ((@x2176 (|unit-resolution| @x876 (|unit-resolution| (|unit-resolution| @x1733 @x1728 (or $x726 $x1119)) @x2172 $x726) $x872)))
-(let ((@x2177 (|unit-resolution| @x1376 @x2176 $x910)))
-(let ((@x2180 (|unit-resolution| (|unit-resolution| @x1738 @x1374 @x1082 @x1919 (or $x1119 $x1445 $x1339 $x754)) @x1617 @x2172 @x2177 $x1339)))
-(let ((@x2181 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -2) (or $x1122 $x1445 $x874)) @x2177 (|unit-resolution| (|unit-resolution| @x1733 @x1728 (or $x726 $x1119)) @x2172 $x726) $x1122)))
-(let ((@x2184 (|unit-resolution| (|unit-resolution| @x1884 @x1374 @x1857 @x950 (or $x1876 $x1778 $x754)) @x1617 @x2181 $x1778)))
-(let ((@x2186 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x1087 $x917)) (|unit-resolution| @x2063 @x2184 @x2167 $x954) @x2180 false)))
-(let ((@x2192 (|unit-resolution| @x1398 (|unit-resolution| @x885 (lemma @x2186 $x754) $x881) $x907)))
-(let ((@x2194 (|unit-resolution| (lemma @x1825 (or $x900 $x1119 $x1388 $x1509 $x1031 $x1118)) (lemma (|unit-resolution| @x972 @x2024 @x2019 false) $x928) (or $x900 $x1119 $x1388 $x1509 $x1031))))
-(let ((@x2197 (|unit-resolution| @x1393 (|unit-resolution| @x885 (lemma @x2186 $x754) $x881) $x908)))
-(let ((@x2198 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x1027 $x856 $x1204)) @x1919 @x1857 $x1027)))
-(let ((@x2200 (|unit-resolution| (lemma @x1837 (or $x901 $x1353 $x1150 $x1509 $x980 $x1107)) @x2198 (or $x901 $x1150 $x1509 $x980 $x1107))))
-(let ((@x2201 (|unit-resolution| @x2200 @x2197 @x2133 @x2169 (|unit-resolution| @x1364 @x2176 $x914) $x901)))
-(let ((@x2202 (|unit-resolution| @x1553 @x2201 (|unit-resolution| @x2194 @x2192 @x2133 @x2172 @x2190 $x900) $x70)))
-(let ((@x2205 (|unit-resolution| (|unit-resolution| @x1866 @x1785 @x1864 (or $x782 $x1388 $x1445 $x838)) @x2192 @x2167 @x2177 $x782)))
-(let ((@x2210 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x1496 $x892 $x1779)) (|unit-resolution| @x1685 (|unit-resolution| @x894 @x2205 $x890) $x1628) @x2205 $x1496)))
-(let ((@x2213 (|unit-resolution| (|unit-resolution| @x1511 @x2198 (or $x904 $x954 $x1508 $x1509 $x980 $x1150 $x1107)) @x2210 @x2133 (|unit-resolution| @x1364 @x2176 $x914) @x2197 @x2169 (|unit-resolution| @x1002 (|unit-resolution| @x807 @x2202 $x808) $x1013) $x954)))
-(let ((@x2215 (|unit-resolution| @x1781 @x1100 @x950 @x1385 @x1505 @x2198 @x1079 @x1501 (or $x904 $x1778 $x1779 $x1150 $x1509 $x1388))))
-(let ((@x2216 (|unit-resolution| @x2215 (|unit-resolution| @x1685 (|unit-resolution| @x894 @x2205 $x890) $x1628) @x2133 @x2169 @x2192 (|unit-resolution| @x1002 (|unit-resolution| @x807 @x2202 $x808) $x1013) $x1778)))
-(let ((@x2219 (|unit-resolution| @x867 (|unit-resolution| @x869 (|unit-resolution| @x2051 @x2216 $x1070) $x698) $x863)))
-(|unit-resolution| @x1173 @x2219 @x2213 false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
+(let (($x57 (< |x10$| 0)))
+(let ((?x236 (ite $x57 ?x233 |x10$|)))
+(let ((?x242 (+ ?x216 ?x236)))
+(let (($x247 (= |x11$| ?x242)))
+(let (($x51 (< |x9$| 0)))
+(let ((?x219 (ite $x51 ?x216 |x9$|)))
+(let ((?x225 (+ ?x199 ?x219)))
+(let (($x230 (= |x10$| ?x225)))
+(let (($x250 (and $x230 $x247)))
+(let (($x45 (< |x8$| 0)))
+(let ((?x202 (ite $x45 ?x199 |x8$|)))
+(let ((?x208 (+ ?x182 ?x202)))
+(let (($x213 (= |x9$| ?x208)))
+(let (($x253 (and $x213 $x250)))
+(let (($x39 (< |x7$| 0)))
+(let ((?x185 (ite $x39 ?x182 |x7$|)))
+(let ((?x191 (+ ?x165 ?x185)))
+(let (($x196 (= |x8$| ?x191)))
+(let (($x256 (and $x196 $x253)))
+(let (($x33 (< |x6$| 0)))
+(let ((?x168 (ite $x33 ?x165 |x6$|)))
+(let ((?x174 (+ ?x148 ?x168)))
+(let (($x179 (= |x7$| ?x174)))
+(let (($x259 (and $x179 $x256)))
+(let (($x27 (< |x5$| 0)))
+(let ((?x151 (ite $x27 ?x148 |x5$|)))
+(let ((?x157 (+ ?x131 ?x151)))
+(let (($x162 (= |x6$| ?x157)))
+(let (($x262 (and $x162 $x259)))
+(let (($x21 (< |x4$| 0)))
+(let ((?x134 (ite $x21 ?x131 |x4$|)))
+(let ((?x140 (+ ?x114 ?x134)))
+(let (($x145 (= |x5$| ?x140)))
+(let (($x265 (and $x145 $x262)))
+(let (($x15 (< |x3$| 0)))
+(let ((?x117 (ite $x15 ?x114 |x3$|)))
+(let ((?x123 (+ ?x96 ?x117)))
+(let (($x128 (= |x4$| ?x123)))
+(let (($x268 (and $x128 $x265)))
+(let (($x8 (< |x2$| 0)))
+(let ((?x99 (ite $x8 ?x96 |x2$|)))
+(let ((?x106 (+ (* (~ 1) |x1$|) ?x99)))
+(let (($x111 (= |x3$| ?x106)))
+(let (($x271 (and $x111 $x268)))
+(let (($x278 (or (not $x271) $x72)))
+(let (($x526 (and $x456 (and $x431 (and $x406 (and $x381 (and $x356 (and $x306 $x331))))))))
+(let (($x524 (= $x262 (and $x431 (and $x406 (and $x381 (and $x356 (and $x306 $x331))))))))
+(let ((@x317 (monotonicity (rewrite (= $x57 (not $x311))) (= ?x236 (ite (not $x311) ?x233 |x10$|)))))
+(let ((@x322 (trans @x317 (rewrite (= (ite (not $x311) ?x233 |x10$|) ?x318)) (= ?x236 ?x318))))
+(let ((@x328 (monotonicity (monotonicity @x322 (= ?x242 (+ ?x216 ?x318))) (= $x247 (= |x11$| (+ ?x216 ?x318))))))
+(let ((@x335 (trans @x328 (rewrite (= (= |x11$| (+ ?x216 ?x318)) $x331)) (= $x247 $x331))))
+(let ((@x292 (monotonicity (rewrite (= $x51 $x287)) (= ?x219 (ite $x287 ?x216 |x9$|)))))
+(let ((@x300 (monotonicity (trans @x292 (rewrite (= (ite $x287 ?x216 |x9$|) ?x293)) (= ?x219 ?x293)) (= ?x225 (+ ?x199 ?x293)))))
+(let ((@x310 (trans (monotonicity @x300 (= $x230 (= |x10$| (+ ?x199 ?x293)))) (rewrite (= (= |x10$| (+ ?x199 ?x293)) $x306)) (= $x230 $x306))))
+(let ((@x342 (monotonicity (rewrite (= $x45 (not $x336))) (= ?x202 (ite (not $x336) ?x199 |x8$|)))))
+(let ((@x347 (trans @x342 (rewrite (= (ite (not $x336) ?x199 |x8$|) ?x343)) (= ?x202 ?x343))))
+(let ((@x353 (monotonicity (monotonicity @x347 (= ?x208 (+ ?x182 ?x343))) (= $x213 (= |x9$| (+ ?x182 ?x343))))))
+(let ((@x360 (trans @x353 (rewrite (= (= |x9$| (+ ?x182 ?x343)) $x356)) (= $x213 $x356))))
+(let ((@x516 (monotonicity @x360 (monotonicity @x310 @x335 (= $x250 (and $x306 $x331))) (= $x253 (and $x356 (and $x306 $x331))))))
+(let ((@x367 (monotonicity (rewrite (= $x39 $x362)) (= ?x185 (ite $x362 ?x182 |x7$|)))))
+(let ((@x375 (monotonicity (trans @x367 (rewrite (= (ite $x362 ?x182 |x7$|) ?x368)) (= ?x185 ?x368)) (= ?x191 (+ ?x165 ?x368)))))
+(let ((@x385 (trans (monotonicity @x375 (= $x196 (= |x8$| (+ ?x165 ?x368)))) (rewrite (= (= |x8$| (+ ?x165 ?x368)) $x381)) (= $x196 $x381))))
+(let ((@x519 (monotonicity @x385 @x516 (= $x256 (and $x381 (and $x356 (and $x306 $x331)))))))
+(let ((@x392 (monotonicity (rewrite (= $x33 $x387)) (= ?x168 (ite $x387 ?x165 |x6$|)))))
+(let ((@x400 (monotonicity (trans @x392 (rewrite (= (ite $x387 ?x165 |x6$|) ?x393)) (= ?x168 ?x393)) (= ?x174 (+ ?x148 ?x393)))))
+(let ((@x410 (trans (monotonicity @x400 (= $x179 (= |x7$| (+ ?x148 ?x393)))) (rewrite (= (= |x7$| (+ ?x148 ?x393)) $x406)) (= $x179 $x406))))
+(let ((@x522 (monotonicity @x410 @x519 (= $x259 (and $x406 (and $x381 (and $x356 (and $x306 $x331))))))))
+(let ((@x417 (monotonicity (rewrite (= $x27 $x412)) (= ?x151 (ite $x412 ?x148 |x5$|)))))
+(let ((@x425 (monotonicity (trans @x417 (rewrite (= (ite $x412 ?x148 |x5$|) ?x418)) (= ?x151 ?x418)) (= ?x157 (+ ?x131 ?x418)))))
+(let ((@x435 (trans (monotonicity @x425 (= $x162 (= |x6$| (+ ?x131 ?x418)))) (rewrite (= (= |x6$| (+ ?x131 ?x418)) $x431)) (= $x162 $x431))))
+(let ((@x442 (monotonicity (rewrite (= $x21 (not $x436))) (= ?x134 (ite (not $x436) ?x131 |x4$|)))))
+(let ((@x447 (trans @x442 (rewrite (= (ite (not $x436) ?x131 |x4$|) ?x443)) (= ?x134 ?x443))))
+(let ((@x453 (monotonicity (monotonicity @x447 (= ?x140 (+ ?x114 ?x443))) (= $x145 (= |x5$| (+ ?x114 ?x443))))))
+(let ((@x460 (trans @x453 (rewrite (= (= |x5$| (+ ?x114 ?x443)) $x456)) (= $x145 $x456))))
+(let ((@x467 (monotonicity (rewrite (= $x15 (not $x461))) (= ?x117 (ite (not $x461) ?x114 |x3$|)))))
+(let ((@x472 (trans @x467 (rewrite (= (ite (not $x461) ?x114 |x3$|) ?x468)) (= ?x117 ?x468))))
+(let ((@x478 (monotonicity (monotonicity @x472 (= ?x123 (+ ?x96 ?x468))) (= $x128 (= |x4$| (+ ?x96 ?x468))))))
+(let ((@x485 (trans @x478 (rewrite (= (= |x4$| (+ ?x96 ?x468)) $x481)) (= $x128 $x481))))
+(let ((@x531 (monotonicity @x485 (monotonicity @x460 (monotonicity @x435 @x522 $x524) (= $x265 $x526)) (= $x268 (and $x481 $x526)))))
+(let ((@x492 (monotonicity (rewrite (= $x8 (not $x486))) (= ?x99 (ite (not $x486) ?x96 |x2$|)))))
+(let ((@x497 (trans @x492 (rewrite (= (ite (not $x486) ?x96 |x2$|) ?x493)) (= ?x99 ?x493))))
+(let ((@x503 (monotonicity (monotonicity @x497 (= ?x106 (+ (* (~ 1) |x1$|) ?x493))) (= $x111 (= |x3$| (+ (* (~ 1) |x1$|) ?x493))))))
+(let ((@x510 (trans @x503 (rewrite (= (= |x3$| (+ (* (~ 1) |x1$|) ?x493)) $x506)) (= $x111 $x506))))
+(let ((@x539 (trans (monotonicity @x510 @x531 (= $x271 (and $x506 (and $x481 $x526)))) (rewrite (= (and $x506 (and $x481 $x526)) $x535)) (= $x271 $x535))))
+(let ((@x545 (monotonicity (monotonicity @x539 (= (not $x271) (not $x535))) (= $x278 (or (not $x535) $x72)))))
+(let ((@x238 (monotonicity (rewrite (= (- |x10$|) ?x233)) (= (ite $x57 (- |x10$|) |x10$|) ?x236))))
+(let ((@x241 (monotonicity @x238 (= (- (ite $x57 (- |x10$|) |x10$|) |x9$|) (- ?x236 |x9$|)))))
+(let ((@x246 (trans @x241 (rewrite (= (- ?x236 |x9$|) ?x242)) (= (- (ite $x57 (- |x10$|) |x10$|) |x9$|) ?x242))))
+(let ((@x249 (monotonicity @x246 (= (= |x11$| (- (ite $x57 (- |x10$|) |x10$|) |x9$|)) $x247))))
+(let ((@x221 (monotonicity (rewrite (= (- |x9$|) ?x216)) (= (ite $x51 (- |x9$|) |x9$|) ?x219))))
+(let ((@x224 (monotonicity @x221 (= (- (ite $x51 (- |x9$|) |x9$|) |x8$|) (- ?x219 |x8$|)))))
+(let ((@x229 (trans @x224 (rewrite (= (- ?x219 |x8$|) ?x225)) (= (- (ite $x51 (- |x9$|) |x9$|) |x8$|) ?x225))))
+(let ((@x232 (monotonicity @x229 (= (= |x10$| (- (ite $x51 (- |x9$|) |x9$|) |x8$|)) $x230))))
+(let ((@x204 (monotonicity (rewrite (= (- |x8$|) ?x199)) (= (ite $x45 (- |x8$|) |x8$|) ?x202))))
+(let ((@x207 (monotonicity @x204 (= (- (ite $x45 (- |x8$|) |x8$|) |x7$|) (- ?x202 |x7$|)))))
+(let ((@x212 (trans @x207 (rewrite (= (- ?x202 |x7$|) ?x208)) (= (- (ite $x45 (- |x8$|) |x8$|) |x7$|) ?x208))))
+(let ((@x215 (monotonicity @x212 (= (= |x9$| (- (ite $x45 (- |x8$|) |x8$|) |x7$|)) $x213))))
+(let ((@x255 (monotonicity @x215 (monotonicity @x232 @x249 (= $x62 $x250)) (= (and (= |x9$| (- (ite $x45 (- |x8$|) |x8$|) |x7$|)) $x62) $x253))))
+(let ((@x187 (monotonicity (rewrite (= (- |x7$|) ?x182)) (= (ite $x39 (- |x7$|) |x7$|) ?x185))))
+(let ((@x190 (monotonicity @x187 (= (- (ite $x39 (- |x7$|) |x7$|) |x6$|) (- ?x185 |x6$|)))))
+(let ((@x195 (trans @x190 (rewrite (= (- ?x185 |x6$|) ?x191)) (= (- (ite $x39 (- |x7$|) |x7$|) |x6$|) ?x191))))
+(let ((@x198 (monotonicity @x195 (= (= |x8$| (- (ite $x39 (- |x7$|) |x7$|) |x6$|)) $x196))))
+(let ((@x170 (monotonicity (rewrite (= (- |x6$|) ?x165)) (= (ite $x33 (- |x6$|) |x6$|) ?x168))))
+(let ((@x173 (monotonicity @x170 (= (- (ite $x33 (- |x6$|) |x6$|) |x5$|) (- ?x168 |x5$|)))))
+(let ((@x178 (trans @x173 (rewrite (= (- ?x168 |x5$|) ?x174)) (= (- (ite $x33 (- |x6$|) |x6$|) |x5$|) ?x174))))
+(let ((@x181 (monotonicity @x178 (= (= |x7$| (- (ite $x33 (- |x6$|) |x6$|) |x5$|)) $x179))))
+(let ((@x261 (monotonicity @x181 (monotonicity @x198 @x255 (= $x64 $x256)) (= (and (= |x7$| (- (ite $x33 (- |x6$|) |x6$|) |x5$|)) $x64) $x259))))
+(let ((@x153 (monotonicity (rewrite (= (- |x5$|) ?x148)) (= (ite $x27 (- |x5$|) |x5$|) ?x151))))
+(let ((@x156 (monotonicity @x153 (= (- (ite $x27 (- |x5$|) |x5$|) |x4$|) (- ?x151 |x4$|)))))
+(let ((@x161 (trans @x156 (rewrite (= (- ?x151 |x4$|) ?x157)) (= (- (ite $x27 (- |x5$|) |x5$|) |x4$|) ?x157))))
+(let ((@x164 (monotonicity @x161 (= (= |x6$| (- (ite $x27 (- |x5$|) |x5$|) |x4$|)) $x162))))
+(let ((@x136 (monotonicity (rewrite (= (- |x4$|) ?x131)) (= (ite $x21 (- |x4$|) |x4$|) ?x134))))
+(let ((@x139 (monotonicity @x136 (= (- (ite $x21 (- |x4$|) |x4$|) |x3$|) (- ?x134 |x3$|)))))
+(let ((@x144 (trans @x139 (rewrite (= (- ?x134 |x3$|) ?x140)) (= (- (ite $x21 (- |x4$|) |x4$|) |x3$|) ?x140))))
+(let ((@x147 (monotonicity @x144 (= (= |x5$| (- (ite $x21 (- |x4$|) |x4$|) |x3$|)) $x145))))
+(let ((@x267 (monotonicity @x147 (monotonicity @x164 @x261 (= $x66 $x262)) (= (and (= |x5$| (- (ite $x21 (- |x4$|) |x4$|) |x3$|)) $x66) $x265))))
+(let ((@x119 (monotonicity (rewrite (= (- |x3$|) ?x114)) (= (ite $x15 (- |x3$|) |x3$|) ?x117))))
+(let ((@x122 (monotonicity @x119 (= (- (ite $x15 (- |x3$|) |x3$|) |x2$|) (- ?x117 |x2$|)))))
+(let ((@x127 (trans @x122 (rewrite (= (- ?x117 |x2$|) ?x123)) (= (- (ite $x15 (- |x3$|) |x3$|) |x2$|) ?x123))))
+(let ((@x130 (monotonicity @x127 (= (= |x4$| (- (ite $x15 (- |x3$|) |x3$|) |x2$|)) $x128))))
+(let ((@x101 (monotonicity (rewrite (= (- |x2$|) ?x96)) (= (ite $x8 (- |x2$|) |x2$|) ?x99))))
+(let ((@x104 (monotonicity @x101 (= (- (ite $x8 (- |x2$|) |x2$|) |x1$|) (- ?x99 |x1$|)))))
+(let ((@x110 (trans @x104 (rewrite (= (- ?x99 |x1$|) ?x106)) (= (- (ite $x8 (- |x2$|) |x2$|) |x1$|) ?x106))))
+(let ((@x113 (monotonicity @x110 (= (= |x3$| (- (ite $x8 (- |x2$|) |x2$|) |x1$|)) $x111))))
+(let ((@x273 (monotonicity @x113 (monotonicity @x130 @x267 (= $x68 $x268)) (= (and (= |x3$| (- (ite $x8 (- |x2$|) |x2$|) |x1$|)) $x68) $x271))))
+(let ((@x282 (trans (monotonicity @x273 (= $x73 (=> $x271 $x72))) (rewrite (= (=> $x271 $x72) $x278)) (= $x73 $x278))))
+(let ((@x550 (trans (monotonicity @x282 (= $x74 (not $x278))) (monotonicity @x545 (= (not $x278) $x546)) (= $x74 $x546))))
+(let ((@x552 (|not-or-elim| (mp (asserted $x74) @x550 $x546) $x535)))
+(let ((@x557 (|and-elim| @x552 $x406)))
+(let ((@x851 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x406) $x617)) @x557 $x617)))
+(let ((@x948 ((_ |th-lemma| arith triangle-eq) (or (not $x610) $x934))))
+(let ((@x1027 (|unit-resolution| @x948 (|unit-resolution| (|def-axiom| (or $x387 $x610)) @x1024 $x610) $x934)))
+(let ((@x1030 (lemma ((_ |th-lemma| arith farkas 1 1 1 1 1) @x1027 @x851 @x1025 @x842 @x1024 false) (or $x361 $x411 $x387))))
+(let ((@x615 (|def-axiom| (or $x386 $x611))))
+(let ((@x1061 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x611) $x778)) (|unit-resolution| @x615 (|unit-resolution| @x1030 @x1025 @x842 $x387) $x611) $x778)))
+(let ((@x1062 ((_ |th-lemma| arith farkas 1 1 1 1 1) (|unit-resolution| @x1030 @x1025 @x842 $x387) @x1025 @x851 @x842 @x1061 false)))
+(let ((@x1064 (lemma @x1062 (or $x361 $x411))))
+(let ((@x621 (|def-axiom| (or $x362 $x618))))
+(let ((@x863 ((_ |th-lemma| arith triangle-eq) (or (not $x618) $x838))))
+(let ((@x1087 (|unit-resolution| @x863 (|unit-resolution| @x621 (|unit-resolution| @x1064 @x842 $x361) $x618) $x838)))
+(let ((?x663 (+ |x8$| ?x354)))
+(let (($x661 (<= ?x663 0)))
+(let (($x626 (= |x8$| ?x343)))
+(let (($x665 (>= ?x663 0)))
+(let ((@x1538 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x661 $x665)) (hypothesis (not $x661)) $x665)))
+(let (($x627 (= ?x199 ?x343)))
+(let (($x337 (not $x336)))
+(let ((@x1527 (hypothesis $x337)))
+(let ((@x631 (|def-axiom| (or $x336 $x627))))
+(let ((@x1528 (|unit-resolution| @x631 @x1527 $x627)))
+(let ((?x664 (+ ?x199 ?x354)))
+(let (($x873 (<= ?x664 0)))
+(let (($x1510 (not $x873)))
+(let ((@x856 (hypothesis $x665)))
+(let ((@x1516 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x627) $x873)) (hypothesis $x627) (hypothesis $x1510) false)))
+(let ((@x1517 (lemma @x1516 (or (not $x627) $x873))))
+(let ((@x1532 (|unit-resolution| @x1517 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1) (or (not $x665) $x336 $x1510)) @x1527 @x856 $x1510) @x1528 false)))
+(let ((@x629 (|def-axiom| (or $x337 $x626))))
+(let ((@x1540 (|unit-resolution| @x629 (|unit-resolution| (lemma @x1532 (or $x336 (not $x665))) @x1538 $x336) $x626)))
+(let ((@x1127 ((_ |th-lemma| arith triangle-eq) (or (not $x626) $x661))))
+(let ((@x1542 (lemma (|unit-resolution| @x1127 @x1540 (hypothesis (not $x661)) false) $x661)))
+(let ((@x1206 (hypothesis $x838)))
+(let ((@x1211 (hypothesis $x661)))
+(let ((@x843 (hypothesis $x387)))
+(let (($x625 (>= ?x380 0)))
+(let ((@x558 (|and-elim| @x552 $x381)))
+(let ((@x833 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x381) $x625)) @x558 $x625)))
+(let (($x633 (>= ?x355 0)))
+(let ((@x559 (|and-elim| @x552 $x356)))
+(let ((@x1125 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x356) $x633)) @x559 $x633)))
+(let ((@x1429 (lemma ((_ |th-lemma| arith farkas 1 1 1 1 1 1) @x1125 @x1426 @x833 @x843 @x1211 @x1206 false) (or $x286 $x386 (not $x661) (not $x838)))))
+(let ((@x1915 (|unit-resolution| (|unit-resolution| @x1429 @x1542 (or $x286 $x386 (not $x838))) @x1087 @x1426 $x386)))
+(let ((@x613 (|def-axiom| (or $x387 $x610))))
+(let ((@x1917 (|unit-resolution| @x948 (|unit-resolution| @x613 @x1915 $x610) $x934)))
+(let ((?x678 (+ |x3$| ?x479)))
+(let (($x670 (>= ?x678 0)))
+(let (($x586 (= |x3$| ?x468)))
+(let ((?x929 (+ ?x148 ?x429)))
+(let (($x1022 (>= ?x929 0)))
+(let (($x603 (= ?x148 ?x418)))
+(let ((@x607 (|def-axiom| (or $x411 $x603))))
+(let ((@x994 (|unit-resolution| @x607 @x842 $x603)))
+(let ((@x1037 ((_ |th-lemma| arith triangle-eq) (or (not $x603) $x1022))))
+(let ((@x1038 (|unit-resolution| @x1037 @x994 $x1022)))
+(let (($x462 (not $x461)))
+(let ((@x686 (hypothesis $x462)))
+(let (($x601 (>= ?x455 0)))
+(let ((@x555 (|and-elim| @x552 $x456)))
+(let ((@x685 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x456) $x601)) @x555 $x601)))
+(let (($x608 (<= ?x430 0)))
+(let ((@x556 (|and-elim| @x552 $x431)))
+(let ((@x810 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x431) $x608)) @x556 $x608)))
+(let ((?x755 (+ |x5$| ?x429)))
+(let (($x773 (<= ?x755 0)))
+(let (($x931 (<= ?x929 0)))
+(let ((@x997 ((_ |th-lemma| arith triangle-eq) (or (not $x603) $x931))))
+(let ((@x998 (|unit-resolution| @x997 @x994 $x931)))
+(let ((@x1067 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x773 (not $x931) $x411)) @x998 @x842 $x773)))
+(let (($x609 (>= ?x430 0)))
+(let ((@x797 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x431) $x609)) @x556 $x609)))
+(let ((@x801 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x386 (not $x773) (not $x601) $x461 $x782 (not $x609)))))
+(let (($x594 (= |x4$| ?x443)))
+(let ((@x1070 ((_ |th-lemma| arith assign-bounds 1 1 1 1) (or $x436 (not $x931) $x411 (not $x609) $x386))))
+(let ((@x597 (|def-axiom| (or (not $x436) $x594))))
+(let ((@x1072 (|unit-resolution| @x597 (|unit-resolution| @x1070 @x843 @x797 @x842 @x998 $x436) $x594)))
+(let ((@x691 ((_ |th-lemma| arith triangle-eq) (or (not $x594) $x676))))
+(let ((@x1073 (|unit-resolution| @x691 @x1072 (|unit-resolution| @x801 @x843 @x797 @x1067 @x686 @x685 $x782) false)))
+(let ((@x1081 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 1 -1 1 -1) (or $x743 (not $x601) $x461 (not $x1022) (not $x608) $x387)) (|unit-resolution| (lemma @x1073 (or $x386 $x461 $x411)) @x686 @x842 $x386) @x810 @x685 @x686 @x1038 $x743)))
+(let (($x595 (= ?x131 ?x443)))
+(let (($x437 (not $x436)))
+(let ((@x1082 (|unit-resolution| @x613 (|unit-resolution| (lemma @x1073 (or $x386 $x461 $x411)) @x686 @x842 $x386) $x610)))
+(let ((@x806 ((_ |th-lemma| arith triangle-eq) (or (not $x610) $x671))))
+(let (($x668 (>= ?x666 0)))
+(let ((@x924 ((_ |th-lemma| arith triangle-eq) (or (not $x618) $x668))))
+(let ((@x1086 (|unit-resolution| @x924 (|unit-resolution| @x621 (|unit-resolution| @x1064 @x842 $x361) $x618) $x668)))
+(let ((@x1092 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x336 (not $x625) (not $x838) (not $x934) (not $x617) $x411))))
+(let ((@x1093 (|unit-resolution| @x1092 (|unit-resolution| @x948 @x1082 $x934) @x833 @x842 @x851 @x1087 $x336)))
+(let ((@x681 (hypothesis $x668)))
+(let ((@x692 (|unit-resolution| @x691 (|unit-resolution| @x597 (hypothesis $x436) $x594) $x676)))
+(let ((@x687 (hypothesis $x436)))
+(let (($x616 (<= ?x405 0)))
+(let ((@x696 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x406) $x616)) @x557 $x616)))
+(let ((@x697 (hypothesis $x671)))
+(let (($x624 (<= ?x380 0)))
+(let ((@x701 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x381) $x624)) @x558 $x624)))
+(let ((@x702 (hypothesis $x336)))
+(let ((@x707 (lemma ((_ |th-lemma| arith farkas 1 -1 1 -1 1 -1 -1 1 1) @x702 @x701 @x697 @x696 @x687 @x692 @x686 @x685 @x681 false) (or $x461 $x337 (not $x671) $x437 (not $x668)))))
+(let ((@x1094 (|unit-resolution| @x707 @x1093 @x1086 @x686 (|unit-resolution| @x806 @x1082 $x671) $x437)))
+(let ((@x599 (|def-axiom| (or $x436 $x595))))
+(let ((@x738 ((_ |th-lemma| arith triangle-eq) (or (not $x595) $x673))))
+(let ((@x1098 (lemma (|unit-resolution| @x738 (|unit-resolution| @x599 @x1094 $x595) @x1081 false) (or $x461 $x411))))
+(let ((@x589 (|def-axiom| (or $x462 $x586))))
+(let ((@x1268 ((_ |th-lemma| arith triangle-eq) (or (not $x586) $x670))))
+(let ((@x1269 (|unit-resolution| @x1268 (|unit-resolution| @x589 (|unit-resolution| @x1098 @x842 $x461) $x586) $x670)))
+(let (($x667 (>= ?x675 0)))
+(let (($x1499 (<= ?x1498 0)))
+(let ((@x1556 ((_ |th-lemma| arith triangle-eq) (or (not $x635) $x1499))))
+(let ((@x1557 (|unit-resolution| @x1556 @x1553 $x1499)))
+(let (($x930 (>= ?x672 0)))
+(let ((@x964 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x595) $x930)) (|unit-resolution| @x599 (hypothesis $x437) $x595) $x930)))
+(let ((@x939 (|unit-resolution| @x738 (|unit-resolution| @x599 (hypothesis $x437) $x595) $x673)))
+(let ((@x1185 (hypothesis $x411)))
+(let (($x1090 (not $x838)))
+(let (($x837 (>= ?x775 0)))
+(let ((@x890 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x611) $x837)) (hypothesis $x611) (hypothesis (not $x837)) false)))
+(let ((@x891 (lemma @x890 (or (not $x611) $x837))))
+(let ((@x1133 (|unit-resolution| @x891 (|unit-resolution| @x615 @x843 $x611) $x837)))
+(let ((?x776 (+ ?x182 ?x379)))
+(let (($x777 (<= ?x776 0)))
+(let (($x900 (not $x777)))
+(let ((@x904 (hypothesis $x900)))
+(let (($x619 (= ?x182 ?x368)))
+(let (($x821 (not $x619)))
+(let ((@x823 ((_ |th-lemma| arith triangle-eq) (or $x821 $x777))))
+(let ((@x907 (lemma (|unit-resolution| @x823 (hypothesis $x619) @x904 false) (or $x821 $x777))))
+(let ((@x623 (|def-axiom| (or $x361 $x619))))
+(let ((@x1363 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x777 $x362 $x1090)) (|unit-resolution| @x623 (|unit-resolution| @x907 @x904 $x821) $x361) @x904 $x1090)))
+(let ((@x1364 (|unit-resolution| @x621 (|unit-resolution| @x623 (|unit-resolution| @x907 @x904 $x821) $x361) $x618)))
+(let ((@x1366 (lemma (|unit-resolution| @x863 @x1364 @x1363 false) $x777)))
+(let ((@x1447 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 1 -1 1 -1) (or $x900 (not $x625) $x336 (not $x837) (not $x616) $x412)) @x833 @x1366 @x696 (or $x336 (not $x837) $x412))))
+(let ((@x1476 (|unit-resolution| @x1127 (|unit-resolution| @x629 (|unit-resolution| @x1447 @x1133 @x1185 $x336) $x626) $x661)))
+(let ((?x1358 (+ ?x96 ?x504)))
+(let (($x1367 (<= ?x1358 0)))
+(let (($x579 (= ?x96 ?x493)))
+(let (($x487 (not $x486)))
+(let (($x602 (= |x5$| ?x418)))
+(let ((@x605 (|def-axiom| (or $x412 $x602))))
+(let ((@x792 ((_ |th-lemma| arith triangle-eq) (or (not $x602) $x773))))
+(let ((@x1187 (|unit-resolution| @x792 (|unit-resolution| @x605 @x1185 $x602) $x773)))
+(let ((@x761 (hypothesis $x437)))
+(let ((@x1357 (lemma ((_ |th-lemma| arith farkas 1 1 1 1 1) @x1185 @x797 @x761 @x843 @x1187 false) (or $x436 $x412 $x386))))
+(let ((@x826 ((_ |th-lemma| arith triangle-eq) (or (not $x594) $x667))))
+(let ((@x1468 (|unit-resolution| @x826 (|unit-resolution| @x597 (|unit-resolution| @x1357 @x843 @x1185 $x436) $x594) $x667)))
+(let ((@x1115 ((_ |th-lemma| arith triangle-eq) (or (not $x626) $x665))))
+(let ((@x1471 (|unit-resolution| @x1115 (|unit-resolution| @x629 (|unit-resolution| @x1447 @x1133 @x1185 $x336) $x626) $x665)))
+(let ((@x1472 (|unit-resolution| @x691 (|unit-resolution| @x597 (|unit-resolution| @x1357 @x843 @x1185 $x436) $x594) $x676)))
+(let ((@x1473 (|unit-resolution| (|unit-resolution| @x801 @x797 @x685 (or $x386 (not $x773) $x461 $x782)) @x1472 @x1187 @x843 $x461)))
+(let ((@x1475 (|unit-resolution| @x1268 (|unit-resolution| @x589 @x1473 $x586) $x670)))
+(let ((@x848 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x611) $x778)) (|unit-resolution| @x615 @x843 $x611) $x778)))
+(let ((?x657 (+ |x9$| ?x304)))
+(let (($x659 (>= ?x657 0)))
+(let (($x634 (= |x9$| ?x293)))
+(let (($x774 (>= ?x755 0)))
+(let ((@x789 ((_ |th-lemma| arith triangle-eq) (or (not $x602) $x774))))
+(let ((@x1477 (|unit-resolution| @x789 (|unit-resolution| @x605 @x1185 $x602) $x774)))
+(let (($x858 (not $x665)))
+(let (($x901 (not $x667)))
+(let (($x815 (not $x774)))
+(let (($x1196 (not $x661)))
+(let (($x798 (not $x773)))
+(let (($x564 (not $x70)))
+(let (($x658 (<= ?x657 0)))
+(let ((@x1379 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1 1 1 1 1) (or $x286 $x361 (not $x633) $x900 (not $x625) $x386 $x1196)) @x1025 @x833 @x1125 @x843 @x1366 @x1211 $x286)))
+(let ((@x637 (|def-axiom| (or $x287 $x634))))
+(let ((@x1149 ((_ |th-lemma| arith triangle-eq) (or (not $x634) $x658))))
+(let (($x1354 (>= ?x776 0)))
+(let ((@x1385 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x821 $x1354)) (|unit-resolution| @x623 @x1025 $x619) $x1354)))
+(let ((@x1207 (hypothesis $x773)))
+(let ((@x866 (hypothesis $x676)))
+(let ((@x1388 (|unit-resolution| (|unit-resolution| @x801 @x797 @x685 (or $x386 $x798 $x461 $x782)) @x866 @x1207 @x843 $x461)))
+(let ((@x1390 (|unit-resolution| @x1268 (|unit-resolution| @x589 @x1388 $x586) $x670)))
+(let ((@x898 (hypothesis $x667)))
+(let (($x641 (>= ?x305 0)))
+(let ((@x560 (|and-elim| @x552 $x306)))
+(let ((@x1136 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x306) $x641)) @x560 $x641)))
+(let ((@x1199 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x361 $x311 $x1196 (not $x633) (not $x658) (not $x641)))))
+(let ((@x1393 (|unit-resolution| (|unit-resolution| @x1199 @x1136 @x1125 (or $x361 $x311 $x1196 (not $x658))) (|unit-resolution| @x1149 (|unit-resolution| @x637 @x1379 $x634) $x658) @x1211 @x1025 $x311)))
+(let ((@x645 (|def-axiom| (or (not $x311) $x642))))
+(let ((@x1396 ((_ |th-lemma| arith triangle-eq) (or (not $x642) $x1369))))
+(let (($x1139 (not $x658)))
+(let (($x1374 (not $x1354)))
+(let (($x1260 (not $x670)))
+(let (($x1104 (not $x778)))
+(let (($x1373 (not $x1369)))
+(let ((@x1137 (hypothesis $x658)))
+(let ((@x1370 (hypothesis $x1354)))
+(let (($x592 (<= ?x480 0)))
+(let ((@x554 (|and-elim| @x552 $x481)))
+(let ((@x1252 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x481) $x592)) @x554 $x592)))
+(let (($x600 (<= ?x455 0)))
+(let ((@x830 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x456) $x600)) @x555 $x600)))
+(let ((@x1249 (hypothesis $x670)))
+(let ((@x1248 (hypothesis $x778)))
+(let (($x764 (not $x655)))
+(let ((@x1253 (hypothesis $x764)))
+(let (($x649 (>= ?x330 0)))
+(let ((@x561 (|and-elim| @x552 $x331)))
+(let ((@x1256 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x331) $x649)) @x561 $x649)))
+(let ((@x1371 (hypothesis $x1369)))
+(let ((@x1372 ((_ |th-lemma| arith farkas -1 1 -1 -1 1 -1 -1 -1 1 1 -1 1 1) @x1136 @x1371 @x1256 @x1253 @x1248 @x851 @x898 @x1249 @x830 @x1252 @x1370 @x701 @x1137 false)))
+(let ((@x1376 (lemma @x1372 (or $x655 $x1373 $x1104 $x901 $x1260 $x1374 $x1139))))
+(let ((@x1398 (|unit-resolution| @x1376 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x1393 $x642) $x1369) @x848 @x898 @x1390 @x1385 (|unit-resolution| @x1149 (|unit-resolution| @x637 @x1379 $x634) $x658) $x655)))
+(let ((@x1277 ((_ |th-lemma| arith triangle-eq) (or $x71 $x764 $x708))))
+(let (($x565 (not $x71)))
+(let (($x566 (or $x564 $x565)))
+(let ((@x572 (monotonicity (rewrite (= $x72 (not $x566))) (= (not $x72) (not (not $x566))))))
+(let ((@x576 (trans @x572 (rewrite (= (not (not $x566)) $x566)) (= (not $x72) $x566))))
+(let ((@x577 (mp (|not-or-elim| (mp (asserted $x74) @x550 $x546) (not $x72)) @x576 $x566)))
+(let ((?x650 (+ |x1$| ?x233)))
+(let (($x652 (>= ?x650 0)))
+(let (($x632 (<= ?x355 0)))
+(let ((@x855 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x356) $x632)) @x559 $x632)))
+(let ((@x897 (hypothesis $x774)))
+(let (($x585 (>= ?x505 0)))
+(let ((@x553 (|and-elim| @x552 $x506)))
+(let ((@x1284 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x506) $x585)) @x553 $x585)))
+(let ((@x1404 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1 1 1) (or $x487 $x1260 (not $x592) (not $x600) $x901 $x361 (not $x617) $x386 $x1104))))
+(let ((@x1406 (|unit-resolution| @x1404 @x830 @x851 @x1252 (or $x487 $x1260 $x901 $x361 $x386 $x1104))))
+(let ((@x583 (|def-axiom| (or $x486 $x579))))
+(let ((@x1408 (|unit-resolution| @x583 (|unit-resolution| @x1406 @x1025 @x843 @x848 @x898 @x1390 $x487) $x579)))
+(let ((@x1411 ((_ |th-lemma| arith triangle-eq) (or (not $x579) $x1367))))
+(let ((@x1413 ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 -3 3 2 -2 -2 2 1 -1 -1 1 -1 1 -1) (|unit-resolution| @x1411 @x1408 $x1367) @x1284 @x897 @x810 @x898 @x830 @x848 @x851 @x1390 @x1252 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x1393 $x642) $x1369) @x1256 @x1263 @x855 @x1385 @x701 @x856 $x652)))
+(let (($x651 (<= ?x650 0)))
+(let (($x648 (<= ?x330 0)))
+(let ((@x713 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x331) $x648)) @x561 $x648)))
+(let (($x662 (>= ?x660 0)))
+(let ((@x1165 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x642) $x662)) (hypothesis $x642) (hypothesis (not $x662)) false)))
+(let ((@x1166 (lemma @x1165 (or (not $x642) $x662))))
+(let (($x593 (>= ?x480 0)))
+(let ((@x718 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x481) $x593)) @x554 $x593)))
+(let (($x679 (<= ?x678 0)))
+(let ((@x723 ((_ |th-lemma| arith triangle-eq) (or (not $x586) $x679))))
+(let (($x584 (<= ?x505 0)))
+(let ((@x1296 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x506) $x584)) @x553 $x584)))
+(let (($x1368 (>= ?x1358 0)))
+(let ((@x1419 ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 -3 3 2 -2 -2 2 1 -1 -1 1 -1 1 -1) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x579) $x1368)) @x1408 $x1368) @x1296 @x1207 @x797 @x866 @x685 @x1133 @x696 (|unit-resolution| @x723 (|unit-resolution| @x589 @x1388 $x586) $x679) @x718 (|unit-resolution| @x1166 (|unit-resolution| @x645 @x1393 $x642) $x662) @x713 @x1398 @x1125 @x1366 @x833 @x1211 $x651)))
+(let ((@x1304 ((_ |th-lemma| arith triangle-eq) (or $x70 (not $x651) (not $x652)))))
+(let ((@x1420 (|unit-resolution| @x1304 @x1419 @x1413 (|unit-resolution| @x577 (|unit-resolution| @x1277 @x1398 @x1263 $x71) $x564) false)))
+(let ((@x1478 (|unit-resolution| (lemma @x1420 (or $x361 $x798 $x782 $x1196 $x815 $x901 $x708 $x858 $x386)) @x1263 @x1472 @x1476 @x1477 @x1468 @x1187 @x1471 @x843 $x361)))
+(let ((@x1481 (|unit-resolution| @x1429 (|unit-resolution| @x863 (|unit-resolution| @x621 @x1478 $x618) $x838) @x1476 @x843 $x286)))
+(let ((@x1144 ((_ |th-lemma| arith triangle-eq) (or (not $x634) $x659))))
+(let ((@x1483 (|unit-resolution| @x1144 (|unit-resolution| @x637 @x1481 $x634) $x659)))
+(let (($x1302 (not $x652)))
+(let ((@x729 (hypothesis $x659)))
+(let (($x640 (<= ?x305 0)))
+(let ((@x728 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x306) $x640)) @x560 $x640)))
+(let ((@x1258 ((_ |th-lemma| arith farkas 1/2 -1 -1/2 -1/2 1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 1) @x681 @x855 @x701 (hypothesis $x1247) @x1256 @x1253 @x1252 @x1249 @x830 @x729 @x728 @x898 @x1248 @x851 @x856 false)))
+(let ((@x1262 (lemma @x1258 (or $x655 (not $x668) $x1259 $x1260 (not $x659) $x901 $x1104 $x858))))
+(let ((@x1309 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1119 $x1247)) (hypothesis $x643) (hypothesis $x1259) false)))
+(let ((@x1310 (lemma @x1309 (or $x1119 $x1247))))
+(let ((@x1424 (|unit-resolution| @x1310 (|unit-resolution| @x1262 @x1253 @x856 @x1249 @x681 @x898 @x1248 @x729 $x1259) $x1119)))
+(let ((@x647 (|def-axiom| (or $x311 $x643))))
+(let ((@x1431 (|unit-resolution| @x1396 (|unit-resolution| @x645 (|unit-resolution| @x647 @x1424 $x311) $x642) $x1369)))
+(let ((@x1432 ((_ |th-lemma| arith farkas -2 -1 2 1 -1 2 -1 1 1 -1 1 1 1 -1 -1 1) @x855 @x701 @x856 @x729 @x728 (|unit-resolution| @x647 @x1424 $x311) @x1431 @x1256 @x1253 @x1248 @x851 @x898 @x1249 @x830 @x1252 @x681 false)))
+(let ((@x1485 (|unit-resolution| (lemma @x1432 (or $x655 $x858 (not $x659) $x1104 $x901 $x1260 (not $x668))) @x1483 @x1471 @x848 @x1468 @x1475 (|unit-resolution| @x924 (|unit-resolution| @x621 @x1478 $x618) $x668) $x655)))
+(let ((@x1449 (|unit-resolution| @x629 (|unit-resolution| @x1447 (hypothesis $x837) @x1185 $x336) $x626)))
+(let ((@x865 (hypothesis $x837)))
+(let (($x1301 (not $x651)))
+(let ((@x1318 (hypothesis $x1301)))
+(let ((?x1142 (+ |x2$| ?x504)))
+(let (($x1237 (>= ?x1142 0)))
+(let (($x578 (= |x2$| ?x493)))
+(let (($x1409 (not $x579)))
+(let (($x1437 (not $x1368)))
+(let ((@x867 (hypothesis $x679)))
+(let ((@x1436 ((_ |th-lemma| arith farkas -1 1 1 -1 -2 -1 2 1 1 -1 -1 1 -1 1 1) @x1137 @x1136 @x865 @x696 @x866 @x867 @x685 @x718 @x1125 @x1211 @x1296 @x1318 @x1207 @x797 (hypothesis $x1368) false)))
+(let ((@x1439 (lemma @x1436 (or $x1437 $x1139 (not $x837) $x782 (not $x679) $x1196 $x651 $x798))))
+(let ((@x1451 (|unit-resolution| @x1439 @x1318 @x865 @x866 @x867 (|unit-resolution| @x1127 @x1449 $x661) @x1137 @x1187 $x1437)))
+(let ((@x1441 (hypothesis $x579)))
+(let ((@x1442 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1409 $x1368)) @x1441 (hypothesis $x1437) false)))
+(let ((@x1443 (lemma @x1442 (or $x1409 $x1368))))
+(let ((@x581 (|def-axiom| (or $x487 $x578))))
+(let ((@x1454 (|unit-resolution| @x581 (|unit-resolution| @x583 (|unit-resolution| @x1443 @x1451 $x1409) $x486) $x578)))
+(let ((@x1298 ((_ |th-lemma| arith triangle-eq) (or (not $x578) $x1237))))
+(let ((@x1456 ((_ |th-lemma| arith farkas 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 1/2 -1/2 1/2 -1/2 1) @x1249 @x1252 (|unit-resolution| @x1298 @x1454 $x1237) @x1296 @x1318 @x1187 @x797 @x1137 @x1136 @x865 @x696 @x1125 (|unit-resolution| @x1127 @x1449 $x661) @x1185 false)))
+(let ((@x1490 (|unit-resolution| (lemma @x1456 (or $x651 $x1260 $x1139 (not $x837) $x412 $x782 (not $x679))) (|unit-resolution| @x1149 (|unit-resolution| @x637 @x1481 $x634) $x658) @x1475 @x1133 @x1185 @x1472 (|unit-resolution| @x723 (|unit-resolution| @x589 @x1473 $x586) $x679) $x651)))
+(let ((@x1491 (|unit-resolution| @x1304 @x1490 (|unit-resolution| @x577 (|unit-resolution| @x1277 @x1485 @x1263 $x71) $x564) $x1302)))
+(let (($x1236 (<= ?x1142 0)))
+(let ((@x1291 ((_ |th-lemma| arith triangle-eq) (or (not $x578) $x1236))))
+(let ((@x1461 (|unit-resolution| @x1291 (|unit-resolution| @x581 (hypothesis $x486) $x578) $x1236)))
+(let ((@x1463 ((_ |th-lemma| arith farkas -1 1 -1 1 -1 1 1 -1 -1 1 1 -1 -2 -2 2 1) @x1284 (hypothesis $x1302) @x897 @x810 @x729 @x728 @x1248 @x851 @x1249 @x1252 @x855 @x856 (hypothesis $x486) @x898 @x830 @x1461 false)))
+(let ((@x1465 (lemma @x1463 (or $x487 $x652 $x815 (not $x659) $x1104 $x1260 $x858 $x901))))
+(let ((@x1493 (|unit-resolution| @x583 (|unit-resolution| @x1465 @x1491 @x1477 @x1483 @x848 @x1475 @x1471 @x1468 $x487) $x579)))
+(let ((@x1495 ((_ |th-lemma| arith farkas -1 1 -1 1 -1 1 1 -1 -1 1 1 -1 -2 2 1) @x1284 @x1491 @x1477 @x810 @x1483 @x728 @x848 @x851 @x1475 @x1252 @x855 @x1471 @x1468 @x830 (|unit-resolution| @x1411 @x1493 $x1367) false)))
+(let (($x704 (not $x671)))
+(let ((@x1150 (|unit-resolution| @x1149 (|unit-resolution| @x637 (hypothesis $x286) $x634) $x658)))
+(let ((@x1076 (hypothesis $x286)))
+(let (($x312 (not $x311)))
+(let (($x1162 (not $x642)))
+(let (($x732 (not $x662)))
+(let ((@x1145 (|unit-resolution| @x1144 (|unit-resolution| @x637 @x1076 $x634) $x659)))
+(let ((@x709 (hypothesis $x708)))
+(let ((@x714 (hypothesis $x662)))
+(let (($x845 (not $x611)))
+(let (($x870 (not $x837)))
+(let ((?x674 (+ ?x114 ?x479)))
+(let (($x677 (<= ?x674 0)))
+(let (($x587 (= ?x114 ?x468)))
+(let ((@x591 (|def-axiom| (or $x461 $x587))))
+(let ((@x760 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x587) $x677)) (|unit-resolution| @x591 @x686 $x587) $x677)))
+(let ((@x942 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1) (or $x676 $x436 $x743)) @x939 @x761 $x676)))
+(let ((@x864 (|unit-resolution| @x863 (|unit-resolution| @x621 (hypothesis $x361) $x618) $x838)))
+(let ((@x839 (hypothesis $x361)))
+(let ((@x868 ((_ |th-lemma| arith farkas -1 1 -1 1 -1 -1 1 1 -1 1 1 -1 -2 1) @x833 @x867 @x729 @x728 @x718 @x714 @x713 @x709 @x685 @x866 @x696 @x865 @x839 @x864 false)))
+(let ((@x877 (|unit-resolution| (lemma @x868 (or $x362 (not $x679) (not $x659) $x732 $x656 $x782 $x870)) @x865 @x729 @x714 @x709 @x866 @x867 $x362)))
+(let ((@x880 ((_ |th-lemma| arith farkas -1 1 -1 1 -1 -1 1 1 -1 1 1 -1 1) @x833 @x867 @x729 @x728 @x718 @x714 @x713 @x709 @x685 @x866 @x696 @x865 (|unit-resolution| @x823 (|unit-resolution| @x623 @x877 $x619) $x777) false)))
+(let ((@x882 (lemma @x880 (or $x870 (not $x679) (not $x659) $x732 $x656 $x782))))
+(let ((@x943 (|unit-resolution| @x882 @x942 @x729 @x714 @x709 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x679 (not $x677) $x461)) @x760 @x686 $x679) $x870)))
+(let ((@x946 (|unit-resolution| @x613 (|unit-resolution| @x615 (|unit-resolution| @x891 @x943 $x845) $x386) $x610)))
+(let ((@x952 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1) (or $x411 $x743 (not $x601) $x461 $x436)) @x761 @x685 @x686 @x939 $x411)))
+(let ((@x958 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x361 (not $x934) (not $x617) $x436 $x798 (not $x609)))))
+(let ((@x959 (|unit-resolution| @x958 @x761 @x851 @x797 (|unit-resolution| @x792 (|unit-resolution| @x605 @x952 $x602) $x773) (|unit-resolution| @x948 @x946 $x934) $x361)))
+(let ((@x965 ((_ |th-lemma| arith farkas -1 -1 1 1 -1 -1 1 1 1 -1 -1 1 1) @x833 @x729 @x728 @x760 @x718 @x714 @x713 @x709 (|unit-resolution| @x948 @x946 $x934) @x851 @x964 @x830 (|unit-resolution| @x863 (|unit-resolution| @x621 @x959 $x618) $x838) false)))
+(let ((@x972 (|unit-resolution| (lemma @x965 (or $x436 (not $x659) $x732 $x656 $x461)) @x686 @x714 @x709 @x729 $x436)))
+(let ((@x976 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1) (or $x411 (not $x601) $x461 $x437 $x782)) (|unit-resolution| @x691 (|unit-resolution| @x597 @x972 $x594) $x676) @x685 @x686 @x972 $x411)))
+(let ((@x979 (|unit-resolution| @x882 (|unit-resolution| @x691 (|unit-resolution| @x597 @x972 $x594) $x676) @x729 @x714 @x709 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x679 (not $x677) $x461)) @x760 @x686 $x679) $x870)))
+(let ((@x982 (|unit-resolution| @x613 (|unit-resolution| @x615 (|unit-resolution| @x891 @x979 $x845) $x386) $x610)))
+(let ((@x933 ((_ |th-lemma| arith farkas -1 -1 1 1 -1 -1 1 1 -1 1 -2 2 -1 1 1) @x833 @x729 @x728 (hypothesis $x677) @x718 @x714 @x713 @x709 @x697 @x696 @x897 @x810 @x898 @x830 (hypothesis $x777) false)))
+(let ((@x969 (lemma @x933 (or $x900 (not $x659) (not $x677) $x732 $x656 $x704 $x815 $x901))))
+(let ((@x984 (|unit-resolution| @x969 @x760 @x729 @x714 @x709 (|unit-resolution| @x806 @x982 $x671) (|unit-resolution| @x789 (|unit-resolution| @x605 @x976 $x602) $x774) (|unit-resolution| @x826 (|unit-resolution| @x597 @x972 $x594) $x667) $x900)))
+(let ((@x987 (|unit-resolution| @x621 (|unit-resolution| @x623 (|unit-resolution| @x907 @x984 $x821) $x361) $x618)))
+(let ((@x989 ((_ |th-lemma| arith farkas -1 -1 1 1 -1 -1 1 1 -1 1 -2 2 -2 -1 1 1) @x833 @x729 @x728 @x760 @x718 @x714 @x713 @x709 (|unit-resolution| @x806 @x982 $x671) @x696 (|unit-resolution| @x789 (|unit-resolution| @x605 @x976 $x602) $x774) @x810 (|unit-resolution| @x623 (|unit-resolution| @x907 @x984 $x821) $x361) (|unit-resolution| @x826 (|unit-resolution| @x597 @x972 $x594) $x667) @x830 (|unit-resolution| @x863 @x987 $x838) false)))
+(let ((@x970 (|unit-resolution| (lemma @x989 (or $x461 (not $x659) $x732 $x656)) @x714 @x729 @x709 $x461)))
+(let ((@x992 (|unit-resolution| @x723 (|unit-resolution| @x589 @x970 $x586) $x679)))
+(let ((@x1009 (|unit-resolution| @x891 (|unit-resolution| @x882 @x942 @x729 @x714 @x709 @x992 $x870) $x845)))
+(let ((@x1012 (|unit-resolution| @x948 (|unit-resolution| @x613 (|unit-resolution| @x615 @x1009 $x386) $x610) $x934)))
+(let ((@x751 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x656 $x655)) @x709 $x655)))
+(let ((@x999 (hypothesis $x934)))
+(let ((@x1002 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 2) (or $x361 (not $x934) (not $x617) $x436 (not $x609) (not $x931) $x411))))
+(let ((@x1004 (|unit-resolution| @x621 (|unit-resolution| @x1002 @x842 @x797 @x851 @x761 @x999 @x998 $x361) $x618)))
+(let ((@x762 (hypothesis $x655)))
+(let ((@x1006 ((_ |th-lemma| arith farkas 1 1 1 2 1 1 1 1 1 1 1 1 1 2 1) @x833 @x999 @x851 @x842 @x729 @x728 @x718 @x714 @x713 @x762 @x685 @x939 @x867 @x761 (|unit-resolution| @x863 @x1004 $x838) false)))
+(let ((@x1008 (lemma @x1006 (or $x411 (not $x934) (not $x659) $x732 $x764 (not $x679) $x436))))
+(let ((@x1014 (|unit-resolution| @x605 (|unit-resolution| @x1008 @x1012 @x729 @x714 @x751 @x992 @x761 $x411) $x602)))
+(let ((@x1016 (|unit-resolution| @x958 (|unit-resolution| @x792 @x1014 $x773) @x851 @x761 @x1012 @x797 $x361)))
+(let ((@x1019 ((_ |th-lemma| arith farkas -1/2 1/2 -1/2 1/2 -1/2 1/2 1/2 -1/2 1/2 1/2 -1/2 -1/2 -1/2 1) @x830 @x964 (|unit-resolution| @x863 (|unit-resolution| @x621 @x1016 $x618) $x838) @x833 @x1012 @x851 @x729 @x728 @x718 @x714 @x713 @x709 @x992 @x970 false)))
+(let ((@x1023 (|unit-resolution| (lemma @x1019 (or $x436 (not $x659) $x732 $x656)) @x714 @x729 @x709 $x436)))
+(let ((@x1033 (|unit-resolution| @x882 (|unit-resolution| @x691 (|unit-resolution| @x597 @x1023 $x594) $x676) @x729 @x714 @x709 @x992 $x870)))
+(let ((@x1035 (|unit-resolution| @x615 (|unit-resolution| @x891 @x1033 $x845) $x386)))
+(let ((@x1041 (|unit-resolution| @x863 (|unit-resolution| @x621 (|unit-resolution| @x1030 @x842 @x1035 $x361) $x618) $x838)))
+(let ((@x1044 ((_ |th-lemma| arith farkas -1 1 -1 1 1 -1 1 1 -1 -1 -1 1 -1 1 1) (|unit-resolution| @x948 (|unit-resolution| @x613 @x1035 $x610) $x934) @x851 @x1041 @x833 @x729 @x728 @x718 @x714 @x713 @x709 @x992 @x1038 @x810 @x970 @x1035 false)))
+(let ((@x1049 (|unit-resolution| (lemma @x1044 (or $x411 (not $x659) $x732 $x656)) @x714 @x729 @x709 $x411)))
+(let ((@x895 (|unit-resolution| @x723 (|unit-resolution| @x589 (hypothesis $x461) $x586) $x679)))
+(let ((@x899 ((_ |th-lemma| arith farkas -1/2 1/2 1 -1 -1/2 1/2 -1/2 1/2 -1/2 1/2 1/2 -1/2 -1/2 -1/2 1/2 1) @x830 @x898 @x897 @x810 (hypothesis $x777) @x833 @x895 @x729 @x728 @x718 @x714 @x713 @x709 @x696 @x697 (hypothesis $x461) false)))
+(let ((@x903 (lemma @x899 (or $x900 $x901 $x815 (not $x659) $x732 $x656 $x704 $x462))))
+(let ((@x1052 (|unit-resolution| @x903 (|unit-resolution| @x789 (|unit-resolution| @x605 @x1049 $x602) $x774) @x970 @x729 @x714 @x709 (|unit-resolution| @x826 (|unit-resolution| @x597 @x1023 $x594) $x667) (|unit-resolution| @x806 (|unit-resolution| @x613 @x1035 $x610) $x671) $x900)))
+(let ((@x1055 (|unit-resolution| @x621 (|unit-resolution| @x623 (|unit-resolution| @x907 @x1052 $x821) $x361) $x618)))
+(let ((@x1057 ((_ |th-lemma| arith farkas 1 -1 1/2 -1/2 1 1/2 -1/2 -1/2 1/2 1/2 -1/2 1/2 1/2 -1/2 -1/2 -1/2 1) (|unit-resolution| @x789 (|unit-resolution| @x605 @x1049 $x602) $x774) @x810 (|unit-resolution| @x826 (|unit-resolution| @x597 @x1023 $x594) $x667) @x830 (|unit-resolution| @x623 (|unit-resolution| @x907 @x1052 $x821) $x361) (|unit-resolution| @x806 (|unit-resolution| @x613 @x1035 $x610) $x671) @x696 (|unit-resolution| @x863 @x1055 $x838) @x833 @x729 @x728 @x718 @x714 @x713 @x709 @x992 @x970 false)))
+(let ((@x1167 (|unit-resolution| (lemma @x1057 (or $x732 (not $x659) $x656)) @x709 @x1145 $x732)))
+(let ((@x1169 (|unit-resolution| @x645 (|unit-resolution| @x1166 @x1167 $x1162) $x312)))
+(let ((@x1191 ((_ |th-lemma| arith assign-bounds 1 1 1 1) (or $x336 $x311 $x1139 (not $x641) $x287))))
+(let ((@x1216 (|unit-resolution| @x629 (|unit-resolution| @x1191 @x1169 @x1136 @x1076 @x1150 $x336) $x626)))
+(let ((@x1217 (|unit-resolution| @x1127 @x1216 $x661)))
+(let ((@x1131 (|unit-resolution| @x723 (|unit-resolution| @x589 (|unit-resolution| @x1098 @x842 $x461) $x586) $x679)))
+(let (($x1103 (>= ?x1101 0)))
+(let ((@x1158 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1119 $x1103)) (hypothesis $x643) (hypothesis (not $x1103)) false)))
+(let ((@x1159 (lemma @x1158 (or $x1119 $x1103))))
+(let ((@x1110 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x934 $x671)) (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x704 $x1104 $x386)) @x848 @x843 $x704) $x934)))
+(let ((@x1112 (|unit-resolution| @x629 (|unit-resolution| @x1092 @x1110 @x833 @x851 @x842 @x1087 $x336) $x626)))
+(let ((@x841 (hypothesis $x311)))
+(let ((@x860 (lemma ((_ |th-lemma| arith farkas 1 1 1 1 1 1 1 1 1) @x856 @x855 @x851 @x843 @x729 @x728 @x848 @x842 @x841 false) (or $x411 $x858 $x386 (not $x659) $x312))))
+(let ((@x1117 (|unit-resolution| @x860 (|unit-resolution| @x1115 @x1112 $x665) @x842 @x729 @x843 $x312)))
+(let ((@x1122 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1119 $x1103)) (|unit-resolution| @x647 @x1117 $x643) $x1103)))
+(let ((@x1138 ((_ |th-lemma| arith farkas 1 -1 1 -1 -1 1 -1 -1 1 -1 1 -1 -2 2 1) @x833 @x1137 @x1136 @x1087 @x696 @x1133 @x713 @x709 @x718 (|unit-resolution| @x691 @x1072 $x676) @x685 @x1131 (|unit-resolution| @x1127 @x1112 $x661) @x1125 @x1122 false)))
+(let ((@x1172 (|unit-resolution| (lemma @x1138 (or $x386 $x1139 $x656 $x411 (not $x659))) @x842 @x709 @x1150 @x1145 $x386)))
+(let ((@x1152 ((_ |th-lemma| arith farkas -1/2 1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 -1/2 1/2 -1/2 1/2 -1/2 1) @x701 @x681 @x697 @x696 (hypothesis $x1103) @x1150 @x1136 @x713 @x709 @x718 @x866 @x685 @x867 @x1076 false)))
+(let ((@x1155 (lemma @x1152 (or (not $x1103) (not $x668) $x704 $x656 $x782 (not $x679) $x287))))
+(let ((@x1175 (|unit-resolution| @x1155 (|unit-resolution| @x806 (|unit-resolution| @x613 @x1172 $x610) $x671) (|unit-resolution| @x1159 (|unit-resolution| @x647 @x1169 $x643) $x1103) @x709 @x1131 @x1086 @x1076 $x782)))
+(let ((@x1177 (|unit-resolution| @x1092 @x1087 @x833 @x842 (|unit-resolution| @x948 (|unit-resolution| @x613 @x1172 $x610) $x934) @x851 $x336)))
+(let ((@x1102 (lemma ((_ |th-lemma| arith farkas 1 1 1 1 1 1 1 1 1) @x856 @x701 @x1086 @x855 @x761 @x998 @x842 @x797 @x1076 false) (or $x436 $x858 $x411 $x287))))
+(let ((@x1180 (|unit-resolution| @x1102 (|unit-resolution| @x1115 (|unit-resolution| @x629 @x1177 $x626) $x665) @x842 @x1076 $x436)))
+(let ((@x1184 (lemma (|unit-resolution| @x691 (|unit-resolution| @x597 @x1180 $x594) @x1175 false) (or $x411 $x287 $x656))))
+(let ((@x1220 (|unit-resolution| @x789 (|unit-resolution| @x605 (|unit-resolution| @x1184 @x709 @x1076 $x411) $x602) $x774)))
+(let ((@x1193 (|unit-resolution| @x629 (|unit-resolution| @x1191 (hypothesis $x312) @x1136 @x1076 @x1150 $x336) $x626)))
+(let ((@x1188 (hypothesis $x312)))
+(let ((@x1200 (|unit-resolution| @x1199 (|unit-resolution| @x1127 @x1193 $x661) @x1136 @x1188 @x1150 @x1125 $x361)))
+(let ((@x1203 ((_ |th-lemma| arith farkas -1 1 -1 -1 -1 1 1 -1 1) @x1185 @x701 (|unit-resolution| @x924 (|unit-resolution| @x621 @x1200 $x618) $x668) @x1076 (|unit-resolution| @x1115 @x1193 $x665) @x855 @x761 @x797 @x1187 false)))
+(let ((@x1205 (lemma @x1203 (or $x436 $x412 $x287 $x311))))
+(let ((@x1221 (|unit-resolution| @x1205 (|unit-resolution| @x1184 @x709 @x1076 $x411) @x1076 @x1169 $x436)))
+(let (($x816 (not $x608)))
+(let (($x1197 (not $x633)))
+(let (($x1189 (not $x641)))
+(let (($x741 (not $x616)))
+(let ((@x1224 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1 -1 1 1 -1 1 1 -1) (or $x704 $x741 $x311 $x1139 $x1189 $x815 $x1196 $x1197 $x437 $x816)) @x1169 @x696 @x1125 @x1136 @x810 @x1150 @x1221 @x1220 @x1217 $x704)))
+(let ((@x1225 (|unit-resolution| @x792 (|unit-resolution| @x605 (|unit-resolution| @x1184 @x709 @x1076 $x411) $x602) $x773)))
+(let ((@x1229 (|unit-resolution| @x621 (|unit-resolution| @x1199 @x1217 @x1136 @x1169 @x1150 @x1125 $x361) $x618)))
+(let ((@x1209 (|unit-resolution| @x589 (|unit-resolution| @x801 @x843 @x797 @x1207 @x866 @x685 $x461) $x586)))
+(let ((@x1212 ((_ |th-lemma| arith farkas -1 -2 2 -1 1 1 -1 -1 1 -1 1 -1 -1 1 1) @x696 @x1211 @x1125 @x1137 @x1136 (hypothesis $x1103) @x713 @x709 @x718 (|unit-resolution| @x723 @x1209 $x679) @x833 @x1206 @x866 @x685 @x1133 false)))
+(let ((@x1231 (|unit-resolution| (lemma @x1212 (or $x386 $x1196 $x1139 (not $x1103) $x656 $x1090 $x782 $x798)) @x1217 @x1150 (|unit-resolution| @x1159 (|unit-resolution| @x647 @x1169 $x643) $x1103) @x709 (|unit-resolution| @x863 @x1229 $x838) (|unit-resolution| @x691 (|unit-resolution| @x597 @x1221 $x594) $x676) @x1225 $x386)))
+(let ((@x1235 (lemma (|unit-resolution| @x806 (|unit-resolution| @x613 @x1231 $x610) @x1224 false) (or $x656 $x287))))
+(let ((@x1502 (|unit-resolution| @x1235 (|unit-resolution| (lemma @x1495 (or $x708 $x412 $x386)) @x843 @x1185 $x708) $x287)))
+(let ((@x1504 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1 1 1 1 1) (or $x286 $x361 $x1197 $x900 (not $x625) $x386 $x1196)) @x1502 @x833 @x1125 @x843 @x1366 @x1476 $x361)))
+(let ((@x1506 (|unit-resolution| @x863 (|unit-resolution| @x621 @x1504 $x618) (|unit-resolution| @x1429 @x1502 @x1476 @x843 $x1090) false)))
+(let ((@x1508 (lemma @x1506 (or $x386 $x412))))
+(let ((@x1815 (|unit-resolution| @x1508 @x1185 $x386)))
+(let (($x1513 (not $x627)))
+(let ((@x1519 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1 -1 1 1) (or $x1510 $x1197 $x387 $x1374 (not $x624) $x286)) @x1385 @x1125 @x1426 @x1024 @x701 $x1510)))
+(let ((@x1522 (|unit-resolution| @x629 (|unit-resolution| @x631 (|unit-resolution| @x1517 @x1519 $x1513) $x336) $x626)))
+(let ((@x1524 ((_ |th-lemma| arith farkas 1 1 1 1 1) @x1426 @x1125 (|unit-resolution| @x1127 @x1522 $x661) @x1025 (|unit-resolution| @x631 (|unit-resolution| @x1517 @x1519 $x1513) $x336) false)))
+(let ((@x1526 (lemma @x1524 (or $x361 $x286 $x387))))
+(let ((@x1826 (|unit-resolution| @x924 (|unit-resolution| @x621 (|unit-resolution| @x1526 @x1815 @x1426 $x361) $x618) $x668)))
+(let (($x705 (not $x668)))
+(let ((@x1734 (|unit-resolution| @x806 (|unit-resolution| @x613 @x1024 $x610) $x671)))
+(let ((@x1670 (|unit-resolution| @x924 (|unit-resolution| @x621 @x839 $x618) $x668)))
+(let (($x1500 (>= ?x664 0)))
+(let ((@x1546 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1513 $x1500)) @x1528 $x1500)))
+(let ((@x1547 (|unit-resolution| @x1517 @x1528 $x873)))
+(let ((@x1550 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1 1 1) (or $x437 $x815 $x816 $x704 $x741 $x1510 $x1197 $x286 $x336)) @x1426 @x696 @x1527 @x1125 @x810 @x697 @x1477 @x1547 $x437)))
+(let ((@x1552 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x595) $x930)) (|unit-resolution| @x599 @x1550 $x595) $x930)))
+(let ((@x1558 (|unit-resolution| @x738 (|unit-resolution| @x599 @x1550 $x595) $x673)))
+(let (($x740 (not $x624)))
+(let (($x742 (not $x601)))
+(let ((@x1560 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1 1 1 1 2 2) (or $x461 $x815 $x816 $x742 $x705 $x740 $x1510 $x1197 $x286 $x743 $x704 $x741))))
+(let ((@x1561 (|unit-resolution| @x1560 @x1426 @x810 @x696 @x701 @x1125 @x685 @x697 @x681 @x1558 @x1477 @x1547 $x461)))
+(let ((@x1566 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1 1 1) (or $x311 (not $x1499) $x1189 $x286 $x705 $x412 $x704 $x741 $x740))))
+(let ((@x1568 (|unit-resolution| @x645 (|unit-resolution| @x1566 @x1557 @x701 @x1185 @x1136 @x1426 @x697 @x681 @x696 $x311) $x642)))
+(let ((@x1570 ((_ |th-lemma| arith assign-bounds -1 1 1 -1 -1 -1 -3 3 1 -1 1 1 -2 2 2 -2) (|unit-resolution| @x1396 @x1568 $x1369) @x1256 (|unit-resolution| @x1268 (|unit-resolution| @x589 @x1561 $x586) $x670) @x1252 @x830 @x1206 @x999 @x851 @x833 @x1557 @x1136 @x1552 @x1187 @x797 @x1546 @x855 $x655)))
+(let ((@x1574 (|unit-resolution| @x723 (|unit-resolution| @x589 @x1561 $x586) $x679)))
+(let ((@x1576 ((_ |th-lemma| arith assign-bounds -1 1 1 -1 -1 -1 -3 3 1 -1 1 1 -2 2 2 -2) (|unit-resolution| @x1166 @x1568 $x662) @x713 @x1574 @x718 @x685 @x681 @x697 @x696 @x701 @x1573 @x728 @x1558 @x1477 @x810 @x1547 @x1125 $x656)))
+(let (($x813 (not $x593)))
+(let (($x869 (not $x679)))
+(let (($x1579 (or $x486 $x286 $x336 $x869 $x813 $x742 $x705 $x704 $x741 $x740 $x743 $x815 $x816 $x1510 $x1197)))
+(let ((@x1581 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1 1 1 1 1 3 3 1 1 2 2 2 2) $x1579) @x1426 @x685 @x810 @x696 @x701 @x1527 @x1125 @x718 @x697 @x681 @x1558 @x1477 @x1574 @x1547 $x486)))
+(let (($x812 (not $x640)))
+(let (($x1586 (not $x1543)))
+(let (($x1585 (not $x585)))
+(let (($x1584 (not $x1236)))
+(let (($x1587 (or $x652 $x1584 $x1585 $x815 $x816 $x1510 $x1197 $x704 $x741 $x869 $x813 $x1586 $x812)))
+(let ((@x1589 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 1 -1 -1 1 1 -1 -1 1) $x1587) @x1574 @x810 @x696 @x1125 @x728 @x1284 @x697 @x1477 @x718 @x1547 @x1573 (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1581 $x578) $x1236) $x652)))
+(let (($x1564 (not $x1499)))
+(let (($x1401 (not $x592)))
+(let (($x956 (not $x617)))
+(let (($x955 (not $x934)))
+(let (($x1593 (not $x632)))
+(let (($x1592 (not $x1500)))
+(let (($x799 (not $x609)))
+(let (($x1591 (not $x584)))
+(let (($x1321 (not $x1237)))
+(let (($x1594 (or $x651 $x1321 $x1591 $x798 $x799 $x1592 $x1593 $x955 $x956 $x1260 $x1401 $x1564 $x1189)))
+(let ((@x1596 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 1 -1 -1 1 1 -1 -1 1) $x1594) (|unit-resolution| @x1268 (|unit-resolution| @x589 @x1561 $x586) $x670) @x797 @x851 @x855 @x1136 @x1296 @x1187 @x1252 @x999 (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1581 $x578) $x1237) @x1557 @x1546 $x651)))
+(let ((@x1597 (|unit-resolution| @x1304 @x1596 @x1589 (|unit-resolution| @x577 (|unit-resolution| @x1277 @x1576 @x1570 $x71) $x564) false)))
+(let ((@x1671 (|unit-resolution| (lemma @x1597 (or $x286 $x955 $x704 $x336 $x705 $x1090 $x412)) @x1670 @x697 @x1527 @x999 @x864 @x1185 $x286)))
+(let ((@x1673 (|unit-resolution| @x1149 (|unit-resolution| @x637 @x1671 $x634) $x658)))
+(let ((@x1676 (|unit-resolution| (|unit-resolution| @x1191 @x1136 (or $x336 $x311 $x1139 $x287)) @x1673 @x1671 @x1527 $x311)))
+(let ((@x1677 (|unit-resolution| @x1235 @x1671 $x656)))
+(let (($x1654 (or $x655 $x705 $x704 $x1139 $x1104 $x815 $x1564 $x798 $x955 $x1592 $x1090 $x708 $x312)))
+(let ((@x1602 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x841 $x642) $x1369)))
+(let ((@x1600 (hypothesis $x1500)))
+(let ((@x1623 (hypothesis $x1499)))
+(let ((@x1604 ((_ |th-lemma| arith farkas 2 2 2 2 1 1 1 1 1 1 1 1 1 1) (hypothesis $x487) @x1602 @x1256 @x1263 @x1136 @x761 @x1207 @x797 @x999 @x851 @x1600 @x855 @x841 @x1137 false)))
+(let ((@x1620 (|unit-resolution| (lemma @x1604 (or $x486 $x708 $x436 $x798 $x955 $x1592 $x312 $x1139)) @x761 @x1263 @x1207 @x999 @x1600 @x841 @x1137 $x486)))
+(let (($x1626 (not $x930)))
+(let (($x1089 (not $x625)))
+(let (($x1402 (not $x600)))
+(let (($x1625 (not $x649)))
+(let (($x1627 (or $x1301 $x1584 $x1585 $x798 $x799 $x1592 $x1593 $x955 $x956 $x1373 $x1625 $x655 $x1402 $x1090 $x1089 $x1626)))
+(let ((@x1629 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 1 -1 -1 1 2 -2 1 -1 -1 1 1 -1 -1) $x1627) @x964 @x797 @x851 @x833 @x855 @x1256 @x1284 @x1253 @x1207 @x999 @x830 @x1206 @x1602 @x1600 (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1620 $x578) $x1236) $x1301)))
+(let ((@x1630 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 1 -1 -1 1 1 -1 -1 1) $x1594) @x1629 @x797 @x851 @x855 @x1136 @x1623 @x1207 (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1620 $x578) $x1237) @x999 @x1252 @x1296 @x1600 $x1260)))
+(let (($x757 (not $x587)))
+(let (($x1607 (>= ?x674 0)))
+(let (($x1611 (not $x1607)))
+(let ((@x1609 (hypothesis $x673)))
+(let ((@x1610 ((_ |th-lemma| arith farkas 1 1 -1 1 -1 -1 -1 -1 1 1 -1 1 1) @x685 @x697 @x696 @x681 @x701 @x1609 @x1252 @x1371 @x1256 @x1253 @x1137 @x1136 (hypothesis $x1607) false)))
+(let ((@x1613 (lemma @x1610 (or $x1611 $x704 $x705 $x743 $x1373 $x655 $x1139))))
+(let ((@x1618 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x757 $x1607)) (hypothesis $x587) (hypothesis $x1611) false)))
+(let ((@x1619 (lemma @x1618 (or $x757 $x1607))))
+(let ((@x1632 (|unit-resolution| @x1619 (|unit-resolution| @x1613 @x939 @x681 @x697 @x1602 @x1253 @x1137 $x1611) $x757)))
+(let ((@x1635 (|unit-resolution| @x1268 (|unit-resolution| @x589 (|unit-resolution| @x591 @x1632 $x461) $x586) @x1630 false)))
+(let ((@x1637 (lemma @x1635 (or $x436 $x705 $x704 $x655 $x1139 $x1564 $x798 $x955 $x1592 $x1090 $x708 $x312))))
+(let ((@x1638 (|unit-resolution| @x1637 @x1253 @x697 @x681 @x1137 @x1623 @x1207 @x999 @x1600 @x1206 @x1263 @x841 $x436)))
+(let ((@x1641 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -2 -2 2 -2 2) (or $x1354 $x705 $x437 $x815 $x816 $x704 $x741)) @x1638 @x696 @x697 @x681 @x897 @x810 $x1354)))
+(let ((@x1644 (|unit-resolution| @x1376 (|unit-resolution| @x826 (|unit-resolution| @x597 @x1638 $x594) $x667) @x1248 @x1137 @x1253 @x1641 @x1602 $x1260)))
+(let ((@x1648 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x673 $x437 $x782)) (|unit-resolution| @x691 (|unit-resolution| @x597 @x1638 $x594) $x676) @x1638 $x673)))
+(let ((@x1650 (|unit-resolution| @x1619 (|unit-resolution| @x1613 @x1648 @x681 @x697 @x1602 @x1253 @x1137 $x1611) $x757)))
+(let ((@x1653 (|unit-resolution| @x1268 (|unit-resolution| @x589 (|unit-resolution| @x591 @x1650 $x461) $x586) @x1644 false)))
+(let ((@x1681 (|unit-resolution| (lemma @x1653 $x1654) @x1670 @x697 @x1673 @x1248 @x1477 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -2) (or $x1499 $x1139 $x287)) @x1673 @x1671 $x1499) @x1187 @x999 @x1546 @x864 @x1677 @x1676 $x655)))
+(let (($x1665 (or $x436 $x815 $x1510 $x704 $x764 $x705 $x708 $x798 $x955 $x1090 $x1592 $x312 $x1139)))
+(let (($x1658 (or $x652 $x1584 $x1585 $x798 $x799 $x1592 $x1593 $x955 $x956 $x1373 $x1625 $x708 $x1402 $x1090 $x1089 $x1626)))
+(let ((@x1660 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1 2 2 1 1 1 1 1 -1 -1) $x1658) (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1620 $x578) $x1236) @x797 @x851 @x833 @x855 @x1256 @x964 @x1263 @x1207 @x999 @x830 @x1206 @x1602 @x1600 @x1284 $x652)))
+(let ((@x1661 (|unit-resolution| @x1304 @x1660 (|unit-resolution| @x577 (|unit-resolution| @x1277 @x762 @x1263 $x71) $x564) $x1301)))
+(let ((@x1664 ((_ |th-lemma| arith farkas 1 -1 1 -1 -1 1 2 -2 1 -1 -1 1 1 -1 -1 1) (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1620 $x578) $x1237) @x1296 @x897 @x810 (hypothesis $x873) @x1125 @x697 @x696 (|unit-resolution| @x1166 (|unit-resolution| @x645 @x841 $x642) $x662) @x713 @x762 @x685 @x681 @x701 @x939 @x1661 false)))
+(let ((@x1682 (|unit-resolution| (lemma @x1664 $x1665) @x1681 @x1547 @x697 @x1477 @x1670 @x1677 @x1187 @x999 @x864 @x1546 @x1676 @x1673 $x436)))
+(let ((@x1694 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -2 2 -2 -2 2 -1) (or $x930 $x815 $x816 $x704 $x362 $x741 $x901)) @x696 @x810 (or $x930 $x815 $x704 $x362 $x901))))
+(let ((@x1695 (|unit-resolution| @x1694 (|unit-resolution| @x826 (|unit-resolution| @x597 @x1682 $x594) $x667) @x697 @x839 @x1477 $x930)))
+(let ((@x1667 ((_ |th-lemma| arith farkas 1 -1 1 -1 -1 -1 1 1 -1 1 1) @x681 @x701 @x697 @x696 (hypothesis $x487) @x1371 @x1256 @x1263 @x1137 @x1136 @x1185 false)))
+(let ((@x1669 (lemma @x1667 (or $x486 $x705 $x704 $x1373 $x708 $x1139 $x412))))
+(let ((@x1696 (|unit-resolution| @x1669 @x1670 @x697 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x1676 $x642) $x1369) @x1677 @x1673 @x1185 $x486)))
+(let ((@x1699 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1 2 2 1 1 1 1 1 -1 -1) $x1658) (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1696 $x578) $x1236) @x797 @x851 @x833 @x855 @x1256 @x1695 @x1677 @x1187 @x999 @x830 @x864 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x1676 $x642) $x1369) @x1546 @x1284 $x652)))
+(let ((@x1700 (|unit-resolution| @x1304 @x1699 (|unit-resolution| @x577 (|unit-resolution| @x1277 @x1681 @x1677 $x71) $x564) $x1301)))
+(let ((@x1702 ((_ |th-lemma| arith farkas -2 -1 1 -1 -1 1 1 -1 -2 2 -1 1 1 -1 -1 1 1) @x1682 (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1696 $x578) $x1237) @x1296 @x1700 @x1477 @x810 @x1547 @x1125 @x697 @x696 (|unit-resolution| @x1166 (|unit-resolution| @x645 @x1676 $x642) $x662) @x713 @x1681 @x685 @x1670 @x701 (|unit-resolution| @x691 (|unit-resolution| @x597 @x1682 $x594) $x676) false)))
+(let ((@x1736 (|unit-resolution| (lemma @x1702 (or $x362 $x704 $x955 $x412 $x1104 $x336)) @x1527 @x1027 @x1185 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x778 $x387 $x955)) @x1027 @x1024 $x778) @x1734 $x362)))
+(let ((@x1737 (|unit-resolution| (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1) (or $x705 $x361 $x900)) @x1366 (or $x705 $x361)) @x1736 $x705)))
+(let ((@x1741 (|unit-resolution| @x1149 (|unit-resolution| @x637 (|unit-resolution| @x1526 @x1736 @x1024 $x286) $x634) $x658)))
+(let ((@x1743 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x821 $x1354)) (|unit-resolution| @x623 @x1736 $x619) $x1354)))
+(let ((@x1744 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 2 1 2 2 2) (or $x1374 $x1139 $x1189 $x1090 $x1197 $x1196 $x311)) @x1743 @x1542 @x1741 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x838 $x668)) @x1737 $x838) @x1136 @x1125 $x311)))
+(let ((@x1747 (|unit-resolution| @x1235 (|unit-resolution| @x1526 @x1736 @x1024 $x286) $x656)))
+(let ((@x1750 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1) (or $x486 $x336 $x1373 $x1625 $x708 $x1139 $x1189)) @x1527 @x1136 @x1256 @x1747 @x1741 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x1744 $x642) $x1369) $x486)))
+(let ((@x1719 (|unit-resolution| @x958 @x851 @x797 (or $x361 $x955 $x436 $x798))))
+(let ((@x1755 (|unit-resolution| @x826 (|unit-resolution| @x597 (|unit-resolution| @x1719 @x1736 @x1027 @x1187 $x436) $x594) $x667)))
+(let (($x1756 (or $x652 $x901 $x1584 $x1585 $x815 $x816 $x1592 $x1593 $x1373 $x1625 $x708 $x1402 $x1089 $x900)))
+(let ((@x1758 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 1 -1 -1 1 -1 1 1 -1 -1 1 -1 1) $x1756) @x1747 @x810 @x833 @x855 @x1256 @x1284 @x830 @x1477 @x1755 @x1366 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x1744 $x642) $x1369) @x1546 (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1750 $x578) $x1236) $x652)))
+(let ((@x1709 (|unit-resolution| (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1) (or $x705 $x361 $x900)) @x1366 (or $x705 $x361)) @x1025 $x705)))
+(let ((@x1715 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 2 1 2 2 2) (or $x1374 $x1139 $x1189 $x1090 $x1197 $x1196 $x311)) @x1385 @x1542 @x1137 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x838 $x668)) @x1709 $x838) @x1136 @x1125 $x311)))
+(let ((@x1722 (|unit-resolution| @x691 (|unit-resolution| @x597 (|unit-resolution| @x1719 @x1025 @x999 @x1207 $x436) $x594) $x676)))
+(let (($x1723 (or $x1611 $x955 $x956 $x1401 $x1373 $x1625 $x655 $x1139 $x1189 $x798 $x799 $x782 $x742 $x740 $x1374)))
+(let ((@x1725 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 1 -1 -1 1 1 -1 1 -2 2 -1 1 -1 1) $x1723) @x1253 @x797 @x851 @x701 @x1136 @x1256 @x685 @x1137 @x1722 @x1207 @x999 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x1715 $x642) $x1369) @x1385 @x1252 $x1611)))
+(let ((@x1726 (|unit-resolution| @x826 (|unit-resolution| @x597 (|unit-resolution| @x1719 @x1025 @x999 @x1207 $x436) $x594) $x667)))
+(let ((@x1729 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1 1 1) (or $x462 $x361 $x901 $x815 $x816 $x1402 $x1089 $x900 $x336)) @x1025 @x810 @x830 @x833 @x1527 @x897 @x1726 @x1366 $x462)))
+(let ((@x1733 (lemma (|unit-resolution| @x1619 (|unit-resolution| @x591 @x1729 $x587) @x1725 false) (or $x655 $x1139 $x798 $x955 $x361 $x336 $x815))))
+(let ((@x1760 (|unit-resolution| @x1277 (|unit-resolution| @x1733 @x1741 @x1187 @x1027 @x1736 @x1527 @x1477 $x655) @x1747 $x71)))
+(let ((@x1765 (|unit-resolution| @x691 (|unit-resolution| @x597 (|unit-resolution| @x1719 @x1736 @x1027 @x1187 $x436) $x594) $x676)))
+(let ((@x1766 ((_ |th-lemma| arith farkas -1 1 -1 -1 1 -1 1 1 -1 -1 1 -1 1 1) @x1765 (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1750 $x578) $x1237) @x1296 @x1187 @x797 @x1547 @x1125 (|unit-resolution| @x1166 (|unit-resolution| @x645 @x1744 $x642) $x662) @x713 (|unit-resolution| @x1733 @x1741 @x1187 @x1027 @x1736 @x1527 @x1477 $x655) @x685 @x701 @x1743 (|unit-resolution| @x1304 (|unit-resolution| @x577 @x1760 $x564) @x1758 $x1301) false)))
+(let ((@x1768 (lemma @x1766 (or $x336 $x387 $x412))))
+(let ((@x1829 (|unit-resolution| (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -2) (or $x873 $x1196 $x337)) @x1542 (or $x873 $x337)) (|unit-resolution| @x1768 @x1185 @x1815 $x336) $x873)))
+(let ((@x1820 (|unit-resolution| @x806 (|unit-resolution| @x613 @x1815 $x610) $x671)))
+(let ((@x1805 (hypothesis $x1139)))
+(let ((@x1807 (|unit-resolution| @x1556 @x1553 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1) (or $x658 $x286 $x1564)) @x1426 @x1805 $x1564) false)))
+(let ((@x1811 (|unit-resolution| @x637 (|unit-resolution| (lemma @x1807 (or $x286 $x658)) @x1805 $x286) $x634)))
+(let ((@x1813 (lemma (|unit-resolution| @x1149 @x1811 @x1805 false) $x658)))
+(let (($x1791 (or $x1586 $x815 $x816 $x704 $x741 $x1510 $x1197 $x1139 $x461 $x742 $x705 $x740 $x743)))
+(let ((@x1831 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 2 4 4 2 2 1 2 2 2 2 2) $x1791) @x810 @x696 @x701 @x1125 @x1813 @x685 (or $x1586 $x815 $x704 $x1510 $x461 $x705 $x743))))
+(let ((@x1833 (|unit-resolution| @x589 (|unit-resolution| @x1831 @x1820 @x1573 @x1826 @x1609 @x1477 @x1829 $x461) $x586)))
+(let ((@x1836 (|unit-resolution| @x1566 @x701 @x1136 @x696 (or $x311 $x1564 $x286 $x705 $x412 $x704))))
+(let ((@x1838 (|unit-resolution| @x645 (|unit-resolution| @x1836 @x1820 @x1557 @x1426 @x1185 @x1826 $x311) $x642)))
+(let ((@x1842 (|unit-resolution| (|unit-resolution| @x1669 @x1813 (or $x486 $x705 $x704 $x1373 $x708 $x412)) (|unit-resolution| @x1396 @x1838 $x1369) @x1263 @x1826 @x1820 @x1185 $x486)))
+(let ((@x1846 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 1 -1 -1 1 1 -1 -1 1) $x1587) @x810 @x696 @x1125 @x728 @x718 @x1284 (or $x652 $x1584 $x815 $x1510 $x704 $x869 $x1586))))
+(let ((@x1847 (|unit-resolution| @x1846 (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1842 $x578) $x1236) @x1573 @x1820 @x1477 (|unit-resolution| @x723 @x1833 $x679) @x1829 $x652)))
+(let ((@x1818 (|unit-resolution| @x1115 (|unit-resolution| @x629 (|unit-resolution| @x1768 @x1185 @x1815 $x336) $x626) $x665)))
+(let ((@x1821 ((_ |th-lemma| arith farkas -1 1/3 -1/3 4/3 1/3 -1/3 -1/3 1/3 1/3 -1/3 1/3 -2/3 2/3 2/3 -2/3 1/3 -1/3 1) @x701 @x1820 @x696 @x1185 @x1249 @x1252 @x1371 @x1256 @x1253 @x1623 @x1136 @x1187 @x797 @x1818 @x855 (hypothesis $x930) @x830 @x681 false)))
+(let ((@x1849 (|unit-resolution| (lemma @x1821 (or $x655 $x412 $x1260 $x1373 $x1564 $x1626 $x705)) @x1185 (|unit-resolution| @x1268 @x1833 $x670) (|unit-resolution| @x1396 @x1838 $x1369) @x1557 (hypothesis $x930) @x1826 $x655)))
+(let ((@x1852 (|unit-resolution| @x1304 (|unit-resolution| @x577 (|unit-resolution| @x1277 @x1849 @x1263 $x71) $x564) @x1847 $x1301)))
+(let ((@x1855 ((_ |th-lemma| arith farkas 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 1) @x701 @x1820 @x696 (|unit-resolution| @x1268 @x1833 $x670) @x1252 (|unit-resolution| @x1166 @x1838 $x662) @x713 @x1849 @x1557 @x1136 @x1609 @x685 (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1842 $x578) $x1237) @x1296 @x1852 @x1826 false)))
+(let ((@x1858 (|unit-resolution| (lemma @x1855 (or $x412 $x743 $x708 $x1626 $x286)) @x939 @x1263 @x964 @x1426 $x412)))
+(let ((@x1860 (|unit-resolution| @x997 (|unit-resolution| @x607 @x1858 $x603) $x931)))
+(let ((@x1861 (|unit-resolution| @x1037 (|unit-resolution| @x607 @x1858 $x603) $x1022)))
+(let ((@x1865 (|unit-resolution| @x863 (|unit-resolution| @x621 (|unit-resolution| @x1064 @x1858 $x361) $x618) $x838)))
+(let ((@x1868 (|unit-resolution| (|unit-resolution| @x1070 @x797 (or $x436 (not $x931) $x411 $x386)) @x1860 @x761 @x1858 $x386)))
+(let ((@x1874 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2 2 2 2 2) (or (not $x1022) $x798 $x336 $x1090 $x955 $x956 $x1089)) @x833 @x851 (or (not $x1022) $x798 $x336 $x1090 $x955))))
+(let ((@x1875 (|unit-resolution| @x1874 (|unit-resolution| @x948 (|unit-resolution| @x613 @x1868 $x610) $x934) @x1865 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x773 (not $x931) $x411)) @x1860 @x1858 $x773) @x1861 $x336)))
+(let ((@x1877 (|unit-resolution| @x1115 (|unit-resolution| @x629 @x1875 $x626) $x665)))
+(let ((@x1878 (|unit-resolution| @x924 (|unit-resolution| @x621 (|unit-resolution| @x1064 @x1858 $x361) $x618) $x668)))
+(let ((@x1879 (|unit-resolution| @x806 (|unit-resolution| @x613 @x1868 $x610) $x671)))
+(let (($x1000 (not $x931)))
+(let ((@x1881 ((_ |th-lemma| arith assign-bounds 2 2 1 1 1 1 1 1 1 1 1) (or $x311 $x705 $x740 $x704 $x741 $x1564 $x1189 $x436 $x799 $x858 $x1593 $x1000))))
+(let ((@x1882 (|unit-resolution| @x1881 @x761 @x696 @x701 @x855 @x1136 @x797 @x1879 @x1878 @x1877 @x1860 @x1557 $x311)))
+(let ((@x1887 (|unit-resolution| @x1268 (|unit-resolution| @x589 (|unit-resolution| @x1098 @x1858 $x461) $x586) $x670)))
+(let ((@x1888 (|unit-resolution| @x723 (|unit-resolution| @x589 (|unit-resolution| @x1098 @x1858 $x461) $x586) $x679)))
+(let ((@x1892 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2 2 2 2 2) (or (not $x1022) $x798 $x486 $x782 $x869 $x742 $x813)) @x685 @x718 (or (not $x1022) $x798 $x486 $x782 $x869))))
+(let ((@x1893 (|unit-resolution| @x1892 @x1861 @x942 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x773 $x1000 $x411)) @x1860 @x1858 $x773) @x1888 $x486)))
+(let (($x1078 (not $x1022)))
+(let (($x1896 (or $x652 $x1090 $x1089 $x955 $x956 $x869 $x813 $x1586 $x812 $x1584 $x1585 $x816 $x1196 $x1197 $x1078)))
+(let ((@x1898 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -2 1 -1 1 -1 -1 1 1 -1 1 1 -1 -1) $x1896) @x1888 @x810 @x851 @x833 @x1125 @x728 @x1284 @x718 (|unit-resolution| @x948 (|unit-resolution| @x613 @x1868 $x610) $x934) @x1865 @x1861 @x1542 @x1573 (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1893 $x578) $x1236) $x652)))
+(let (($x1900 (or $x651 $x705 $x740 $x704 $x741 $x1260 $x1401 $x1564 $x1189 $x1321 $x1591 $x799 $x858 $x1593 $x1000)))
+(let ((@x1902 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -2 1 -1 1 -1 -1 1 1 -1 1 1 -1 -1) $x1900) @x1879 @x797 @x696 @x701 @x855 @x1136 @x1296 @x1252 @x1878 @x1877 @x1887 @x1860 (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1893 $x578) $x1237) @x1557 $x651)))
+(let ((@x1905 (|unit-resolution| @x1277 (|unit-resolution| @x577 (|unit-resolution| @x1304 @x1902 @x1898 $x70) $x565) @x1263 $x764)))
+(let ((@x1906 ((_ |th-lemma| arith farkas -1 -1 -1 1 -3 3 -1 1 -1 1 1 -1 -2 -2 2 2 1) @x1256 @x1905 @x964 @x830 @x1878 @x701 @x1879 @x696 @x1887 @x1252 @x1557 @x1136 @x797 @x1877 @x855 @x1860 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x1882 $x642) $x1369) false)))
+(let ((@x1919 (|unit-resolution| @x597 (|unit-resolution| (lemma @x1906 (or $x436 $x708 $x286)) @x1426 @x1263 $x436) $x594)))
+(let ((@x1922 (|unit-resolution| @x1892 @x1038 (|unit-resolution| @x691 @x1919 $x676) @x1067 @x1131 $x486)))
+(let ((@x1925 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -2 1 -1 1 -1 -1 1 1 -1 1 1 -1 -1) $x1896) @x1917 @x810 @x851 @x833 @x1125 @x728 @x1284 @x718 @x1131 @x1087 @x1038 @x1542 @x1573 (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1922 $x578) $x1236) $x652)))
+(let ((@x1929 (|unit-resolution| @x629 (|unit-resolution| @x1874 @x1917 @x1087 @x1067 @x1038 $x336) $x626)))
+(let ((@x1931 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -2 1 -1 1 -1 -1 1 1 -1 1 1 -1 -1) $x1900) (|unit-resolution| @x1115 @x1929 $x665) @x797 @x696 @x701 @x855 @x1136 @x1296 @x1252 @x1086 (|unit-resolution| @x806 (|unit-resolution| @x613 @x1915 $x610) $x671) @x1269 @x998 (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1922 $x578) $x1237) @x1557 $x651)))
+(let ((@x1934 (|unit-resolution| @x1277 (|unit-resolution| @x577 (|unit-resolution| @x1304 @x1931 @x1925 $x70) $x565) @x1263 $x764)))
+(let ((@x1910 ((_ |th-lemma| arith farkas -1 -1 -1 1 -1 1 1 -1 1 -1 -1 1 1) @x1256 @x1253 @x898 @x830 @x1249 @x1252 @x1206 @x833 @x999 @x851 (hypothesis $x1543) @x728 (hypothesis $x1247) false)))
+(let ((@x1935 (|unit-resolution| (lemma @x1910 (or $x1259 $x655 $x901 $x1260 $x1090 $x955 $x1586)) @x1934 (|unit-resolution| @x826 @x1919 $x667) @x1269 @x1087 @x1917 @x1573 $x1259)))
+(let ((@x1938 (|unit-resolution| @x645 (|unit-resolution| @x647 (|unit-resolution| @x1310 @x1935 $x1119) $x311) $x642)))
+(let ((@x1940 ((_ |th-lemma| arith farkas -1 -1 -2 -1 1 -1 1 1 -1 1 -1 -1 1 1) @x1256 @x1934 (|unit-resolution| @x647 (|unit-resolution| @x1310 @x1935 $x1119) $x311) (|unit-resolution| @x826 @x1919 $x667) @x830 @x1269 @x1252 @x1087 @x833 @x1917 @x851 @x1573 @x728 (|unit-resolution| @x1396 @x1938 $x1369) false)))
+(let ((@x1943 (|unit-resolution| (lemma @x1940 (or $x411 $x708 $x286)) @x1426 @x1263 $x411)))
+(let ((@x1944 (|unit-resolution| @x1508 @x1943 $x386)))
+(let ((@x1948 (|unit-resolution| (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -2) (or $x873 $x1196 $x337)) @x1542 (or $x873 $x337)) (|unit-resolution| @x1768 @x1943 @x1944 $x336) $x873)))
+(let ((@x1950 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1 -1 1 1) (or $x1510 $x1197 $x387 $x1374 $x740 $x286)) @x1125 @x701 (or $x1510 $x387 $x1374 $x286))))
+(let ((@x1956 (|unit-resolution| @x924 (|unit-resolution| @x621 (|unit-resolution| @x1526 @x1944 @x1426 $x361) $x618) $x668)))
+(let ((@x1958 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -2 -2 2 -2 2) (or $x1354 $x705 $x437 $x815 $x816 $x704 $x741)) @x696 @x810 (or $x1354 $x705 $x437 $x815 $x704))))
+(let ((@x1959 (|unit-resolution| @x1958 @x1956 (|unit-resolution| @x789 (|unit-resolution| @x605 @x1943 $x602) $x774) (|unit-resolution| (lemma @x1906 (or $x436 $x708 $x286)) @x1426 @x1263 $x436) (|unit-resolution| @x1950 @x1948 @x1426 @x1944 $x1374) (|unit-resolution| @x806 (|unit-resolution| @x613 @x1944 $x610) $x671) false)))
+(let ((@x1992 (|unit-resolution| (lemma @x1959 (or $x286 $x708)) @x1263 $x286)))
+(let ((@x1240 (|unit-resolution| @x613 (|unit-resolution| @x1070 @x761 @x797 @x998 @x842 $x386) $x610)))
+(let ((@x1242 (|unit-resolution| @x1092 (|unit-resolution| @x948 @x1240 $x934) @x833 @x842 @x1087 @x851 $x336)))
+(let ((@x1244 (|unit-resolution| @x1115 (|unit-resolution| @x629 @x1242 $x626) (|unit-resolution| @x1102 @x761 @x842 @x1076 $x858) false)))
+(let ((@x1325 (|unit-resolution| @x597 (|unit-resolution| (lemma @x1244 (or $x436 $x411 $x287)) @x842 @x1076 $x436) $x594)))
+(let ((@x1265 (|unit-resolution| @x629 (|unit-resolution| @x1092 @x1110 @x833 @x842 @x1087 @x851 $x336) $x626)))
+(let ((@x1270 (|unit-resolution| @x860 (|unit-resolution| @x1115 @x1265 $x665) @x842 @x729 @x843 $x312)))
+(let ((@x1274 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1119 $x1247)) (|unit-resolution| @x647 @x1270 $x643) $x1247)))
+(let ((@x1275 (|unit-resolution| @x1262 @x1274 @x1086 @x1269 @x729 @x898 @x848 (|unit-resolution| @x1115 @x1265 $x665) $x655)))
+(let ((@x1287 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x486 $x813 $x411 $x782 $x742 $x869)) @x866 @x685 @x842 @x1131 @x718 $x486)))
+(let ((@x1293 ((_ |th-lemma| arith assign-bounds 1 -3/2 3/2 -1 1/2 -1/2 1/2 -1/2 -1 1 1/2 -1/2 -1/2 1/2 1/2 -1/2 1/2) (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1287 $x578) $x1236) @x718 @x1131 @x1284 @x1087 @x729 @x728 @x833 @x1038 @x810 @x848 @x851 (|unit-resolution| @x1159 (|unit-resolution| @x647 @x1270 $x643) $x1103) @x713 @x1275 @x685 @x866 $x652)))
+(let ((@x1300 ((_ |th-lemma| arith assign-bounds 1 -3/2 3/2 -1 1/2 -1/2 1/2 -1/2 -1 1 1/2 -1/2 -1/2 1/2 1/2 -1/2 1/2) (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1287 $x578) $x1237) @x1252 @x1269 @x1296 @x1086 @x1137 @x1136 @x701 @x998 @x797 @x1133 @x696 @x1274 @x1256 @x1263 @x830 @x898 $x651)))
+(let ((@x1305 (|unit-resolution| @x1304 @x1300 @x1293 (|unit-resolution| @x577 (|unit-resolution| @x1277 @x1275 @x1263 $x71) $x564) false)))
+(let ((@x1329 (|unit-resolution| (lemma @x1305 (or $x386 $x1139 $x708 $x901 (not $x659) $x782 $x411)) (|unit-resolution| @x826 @x1325 $x667) (|unit-resolution| @x1235 @x1076 $x656) @x1150 @x1145 (|unit-resolution| @x691 @x1325 $x676) @x842 $x386)))
+(let ((@x1331 (|unit-resolution| @x948 (|unit-resolution| @x613 @x1329 $x610) $x934)))
+(let ((@x1333 ((_ |th-lemma| arith assign-bounds 2 -1) (or $x778 $x387 $x955))))
+(let ((@x1336 (|unit-resolution| @x629 (|unit-resolution| @x1092 @x1331 @x833 @x842 @x1087 @x851 $x336) $x626)))
+(let ((@x1337 (|unit-resolution| @x1115 @x1336 $x665)))
+(let ((@x1313 (|unit-resolution| @x629 (|unit-resolution| @x1092 @x1027 @x833 @x842 @x1087 @x851 $x336) $x626)))
+(let ((@x1315 ((_ |th-lemma| arith farkas -1 -1 -1 1 -1 1 -1 1 1) @x1024 @x841 @x729 @x728 @x851 @x842 (|unit-resolution| @x1115 @x1313 $x665) @x855 @x1027 false)))
+(let ((@x1338 (|unit-resolution| (lemma @x1315 (or $x312 $x387 (not $x659) $x411)) @x1329 @x1145 @x842 $x312)))
+(let ((@x1341 (|unit-resolution| @x1262 (|unit-resolution| @x1310 (|unit-resolution| @x647 @x1338 $x643) $x1247) @x1337 @x1269 @x1145 (|unit-resolution| @x826 @x1325 $x667) (|unit-resolution| @x1333 @x1331 @x1329 $x778) @x1086 $x655)))
+(let ((@x1343 (|unit-resolution| @x577 (|unit-resolution| @x1277 @x1341 (|unit-resolution| @x1235 @x1076 $x656) $x71) $x564)))
+(let ((@x1344 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x486 $x813 $x411 $x782 $x742 $x869)) (|unit-resolution| @x691 @x1325 $x676) @x685 @x842 @x1131 @x718 $x486)))
+(let ((@x1320 ((_ |th-lemma| arith farkas 1 -1 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 1) @x681 @x701 @x856 @x855 @x697 @x1150 @x1136 @x696 (hypothesis $x1237) @x1252 @x1249 @x1296 @x1318 (hypothesis $x931) @x797 @x1076 false)))
+(let ((@x1323 (lemma @x1320 (or $x651 $x705 $x858 $x704 $x1321 $x1260 $x1000 $x287))))
+(let ((@x1348 (|unit-resolution| @x1323 @x1086 @x1337 (|unit-resolution| @x806 (|unit-resolution| @x613 @x1329 $x610) $x671) (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1344 $x578) $x1237) @x1269 @x998 @x1076 $x651)))
+(let ((@x1351 ((_ |th-lemma| arith farkas -1/2 1/2 -1/2 1/2 1/2 -1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1) @x1331 @x1145 @x728 @x851 @x1337 @x855 (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1344 $x578) $x1236) @x718 @x1131 @x1284 (|unit-resolution| @x1304 @x1348 @x1343 $x1302) @x1038 @x810 @x1329 false)))
+(let ((@x1353 (lemma @x1351 (or $x411 $x287))))
+(let ((@x1993 (|unit-resolution| @x1353 @x1992 $x411)))
+(let ((@x1994 (|unit-resolution| @x1508 @x1993 $x386)))
+(let ((@x1996 (|unit-resolution| @x948 (|unit-resolution| @x613 @x1994 $x610) $x934)))
+(let ((@x1998 (|unit-resolution| @x792 (|unit-resolution| @x605 @x1993 $x602) $x773)))
+(let ((@x1964 (|unit-resolution| @x613 (|unit-resolution| @x1508 (|unit-resolution| @x1353 @x1076 $x411) $x386) $x610)))
+(let ((@x1967 (|unit-resolution| @x789 (|unit-resolution| @x605 (|unit-resolution| @x1353 @x1076 $x411) $x602) $x774)))
+(let ((@x1970 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1 -1 1 1 -1 1 1 -1) (or $x704 $x741 $x311 $x1139 $x1189 $x815 $x1196 $x1197 $x437 $x816)) @x696 @x1125 @x1136 @x810 (or $x704 $x311 $x1139 $x815 $x1196 $x437))))
+(let ((@x1973 (|unit-resolution| (|unit-resolution| @x1970 @x1542 @x1813 (or $x704 $x311 $x815 $x437)) (|unit-resolution| @x1205 @x1188 @x1076 (|unit-resolution| @x1353 @x1076 $x411) $x436) @x1188 @x1967 (|unit-resolution| @x806 @x1964 $x671) false)))
+(let ((@x2008 (|unit-resolution| @x1115 (|unit-resolution| @x629 (|unit-resolution| @x1768 @x1993 @x1994 $x336) $x626) $x665)))
+(let ((@x2012 (|unit-resolution| @x1144 (|unit-resolution| @x637 @x1992 $x634) $x659)))
+(let ((@x2049 (lemma ((_ |th-lemma| arith farkas 1 -1 1 -1 -1 -1 1 -1 1 1) @x729 @x728 @x856 @x855 @x1207 @x761 @x797 @x999 @x851 @x841 false) (or $x436 (not $x659) $x858 $x798 $x955 $x312))))
+(let ((@x2050 (|unit-resolution| @x2049 @x2012 @x2008 @x1998 @x1996 (|unit-resolution| (lemma @x1973 (or $x311 $x287)) @x1992 $x311) $x436)))
+(let ((@x2000 (|unit-resolution| @x645 (|unit-resolution| (lemma @x1973 (or $x311 $x287)) @x1992 $x311) $x642)))
+(let ((@x2001 (|unit-resolution| @x1396 @x2000 $x1369)))
+(let ((@x2002 (|unit-resolution| @x1333 @x1996 @x1994 $x778)))
+(let ((@x2053 (|unit-resolution| @x806 (|unit-resolution| @x613 @x1994 $x610) $x671)))
+(let ((@x2006 (|unit-resolution| @x1768 @x1993 @x1994 $x336)))
+(let ((@x2027 (|unit-resolution| @x691 (|unit-resolution| @x597 (|unit-resolution| @x1719 @x1025 @x1996 @x1998 $x436) $x594) $x676)))
+(let ((@x2028 (|unit-resolution| @x826 (|unit-resolution| @x597 (|unit-resolution| @x1719 @x1025 @x1996 @x1998 $x436) $x594) $x667)))
+(let ((@x1982 (|unit-resolution| (|unit-resolution| @x1376 @x1813 (or $x655 $x1373 $x1104 $x901 $x1260 $x1374)) @x1253 @x1370 @x898 @x1248 @x1371 $x1260)))
+(let ((@x1984 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 1 -1 -1 1 1 -1 1 -2 2 -1 1 -1 1) $x1723) @x797 @x851 @x701 @x1136 @x1256 @x1813 @x685 @x1252 (or $x1611 $x955 $x1373 $x655 $x798 $x782 $x1374))))
+(let ((@x1986 (|unit-resolution| @x1619 (|unit-resolution| @x1984 @x1253 @x1370 @x866 @x1207 @x999 @x1371 $x1611) $x757)))
+(let ((@x1989 (|unit-resolution| @x1268 (|unit-resolution| @x589 (|unit-resolution| @x591 @x1986 $x461) $x586) @x1982 false)))
+(let ((@x1991 (lemma @x1989 (or $x655 $x1374 $x901 $x1104 $x1373 $x782 $x798 $x955))))
+(let ((@x2029 (|unit-resolution| @x1991 @x1385 @x2028 @x2002 @x2001 @x2027 @x1998 @x1996 $x655)))
+(let ((@x2009 (|unit-resolution| @x789 (|unit-resolution| @x605 @x1993 $x602) $x774)))
+(let ((@x2004 (|unit-resolution| @x1277 (|unit-resolution| @x1991 @x1370 @x898 @x2002 @x2001 @x866 @x1998 @x1996 $x655) @x1263 $x71)))
+(let ((@x2010 (|unit-resolution| @x1166 @x2000 $x662)))
+(let (($x731 (not $x659)))
+(let (($x814 (not $x648)))
+(let (($x2015 (or $x652 $x1585 $x732 $x814 $x764 $x901 $x1402 $x858 $x1593 $x815 $x816 $x900 $x1089 $x731 $x812 (not $x1367))))
+(let ((@x2017 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1 1 1 -1 1 -1 1 -1 1 1 -1 -2 2 1) $x2015) (|unit-resolution| @x1411 @x1441 $x1367) @x810 @x833 @x855 @x728 @x713 @x1284 (|unit-resolution| @x1991 @x1370 @x898 @x2002 @x2001 @x866 @x1998 @x1996 $x655) @x2012 @x2010 @x2009 @x2008 @x898 @x1366 @x830 $x652)))
+(let (($x2019 (or $x651 $x1591 $x1373 $x1625 $x708 $x782 $x742 $x1196 $x1197 $x798 $x799 $x1374 $x740 $x1139 $x1189 $x1437)))
+(let ((@x2021 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1 1 1 -1 1 -1 1 -1 1 1 -1 -2 2 1) $x2019) (|unit-resolution| @x1443 @x1441 $x1368) @x797 @x701 @x1125 @x1136 @x1256 @x1296 @x1263 @x1813 @x866 @x1998 @x1542 @x2001 @x1370 @x685 $x651)))
+(let ((@x2022 (|unit-resolution| @x1304 @x2021 @x2017 (|unit-resolution| @x577 @x2004 $x564) false)))
+(let ((@x2032 (|unit-resolution| (lemma @x2022 (or $x1409 $x708 $x782 $x1374 $x901)) @x2027 @x1263 @x1385 @x2028 $x1409)))
+(let ((@x2035 (|unit-resolution| @x1291 (|unit-resolution| @x581 (|unit-resolution| @x583 @x2032 $x486) $x578) $x1236)))
+(let ((@x2038 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -2 -2 2 2 -2 2) (or $x1500 $x858 $x487 $x732 $x814 $x764 $x731 $x812)) @x2029 @x713 @x728 @x2012 @x2010 @x2008 (|unit-resolution| @x583 @x2032 $x486) $x1500)))
+(let ((@x2040 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 1 -1 -1 1 -1 1 1 -1 -1 1 -1 1) $x1756) @x810 @x833 @x855 @x1256 @x1366 @x830 @x1284 (or $x652 $x901 $x1584 $x815 $x1592 $x1373 $x708))))
+(let ((@x2042 (|unit-resolution| @x1304 (|unit-resolution| @x2040 @x2038 @x2035 @x1263 @x2009 @x2028 @x2001 $x652) (|unit-resolution| @x577 (|unit-resolution| @x1277 @x2029 @x1263 $x71) $x564) $x1301)))
+(let ((@x2043 (|unit-resolution| @x1298 (|unit-resolution| @x581 (|unit-resolution| @x583 @x2032 $x486) $x578) $x1237)))
+(let ((@x2044 ((_ |th-lemma| arith farkas 1/2 -1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 1/2 -1/2 1) @x2010 @x713 @x2029 @x2043 @x1296 @x2042 @x2027 @x685 @x1542 @x1125 @x1998 @x797 @x1385 @x701 @x2006 false)))
+(let ((@x2055 (|unit-resolution| @x621 (|unit-resolution| (lemma @x2044 (or $x361 $x708)) @x1263 $x361) $x618)))
+(let ((@x1979 (lemma (|unit-resolution| @x924 (hypothesis $x618) (hypothesis $x705) false) (or (not $x618) $x668))))
+(let ((@x2056 (|unit-resolution| @x1979 @x2055 $x668)))
+(let ((@x2059 (|unit-resolution| @x1991 (|unit-resolution| @x826 (|unit-resolution| @x597 @x2050 $x594) $x667) (|unit-resolution| @x1958 @x2050 @x2009 @x2056 @x2053 $x1354) @x2002 @x2001 (|unit-resolution| @x691 (|unit-resolution| @x597 @x2050 $x594) $x676) @x1998 @x1996 $x655)))
+(let ((@x2061 (|unit-resolution| (|unit-resolution| @x1669 @x1813 (or $x486 $x705 $x704 $x1373 $x708 $x412)) @x2056 @x1263 @x2001 @x2053 @x1993 $x486)))
+(let ((@x2063 (|unit-resolution| @x589 (|unit-resolution| @x707 @x2050 @x2053 @x2006 @x2056 $x461) $x586)))
+(let ((@x2065 (|unit-resolution| @x1465 (|unit-resolution| @x1268 @x2063 $x670) @x2009 @x2012 @x2002 @x2061 @x2008 (|unit-resolution| @x826 (|unit-resolution| @x597 @x2050 $x594) $x667) $x652)))
+(let ((@x2071 (|unit-resolution| @x1323 (|unit-resolution| @x1268 @x2063 $x670) @x1992 @x2008 @x2053 (|unit-resolution| @x1298 (|unit-resolution| @x581 @x2061 $x578) $x1237) (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x931 $x412 $x798)) @x1998 @x1993 $x931) @x2056 $x651)))
+(let ((@x2073 (|unit-resolution| @x577 (|unit-resolution| @x1304 @x2071 @x2065 $x70) (|unit-resolution| @x1277 @x2059 @x1263 $x71) false)))
+(let ((@x2074 (lemma @x2073 $x708)))
+(let ((@x1771 (|unit-resolution| @x621 (|unit-resolution| @x1526 (|unit-resolution| @x1235 @x709 $x287) @x1024 $x361) $x618)))
+(let ((@x1772 (|unit-resolution| @x924 @x1771 $x668)))
+(let ((@x1773 (|unit-resolution| @x1768 @x1185 @x1024 $x336)))
+(let ((@x1769 (|unit-resolution| @x1235 @x709 $x287)))
+(let ((@x1776 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 1 -1 -1 1 -1 1) (or $x437 $x815 $x816 $x704 $x741 $x1196 $x337 $x286 $x1197)) @x1769 @x696 @x1773 @x1125 @x810 @x1734 @x1477 @x1542 $x437)))
+(let ((@x1782 (|unit-resolution| @x1566 (|unit-resolution| @x1556 (|unit-resolution| @x639 @x1769 $x635) $x1499) @x701 @x1185 @x1136 @x1769 @x1734 @x1772 @x696 $x311)))
+(let ((@x1790 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1) (or $x658 $x286 $x1564)) (|unit-resolution| @x1556 (|unit-resolution| @x639 @x1769 $x635) $x1499) @x1769 $x658)))
+(let ((@x1793 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 2 4 4 2 2 1 2 2 2 2 2) $x1791) (|unit-resolution| @x738 (|unit-resolution| @x599 @x1776 $x595) $x673) @x810 @x696 @x701 @x1125 @x1790 @x1734 @x1772 (|unit-resolution| @x1572 (|unit-resolution| @x639 @x1769 $x635) $x1543) @x1477 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -2) (or $x873 $x1196 $x337)) @x1773 @x1542 $x873) @x685 $x461)))
+(let ((@x1796 ((_ |th-lemma| arith farkas 4 -1 3 -3 -1 1 1 -1 -1 1 -1 2 -2 -2 2 -1 1 1) @x1773 @x701 @x1734 @x696 (|unit-resolution| @x723 (|unit-resolution| @x589 @x1793 $x586) $x679) @x718 (|unit-resolution| @x1166 (|unit-resolution| @x645 @x1782 $x642) $x662) @x713 @x709 (|unit-resolution| @x1572 (|unit-resolution| @x639 @x1769 $x635) $x1543) @x728 @x1477 @x810 @x1542 @x1125 (|unit-resolution| @x738 (|unit-resolution| @x599 @x1776 $x595) $x673) @x685 @x1772 false)))
+(let ((@x2081 (|unit-resolution| (lemma @x1796 (or $x656 $x412 $x387)) @x1815 @x1185 @x2074 false)))
+(let ((@x2082 (lemma @x2081 $x412)))
+(let ((@x2100 (|unit-resolution| @x863 (|unit-resolution| @x621 (|unit-resolution| @x1064 @x2082 $x361) $x618) $x838)))
+(let ((@x2117 (|unit-resolution| @x1572 (|unit-resolution| @x639 (|unit-resolution| @x1235 @x2074 $x287) $x635) $x1543)))
+(let ((@x2101 (|unit-resolution| (|unit-resolution| @x1429 @x1542 (or $x286 $x386 $x1090)) @x2100 (|unit-resolution| @x1235 @x2074 $x287) $x386)))
+(let ((@x2090 (|unit-resolution| @x1556 (|unit-resolution| @x639 (|unit-resolution| @x1235 @x2074 $x287) $x635) $x1499)))
+(let ((@x2078 (|unit-resolution| @x997 @x994 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x815 $x1000 $x411)) @x842 @x897 $x1000) false)))
+(let ((@x2097 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x774 $x773)) (|unit-resolution| (lemma @x2078 (or $x411 $x815)) @x2082 $x815) $x773)))
+(let ((@x2104 (|unit-resolution| @x1874 (|unit-resolution| @x948 (|unit-resolution| @x613 @x2101 $x610) $x934) @x2100 @x2097 (|unit-resolution| @x1037 (|unit-resolution| @x607 @x2082 $x603) $x1022) $x336)))
+(let ((@x2107 (|unit-resolution| @x1979 (|unit-resolution| @x621 (|unit-resolution| @x1064 @x2082 $x361) $x618) $x668)))
+(let ((@x2109 (|unit-resolution| @x1881 @x1188 @x696 @x701 @x855 @x1136 @x797 (|unit-resolution| @x806 (|unit-resolution| @x613 @x2101 $x610) $x671) @x2107 (|unit-resolution| @x1115 (|unit-resolution| @x629 @x2104 $x626) $x665) (|unit-resolution| @x997 (|unit-resolution| @x607 @x2082 $x603) $x931) @x2090 $x436)))
+(let ((@x2114 (|unit-resolution| @x723 (|unit-resolution| @x589 (|unit-resolution| @x1098 @x2082 $x461) $x586) $x679)))
+(let ((@x2115 ((_ |th-lemma| arith farkas 1 1 -1 -1 1 -1 -1 1 -1 -1 1 -1 1) @x1136 (|unit-resolution| @x806 (|unit-resolution| @x613 @x2101 $x610) $x671) @x696 @x2090 @x2107 @x701 @x2114 @x718 @x713 @x2074 @x685 (|unit-resolution| @x691 (|unit-resolution| @x597 @x2109 $x594) $x676) (|unit-resolution| @x1159 (|unit-resolution| @x647 @x1188 $x643) $x1103) false)))
+(let ((@x2119 (|unit-resolution| @x1166 (|unit-resolution| @x645 (lemma @x2115 $x311) $x642) $x662)))
+(let ((@x2120 ((_ |th-lemma| arith farkas 1 -1 1 -1 1 1 -1 -1 3 -3 2 -2 2 -2 1 -1 1) @x2114 @x718 @x728 @x2119 @x713 (|unit-resolution| @x948 (|unit-resolution| @x613 @x2101 $x610) $x934) @x851 @x2117 @x2100 @x833 @x1542 @x1125 @x810 (|unit-resolution| @x1037 (|unit-resolution| @x607 @x2082 $x603) $x1022) @x1609 @x685 @x2074 false)))
+(let ((@x2121 (lemma @x2120 $x743)))
+(let (($x736 (not $x595)))
+(let ((@x2125 (|unit-resolution| @x599 (lemma (|unit-resolution| @x738 (hypothesis $x595) @x2121 false) $x736) $x436)))
+(|unit-resolution| @x691 (|unit-resolution| @x597 @x2125 $x594) (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x673 $x437 $x782)) @x2125 @x2121 $x782) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
 
-6a3a89e24d8df556f7ea5217b40c76ff1c882fab 13 0
+8778062e40723924421e3a1f0c912b62e43b9b81 20 0
 unsat
 ((set-logic AUFLIRA)
 (proof
-(let (($x11 (< (+ |x$| |x$|) (+ (* 2.0 |x$|) 1.0))))
-(let (($x16 (not $x11)))
-(let (($x32 (not (<= (+ 1.0 (* 2.0 |x$|)) (* 2.0 |x$|)))))
-(let ((@x39 (rewrite (= (<= (+ 1.0 (* 2.0 |x$|)) (* 2.0 |x$|)) false))))
-(let ((@x45 (trans (monotonicity @x39 (= $x32 (not false))) (rewrite (= (not false) true)) (= $x32 true))))
-(let ((@x30 (monotonicity (rewrite (= (+ |x$| |x$|) (* 2.0 |x$|))) (rewrite (= (+ (* 2.0 |x$|) 1.0) (+ 1.0 (* 2.0 |x$|)))) (= $x11 (< (* 2.0 |x$|) (+ 1.0 (* 2.0 |x$|)))))))
-(let ((@x36 (trans @x30 (rewrite (= (< (* 2.0 |x$|) (+ 1.0 (* 2.0 |x$|))) $x32)) (= $x11 $x32))))
-(let ((@x50 (monotonicity (trans @x36 @x45 (= $x11 true)) (= $x16 (not true)))))
-(mp (|not-or-elim| (asserted (not (or $x11 (or false $x11)))) $x16) (trans @x50 (rewrite (= (not true) false)) (= $x16 false)) false)))))))))))
+(let ((?x8 (* 2.0 |x$|)))
+(let ((?x10 (+ ?x8 1.0)))
+(let ((?x6 (+ |x$| |x$|)))
+(let (($x11 (< ?x6 ?x10)))
+(let (($x12 (or false $x11)))
+(let (($x13 (or $x11 $x12)))
+(let (($x14 (not $x13)))
+(let ((@x65 (monotonicity (rewrite (= (< ?x8 (+ 1.0 ?x8)) true)) (= (not (< ?x8 (+ 1.0 ?x8))) (not true)))))
+(let ((@x69 (trans @x65 (rewrite (= (not true) false)) (= (not (< ?x8 (+ 1.0 ?x8))) false))))
+(let ((?x38 (+ 1.0 ?x8)))
+(let (($x41 (< ?x8 ?x38)))
+(let ((@x43 (monotonicity (rewrite (= ?x6 ?x8)) (rewrite (= ?x10 ?x38)) (= $x11 $x41))))
+(let ((@x50 (trans (monotonicity @x43 (= $x12 (or false $x41))) (rewrite (= (or false $x41) $x41)) (= $x12 $x41))))
+(let ((@x57 (trans (monotonicity @x43 @x50 (= $x13 (or $x41 $x41))) (rewrite (= (or $x41 $x41) $x41)) (= $x13 $x41))))
+(let ((@x60 (monotonicity @x57 (= $x14 (not $x41)))))
+(mp (asserted $x14) (trans @x60 @x69 (= $x14 false)) false))))))))))))))))))
 
-b3a64ab4fe7d5720729351a375772727b97cece2 81 0
+bbf5431bd7e9448dc98de52e9b465f05ca123636 113 0
 unsat
 ((set-logic <null>)
 (proof
-(let (($x591 (= (+ (|mod$| |x$| 2) (* (~ 1) (mod |x$| 2))) 0)))
-(let (($x607 (forall ((?v0 Int) (?v1 Int) )(!(let (($x68 (<= ?v1 0)))
-(let (($x178 (ite $x68 (= (+ (|mod$| ?v0 ?v1) (mod (* (~ 1) ?v0) (* (~ 1) ?v1))) 0) (= (+ (|mod$| ?v0 ?v1) (* (~ 1) (mod ?v0 ?v1))) 0))))
+(let ((?x215 (mod |x$| 2)))
+(let ((?x249 (* (~ 1) ?x215)))
+(let ((?x9 (|mod$| |x$| 2)))
+(let ((?x250 (+ ?x9 ?x249)))
+(let (($x267 (>= ?x250 0)))
+(let (($x251 (= ?x250 0)))
+(let (($x203 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x30 (mod ?v0 ?v1)))
+(let ((?x99 (* (~ 1) ?v1)))
+(let ((?x96 (* (~ 1) ?v0)))
+(let ((?x142 (mod ?x96 ?x99)))
+(let ((?x148 (* (~ 1) ?x142)))
+(let (($x117 (<= ?v1 0)))
+(let ((?x168 (ite $x117 ?x148 ?x30)))
 (let (($x19 (= ?v1 0)))
-(ite $x19 (= (|mod$| ?v0 ?v1) ?v0) $x178)))) :pattern ( (|mod$| ?v0 ?v1) )))
-))
-(let (($x182 (forall ((?v0 Int) (?v1 Int) )(let (($x68 (<= ?v1 0)))
-(let (($x178 (ite $x68 (= (+ (|mod$| ?v0 ?v1) (mod (* (~ 1) ?v0) (* (~ 1) ?v1))) 0) (= (+ (|mod$| ?v0 ?v1) (* (~ 1) (mod ?v0 ?v1))) 0))))
-(let (($x19 (= ?v1 0)))
-(ite $x19 (= (|mod$| ?v0 ?v1) ?v0) $x178)))))
+(let ((?x173 (ite $x19 ?v0 ?x168)))
+(let ((?x29 (|mod$| ?v0 ?v1)))
+(= ?x29 ?x173))))))))))) :pattern ( (|mod$| ?v0 ?v1) )))
 ))
-(let (($x68 (<= ?0 0)))
-(let (($x178 (ite $x68 (= (+ (|mod$| ?1 ?0) (mod (* (~ 1) ?1) (* (~ 1) ?0))) 0) (= (+ (|mod$| ?1 ?0) (* (~ 1) (mod ?1 ?0))) 0))))
-(let (($x19 (= ?0 0)))
-(let (($x179 (ite $x19 (= (|mod$| ?1 ?0) ?1) $x178)))
-(let (($x125 (forall ((?v0 Int) (?v1 Int) )(let ((?x30 (mod ?v0 ?v1)))
-(let ((?x100 (mod (* (~ 1) ?v0) (* (~ 1) ?v1))))
-(let ((?x106 (* (~ 1) ?x100)))
-(let (($x68 (<= ?v1 0)))
-(let ((?x114 (ite $x68 ?x106 ?x30)))
+(let (($x179 (forall ((?v0 Int) (?v1 Int) )(let ((?x30 (mod ?v0 ?v1)))
+(let ((?x99 (* (~ 1) ?v1)))
+(let ((?x96 (* (~ 1) ?v0)))
+(let ((?x142 (mod ?x96 ?x99)))
+(let ((?x148 (* (~ 1) ?x142)))
+(let (($x117 (<= ?v1 0)))
+(let ((?x168 (ite $x117 ?x148 ?x30)))
 (let (($x19 (= ?v1 0)))
+(let ((?x173 (ite $x19 ?v0 ?x168)))
 (let ((?x29 (|mod$| ?v0 ?v1)))
-(= ?x29 (ite $x19 ?v0 ?x114))))))))))
+(= ?x29 ?x173))))))))))))
 ))
 (let ((?x30 (mod ?1 ?0)))
-(let ((?x100 (mod (* (~ 1) ?1) (* (~ 1) ?0))))
-(let ((?x106 (* (~ 1) ?x100)))
-(let ((?x114 (ite $x68 ?x106 ?x30)))
+(let ((?x99 (* (~ 1) ?0)))
+(let ((?x96 (* (~ 1) ?1)))
+(let ((?x142 (mod ?x96 ?x99)))
+(let ((?x148 (* (~ 1) ?x142)))
+(let (($x117 (<= ?0 0)))
+(let ((?x168 (ite $x117 ?x148 ?x30)))
+(let (($x19 (= ?0 0)))
+(let ((?x173 (ite $x19 ?1 ?x168)))
 (let ((?x29 (|mod$| ?1 ?0)))
-(let (($x122 (= ?x29 (ite $x19 ?1 ?x114))))
-(let (($x36 (forall ((?v0 Int) (?v1 Int) )(let ((?x32 (- (mod (- ?v0) (- ?v1)))))
+(let (($x176 (= ?x29 ?x173)))
+(let (($x36 (forall ((?v0 Int) (?v1 Int) )(let (($x19 (= ?v1 0)))
+(let ((?x34 (ite $x19 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
+(let ((?x29 (|mod$| ?v0 ?v1)))
+(= ?x29 ?x34)))))
+))
+(let (($x162 (forall ((?v0 Int) (?v1 Int) )(let ((?x99 (* (~ 1) ?v1)))
+(let ((?x96 (* (~ 1) ?v0)))
+(let ((?x142 (mod ?x96 ?x99)))
+(let ((?x148 (* (~ 1) ?x142)))
 (let ((?x30 (mod ?v0 ?v1)))
 (let (($x20 (< 0 ?v1)))
-(let ((?x33 (ite $x20 ?x30 ?x32)))
+(let ((?x153 (ite $x20 ?x30 ?x148)))
 (let (($x19 (= ?v1 0)))
+(let ((?x156 (ite $x19 ?v0 ?x153)))
 (let ((?x29 (|mod$| ?v0 ?v1)))
-(= ?x29 (ite $x19 ?v0 ?x33)))))))))
+(= ?x29 ?x156))))))))))))
 ))
-(let ((?x32 (- (mod (- ?1) (- ?0)))))
+(let ((@x167 (monotonicity (rewrite (= (< 0 ?0) (not $x117))) (= (ite (< 0 ?0) ?x30 ?x148) (ite (not $x117) ?x30 ?x148)))))
+(let ((@x172 (trans @x167 (rewrite (= (ite (not $x117) ?x30 ?x148) ?x168)) (= (ite (< 0 ?0) ?x30 ?x148) ?x168))))
+(let ((@x175 (monotonicity @x172 (= (ite $x19 ?1 (ite (< 0 ?0) ?x30 ?x148)) ?x173))))
+(let ((@x178 (monotonicity @x175 (= (= ?x29 (ite $x19 ?1 (ite (< 0 ?0) ?x30 ?x148))) $x176))))
 (let (($x20 (< 0 ?0)))
-(let ((?x33 (ite $x20 ?x30 ?x32)))
-(let ((@x102 (monotonicity (rewrite (= (- ?1) (* (~ 1) ?1))) (rewrite (= (- ?0) (* (~ 1) ?0))) (= (mod (- ?1) (- ?0)) ?x100))))
-(let ((@x110 (trans (monotonicity @x102 (= ?x32 (- ?x100))) (rewrite (= (- ?x100) ?x106)) (= ?x32 ?x106))))
-(let ((@x113 (monotonicity (rewrite (= $x20 (not $x68))) @x110 (= ?x33 (ite (not $x68) ?x30 ?x106)))))
-(let ((@x118 (trans @x113 (rewrite (= (ite (not $x68) ?x30 ?x106) ?x114)) (= ?x33 ?x114))))
-(let ((@x124 (monotonicity (monotonicity @x118 (= (ite $x19 ?1 ?x33) (ite $x19 ?1 ?x114))) (= (= ?x29 (ite $x19 ?1 ?x33)) $x122))))
-(let ((@x156 (|mp~| (mp (asserted $x36) (|quant-intro| @x124 (= $x36 $x125)) $x125) (|nnf-pos| (refl (|~| $x122 $x122)) (|~| $x125 $x125)) $x125)))
-(let ((@x185 (mp @x156 (|quant-intro| (rewrite (= $x122 $x179)) (= $x125 $x182)) $x182)))
-(let (($x583 (or (not $x607) $x591)))
-(let (($x275 (= (+ (|mod$| |x$| 2) (mod (* (~ 1) |x$|) (* (~ 1) 2))) 0)))
-(let (($x592 (ite (<= 2 0) $x275 $x591)))
-(let (($x248 (ite (= 2 0) (= (|mod$| |x$| 2) |x$|) $x592)))
-(let (($x233 (ite false (= (+ (|mod$| |x$| 2) (mod (* (~ 1) |x$|) (~ 2))) 0) $x591)))
-(let (($x254 (= $x275 (= (+ (|mod$| |x$| 2) (mod (* (~ 1) |x$|) (~ 2))) 0))))
-(let (($x251 (= (+ (|mod$| |x$| 2) (mod (* (~ 1) |x$|) (* (~ 1) 2))) (+ (|mod$| |x$| 2) (mod (* (~ 1) |x$|) (~ 2))))))
-(let ((@x598 (monotonicity (rewrite (= (* (~ 1) 2) (~ 2))) (= (mod (* (~ 1) |x$|) (* (~ 1) 2)) (mod (* (~ 1) |x$|) (~ 2))))))
-(let ((@x236 (monotonicity (rewrite (= (<= 2 0) false)) (monotonicity (monotonicity @x598 $x251) $x254) (= $x592 $x233))))
-(let ((@x578 (monotonicity (rewrite (= (= 2 0) false)) (trans @x236 (rewrite (= $x233 $x591)) (= $x592 $x591)) (= $x248 (ite false (= (|mod$| |x$| 2) |x$|) $x591)))))
-(let ((@x219 (trans @x578 (rewrite (= (ite false (= (|mod$| |x$| 2) |x$|) $x591) $x591)) (= $x248 $x591))))
-(let ((@x573 (trans (monotonicity @x219 (= (or (not $x607) $x248) $x583)) (rewrite (= $x583 $x583)) (= (or (not $x607) $x248) $x583))))
-(let ((@x416 (|unit-resolution| (mp ((_ |quant-inst| |x$| 2) (or (not $x607) $x248)) @x573 $x583) (mp @x185 (|quant-intro| (refl (= $x179 $x179)) (= $x182 $x607)) $x607) $x591)))
-(let (($x418 (or (not $x591) (>= (+ (|mod$| |x$| 2) (* (~ 1) (mod |x$| 2))) 0))))
-(let ((@x528 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) $x418) @x416 (>= (+ (|mod$| |x$| 2) (* (~ 1) (mod |x$| 2))) 0))))
-(let ((@x530 (|unit-resolution| ((_ |th-lemma| arith) (or false (>= (mod |x$| 2) 0))) (|true-axiom| true) (>= (mod |x$| 2) 0))))
-(let ((?x12 (+ |x$| (+ (* 2 (|mod$| |x$| 2)) 1))))
-(let (($x13 (<= (+ |x$| 1) ?x12)))
-(let (($x14 (not $x13)))
-(let ((?x9 (|mod$| |x$| 2)))
-(let (($x59 (>= ?x9 0)))
-(let ((@x61 (rewrite (= (<= (+ 1 |x$|) (+ 1 |x$| (* 2 ?x9))) $x59))))
+(let ((?x153 (ite $x20 ?x30 ?x148)))
+(let ((?x156 (ite $x19 ?1 ?x153)))
+(let (($x159 (= ?x29 ?x156)))
+(let (($x160 (= (= ?x29 (ite $x19 ?1 (ite $x20 ?x30 (- (mod (- ?1) (- ?0)))))) $x159)))
+(let ((@x144 (monotonicity (rewrite (= (- ?1) ?x96)) (rewrite (= (- ?0) ?x99)) (= (mod (- ?1) (- ?0)) ?x142))))
+(let ((@x152 (trans (monotonicity @x144 (= (- (mod (- ?1) (- ?0))) (- ?x142))) (rewrite (= (- ?x142) ?x148)) (= (- (mod (- ?1) (- ?0))) ?x148))))
+(let ((@x155 (monotonicity @x152 (= (ite $x20 ?x30 (- (mod (- ?1) (- ?0)))) ?x153))))
+(let ((@x158 (monotonicity @x155 (= (ite $x19 ?1 (ite $x20 ?x30 (- (mod (- ?1) (- ?0))))) ?x156))))
+(let ((@x183 (trans (|quant-intro| (monotonicity @x158 $x160) (= $x36 $x162)) (|quant-intro| @x178 (= $x162 $x179)) (= $x36 $x179))))
+(let ((@x194 (|mp~| (mp (asserted $x36) @x183 $x179) (|nnf-pos| (refl (|~| $x176 $x176)) (|~| $x179 $x179)) $x179)))
+(let ((@x208 (mp @x194 (|quant-intro| (refl (= $x176 $x176)) (= $x179 $x203)) $x203)))
+(let (($x257 (or (not $x203) $x251)))
+(let ((?x212 (* (~ 1) 2)))
+(let ((?x211 (* (~ 1) |x$|)))
+(let ((?x213 (mod ?x211 ?x212)))
+(let ((?x214 (* (~ 1) ?x213)))
+(let (($x210 (<= 2 0)))
+(let ((?x216 (ite $x210 ?x214 ?x215)))
+(let (($x209 (= 2 0)))
+(let ((?x217 (ite $x209 |x$| ?x216)))
+(let (($x218 (= ?x9 ?x217)))
+(let ((@x231 (monotonicity (monotonicity (rewrite (= ?x212 (~ 2))) (= ?x213 (mod ?x211 (~ 2)))) (= ?x214 (* (~ 1) (mod ?x211 (~ 2)))))))
+(let ((@x234 (monotonicity (rewrite (= $x210 false)) @x231 (= ?x216 (ite false (* (~ 1) (mod ?x211 (~ 2))) ?x215)))))
+(let ((@x238 (trans @x234 (rewrite (= (ite false (* (~ 1) (mod ?x211 (~ 2))) ?x215) ?x215)) (= ?x216 ?x215))))
+(let ((@x241 (monotonicity (rewrite (= $x209 false)) @x238 (= ?x217 (ite false |x$| ?x215)))))
+(let ((@x248 (monotonicity (trans @x241 (rewrite (= (ite false |x$| ?x215) ?x215)) (= ?x217 ?x215)) (= $x218 (= ?x9 ?x215)))))
+(let ((@x261 (monotonicity (trans @x248 (rewrite (= (= ?x9 ?x215) $x251)) (= $x218 $x251)) (= (or (not $x203) $x218) $x257))))
+(let ((@x264 (trans @x261 (rewrite (= $x257 $x257)) (= (or (not $x203) $x218) $x257))))
+(let ((@x265 (mp ((_ |quant-inst| |x$| 2) (or (not $x203) $x218)) @x264 $x257)))
+(let ((@x324 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x251) $x267)) (|unit-resolution| @x265 @x208 $x251) $x267)))
+(let (($x292 (>= ?x215 0)))
+(let (($x83 (>= ?x9 0)))
+(let (($x86 (not $x83)))
+(let (($x14 (not (<= (+ |x$| 1) (+ |x$| (+ (* 2 ?x9) 1))))))
+(let ((@x88 (monotonicity (rewrite (= (>= (* 2 ?x9) 0) $x83)) (= (not (>= (* 2 ?x9) 0)) $x86))))
 (let ((?x10 (* 2 ?x9)))
-(let ((?x51 (+ 1 |x$| ?x10)))
-(let ((@x50 (monotonicity (rewrite (= (+ ?x10 1) (+ 1 ?x10))) (= ?x12 (+ |x$| (+ 1 ?x10))))))
-(let ((@x55 (trans @x50 (rewrite (= (+ |x$| (+ 1 ?x10)) ?x51)) (= ?x12 ?x51))))
-(let ((@x58 (monotonicity (rewrite (= (+ |x$| 1) (+ 1 |x$|))) @x55 (= $x13 (<= (+ 1 |x$|) ?x51)))))
-(let ((@x66 (monotonicity (trans @x58 @x61 (= $x13 $x59)) (= $x14 (not $x59)))))
-((_ |th-lemma| arith farkas -1 1 1) (mp (asserted $x14) @x66 (not $x59)) @x530 @x528 false))))))))))))))))))))))))))))))))))))))))))))))))))))))))
+(let ((?x66 (+ 1 |x$| ?x10)))
+(let (($x71 (<= (+ 1 |x$|) ?x66)))
+(let (($x74 (not $x71)))
+(let ((@x82 (monotonicity (rewrite (= $x71 (>= ?x10 0))) (= $x74 (not (>= ?x10 0))))))
+(let ((@x65 (monotonicity (rewrite (= (+ ?x10 1) (+ 1 ?x10))) (= (+ |x$| (+ ?x10 1)) (+ |x$| (+ 1 ?x10))))))
+(let ((@x70 (trans @x65 (rewrite (= (+ |x$| (+ 1 ?x10)) ?x66)) (= (+ |x$| (+ ?x10 1)) ?x66))))
+(let ((@x73 (monotonicity (rewrite (= (+ |x$| 1) (+ 1 |x$|))) @x70 (= (<= (+ |x$| 1) (+ |x$| (+ ?x10 1))) $x71))))
+(let ((@x92 (trans (monotonicity @x73 (= $x14 $x74)) (trans @x82 @x88 (= $x74 $x86)) (= $x14 $x86))))
+(let ((@x93 (mp (asserted $x14) @x92 $x86)))
+((_ |th-lemma| arith farkas -1 1 1) @x93 (|unit-resolution| ((_ |th-lemma| arith) (or false $x292)) (|true-axiom| true) $x292) @x324 false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
 
-f204450f48b701dc1991b41c92d8f0455c6a933e 80 0
+b5183bee77d63a5b887fd6f1c6035b47d90e65cb 112 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((@x426 (|unit-resolution| ((_ |th-lemma| arith) (or false (not (>= (mod |x$| 2) 2)))) (|true-axiom| true) (not (>= (mod |x$| 2) 2)))))
-(let (($x599 (= (+ (|mod$| |x$| 2) (* (~ 1) (mod |x$| 2))) 0)))
-(let (($x615 (forall ((?v0 Int) (?v1 Int) )(!(let (($x75 (<= ?v1 0)))
-(let (($x185 (ite $x75 (= (+ (|mod$| ?v0 ?v1) (mod (* (~ 1) ?v0) (* (~ 1) ?v1))) 0) (= (+ (|mod$| ?v0 ?v1) (* (~ 1) (mod ?v0 ?v1))) 0))))
+(let ((?x211 (mod |x$| 2)))
+(let (($x305 (>= ?x211 2)))
+(let (($x306 (not $x305)))
+(let ((?x245 (* (~ 1) ?x211)))
+(let ((?x7 (|mod$| |x$| 2)))
+(let ((?x246 (+ ?x7 ?x245)))
+(let (($x262 (<= ?x246 0)))
+(let (($x247 (= ?x246 0)))
+(let (($x199 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x29 (mod ?v0 ?v1)))
+(let ((?x95 (* (~ 1) ?v1)))
+(let ((?x92 (* (~ 1) ?v0)))
+(let ((?x138 (mod ?x92 ?x95)))
+(let ((?x144 (* (~ 1) ?x138)))
+(let (($x113 (<= ?v1 0)))
+(let ((?x164 (ite $x113 ?x144 ?x29)))
 (let (($x18 (= ?v1 0)))
-(ite $x18 (= (|mod$| ?v0 ?v1) ?v0) $x185)))) :pattern ( (|mod$| ?v0 ?v1) )))
-))
-(let (($x189 (forall ((?v0 Int) (?v1 Int) )(let (($x75 (<= ?v1 0)))
-(let (($x185 (ite $x75 (= (+ (|mod$| ?v0 ?v1) (mod (* (~ 1) ?v0) (* (~ 1) ?v1))) 0) (= (+ (|mod$| ?v0 ?v1) (* (~ 1) (mod ?v0 ?v1))) 0))))
-(let (($x18 (= ?v1 0)))
-(ite $x18 (= (|mod$| ?v0 ?v1) ?v0) $x185)))))
+(let ((?x169 (ite $x18 ?v0 ?x164)))
+(let ((?x28 (|mod$| ?v0 ?v1)))
+(= ?x28 ?x169))))))))))) :pattern ( (|mod$| ?v0 ?v1) )))
 ))
-(let (($x75 (<= ?0 0)))
-(let (($x185 (ite $x75 (= (+ (|mod$| ?1 ?0) (mod (* (~ 1) ?1) (* (~ 1) ?0))) 0) (= (+ (|mod$| ?1 ?0) (* (~ 1) (mod ?1 ?0))) 0))))
-(let (($x18 (= ?0 0)))
-(let (($x186 (ite $x18 (= (|mod$| ?1 ?0) ?1) $x185)))
-(let (($x132 (forall ((?v0 Int) (?v1 Int) )(let ((?x29 (mod ?v0 ?v1)))
-(let ((?x107 (mod (* (~ 1) ?v0) (* (~ 1) ?v1))))
-(let ((?x113 (* (~ 1) ?x107)))
-(let (($x75 (<= ?v1 0)))
-(let ((?x121 (ite $x75 ?x113 ?x29)))
+(let (($x175 (forall ((?v0 Int) (?v1 Int) )(let ((?x29 (mod ?v0 ?v1)))
+(let ((?x95 (* (~ 1) ?v1)))
+(let ((?x92 (* (~ 1) ?v0)))
+(let ((?x138 (mod ?x92 ?x95)))
+(let ((?x144 (* (~ 1) ?x138)))
+(let (($x113 (<= ?v1 0)))
+(let ((?x164 (ite $x113 ?x144 ?x29)))
 (let (($x18 (= ?v1 0)))
+(let ((?x169 (ite $x18 ?v0 ?x164)))
 (let ((?x28 (|mod$| ?v0 ?v1)))
-(= ?x28 (ite $x18 ?v0 ?x121))))))))))
+(= ?x28 ?x169))))))))))))
 ))
 (let ((?x29 (mod ?1 ?0)))
-(let ((?x107 (mod (* (~ 1) ?1) (* (~ 1) ?0))))
-(let ((?x113 (* (~ 1) ?x107)))
-(let ((?x121 (ite $x75 ?x113 ?x29)))
+(let ((?x95 (* (~ 1) ?0)))
+(let ((?x92 (* (~ 1) ?1)))
+(let ((?x138 (mod ?x92 ?x95)))
+(let ((?x144 (* (~ 1) ?x138)))
+(let (($x113 (<= ?0 0)))
+(let ((?x164 (ite $x113 ?x144 ?x29)))
+(let (($x18 (= ?0 0)))
+(let ((?x169 (ite $x18 ?1 ?x164)))
 (let ((?x28 (|mod$| ?1 ?0)))
-(let (($x129 (= ?x28 (ite $x18 ?1 ?x121))))
-(let (($x35 (forall ((?v0 Int) (?v1 Int) )(let ((?x31 (- (mod (- ?v0) (- ?v1)))))
+(let (($x172 (= ?x28 ?x169)))
+(let (($x35 (forall ((?v0 Int) (?v1 Int) )(let (($x18 (= ?v1 0)))
+(let ((?x33 (ite $x18 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
+(let ((?x28 (|mod$| ?v0 ?v1)))
+(= ?x28 ?x33)))))
+))
+(let (($x158 (forall ((?v0 Int) (?v1 Int) )(let ((?x95 (* (~ 1) ?v1)))
+(let ((?x92 (* (~ 1) ?v0)))
+(let ((?x138 (mod ?x92 ?x95)))
+(let ((?x144 (* (~ 1) ?x138)))
 (let ((?x29 (mod ?v0 ?v1)))
 (let (($x19 (< 0 ?v1)))
-(let ((?x32 (ite $x19 ?x29 ?x31)))
+(let ((?x149 (ite $x19 ?x29 ?x144)))
 (let (($x18 (= ?v1 0)))
+(let ((?x152 (ite $x18 ?v0 ?x149)))
 (let ((?x28 (|mod$| ?v0 ?v1)))
-(= ?x28 (ite $x18 ?v0 ?x32)))))))))
+(= ?x28 ?x152))))))))))))
 ))
-(let ((?x31 (- (mod (- ?1) (- ?0)))))
+(let ((@x163 (monotonicity (rewrite (= (< 0 ?0) (not $x113))) (= (ite (< 0 ?0) ?x29 ?x144) (ite (not $x113) ?x29 ?x144)))))
+(let ((@x168 (trans @x163 (rewrite (= (ite (not $x113) ?x29 ?x144) ?x164)) (= (ite (< 0 ?0) ?x29 ?x144) ?x164))))
+(let ((@x171 (monotonicity @x168 (= (ite $x18 ?1 (ite (< 0 ?0) ?x29 ?x144)) ?x169))))
+(let ((@x174 (monotonicity @x171 (= (= ?x28 (ite $x18 ?1 (ite (< 0 ?0) ?x29 ?x144))) $x172))))
 (let (($x19 (< 0 ?0)))
-(let ((?x32 (ite $x19 ?x29 ?x31)))
-(let ((@x109 (monotonicity (rewrite (= (- ?1) (* (~ 1) ?1))) (rewrite (= (- ?0) (* (~ 1) ?0))) (= (mod (- ?1) (- ?0)) ?x107))))
-(let ((@x117 (trans (monotonicity @x109 (= ?x31 (- ?x107))) (rewrite (= (- ?x107) ?x113)) (= ?x31 ?x113))))
-(let ((@x120 (monotonicity (rewrite (= $x19 (not $x75))) @x117 (= ?x32 (ite (not $x75) ?x29 ?x113)))))
-(let ((@x125 (trans @x120 (rewrite (= (ite (not $x75) ?x29 ?x113) ?x121)) (= ?x32 ?x121))))
-(let ((@x131 (monotonicity (monotonicity @x125 (= (ite $x18 ?1 ?x32) (ite $x18 ?1 ?x121))) (= (= ?x28 (ite $x18 ?1 ?x32)) $x129))))
-(let ((@x163 (|mp~| (mp (asserted $x35) (|quant-intro| @x131 (= $x35 $x132)) $x132) (|nnf-pos| (refl (|~| $x129 $x129)) (|~| $x132 $x132)) $x132)))
-(let ((@x192 (mp @x163 (|quant-intro| (rewrite (= $x129 $x186)) (= $x132 $x189)) $x189)))
-(let (($x591 (or (not $x615) $x599)))
-(let (($x283 (= (+ (|mod$| |x$| 2) (mod (* (~ 1) |x$|) (* (~ 1) 2))) 0)))
-(let (($x600 (ite (<= 2 0) $x283 $x599)))
-(let (($x256 (ite (= 2 0) (= (|mod$| |x$| 2) |x$|) $x600)))
-(let (($x241 (ite false (= (+ (|mod$| |x$| 2) (mod (* (~ 1) |x$|) (~ 2))) 0) $x599)))
-(let (($x262 (= $x283 (= (+ (|mod$| |x$| 2) (mod (* (~ 1) |x$|) (~ 2))) 0))))
-(let (($x259 (= (+ (|mod$| |x$| 2) (mod (* (~ 1) |x$|) (* (~ 1) 2))) (+ (|mod$| |x$| 2) (mod (* (~ 1) |x$|) (~ 2))))))
-(let ((@x606 (monotonicity (rewrite (= (* (~ 1) 2) (~ 2))) (= (mod (* (~ 1) |x$|) (* (~ 1) 2)) (mod (* (~ 1) |x$|) (~ 2))))))
-(let ((@x244 (monotonicity (rewrite (= (<= 2 0) false)) (monotonicity (monotonicity @x606 $x259) $x262) (= $x600 $x241))))
-(let ((@x586 (monotonicity (rewrite (= (= 2 0) false)) (trans @x244 (rewrite (= $x241 $x599)) (= $x600 $x599)) (= $x256 (ite false (= (|mod$| |x$| 2) |x$|) $x599)))))
-(let ((@x227 (trans @x586 (rewrite (= (ite false (= (|mod$| |x$| 2) |x$|) $x599) $x599)) (= $x256 $x599))))
-(let ((@x581 (trans (monotonicity @x227 (= (or (not $x615) $x256) $x591)) (rewrite (= $x591 $x591)) (= (or (not $x615) $x256) $x591))))
-(let ((@x390 (|unit-resolution| (mp ((_ |quant-inst| |x$| 2) (or (not $x615) $x256)) @x581 $x591) (mp @x192 (|quant-intro| (refl (= $x186 $x186)) (= $x189 $x615)) $x615) $x599)))
-(let (($x440 (or (not $x599) (<= (+ (|mod$| |x$| 2) (* (~ 1) (mod |x$| 2))) 0))))
-(let ((@x538 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) $x440) @x390 (<= (+ (|mod$| |x$| 2) (* (~ 1) (mod |x$| 2))) 0))))
-(let ((?x7 (|mod$| |x$| 2)))
-(let (($x59 (>= ?x7 2)))
-(let (($x12 (< (+ |x$| (+ ?x7 ?x7)) (+ |x$| 3))))
-(let (($x13 (not $x12)))
-(let ((@x64 (monotonicity (rewrite (= (<= (+ 3 |x$|) (+ |x$| (* 2 ?x7))) $x59)) (= (not (<= (+ 3 |x$|) (+ |x$| (* 2 ?x7)))) (not $x59)))))
-(let (($x54 (not (<= (+ 3 |x$|) (+ |x$| (* 2 ?x7))))))
-(let ((@x46 (monotonicity (rewrite (= (+ ?x7 ?x7) (* 2 ?x7))) (= (+ |x$| (+ ?x7 ?x7)) (+ |x$| (* 2 ?x7))))))
-(let ((@x52 (monotonicity @x46 (rewrite (= (+ |x$| 3) (+ 3 |x$|))) (= $x12 (< (+ |x$| (* 2 ?x7)) (+ 3 |x$|))))))
-(let ((@x58 (trans @x52 (rewrite (= (< (+ |x$| (* 2 ?x7)) (+ 3 |x$|)) $x54)) (= $x12 $x54))))
-(let ((@x69 (monotonicity (trans @x58 @x64 (= $x12 (not $x59))) (= $x13 (not (not $x59))))))
-(let ((@x74 (mp (asserted $x13) (trans @x69 (rewrite (= (not (not $x59)) $x59)) (= $x13 $x59)) $x59)))
-((_ |th-lemma| arith farkas -1 1 1) @x74 @x538 @x426 false)))))))))))))))))))))))))))))))))))))))))))))))))))))))
+(let ((?x149 (ite $x19 ?x29 ?x144)))
+(let ((?x152 (ite $x18 ?1 ?x149)))
+(let (($x155 (= ?x28 ?x152)))
+(let (($x156 (= (= ?x28 (ite $x18 ?1 (ite $x19 ?x29 (- (mod (- ?1) (- ?0)))))) $x155)))
+(let ((@x140 (monotonicity (rewrite (= (- ?1) ?x92)) (rewrite (= (- ?0) ?x95)) (= (mod (- ?1) (- ?0)) ?x138))))
+(let ((@x148 (trans (monotonicity @x140 (= (- (mod (- ?1) (- ?0))) (- ?x138))) (rewrite (= (- ?x138) ?x144)) (= (- (mod (- ?1) (- ?0))) ?x144))))
+(let ((@x151 (monotonicity @x148 (= (ite $x19 ?x29 (- (mod (- ?1) (- ?0)))) ?x149))))
+(let ((@x154 (monotonicity @x151 (= (ite $x18 ?1 (ite $x19 ?x29 (- (mod (- ?1) (- ?0))))) ?x152))))
+(let ((@x179 (trans (|quant-intro| (monotonicity @x154 $x156) (= $x35 $x158)) (|quant-intro| @x174 (= $x158 $x175)) (= $x35 $x175))))
+(let ((@x190 (|mp~| (mp (asserted $x35) @x179 $x175) (|nnf-pos| (refl (|~| $x172 $x172)) (|~| $x175 $x175)) $x175)))
+(let ((@x204 (mp @x190 (|quant-intro| (refl (= $x172 $x172)) (= $x175 $x199)) $x199)))
+(let (($x253 (or (not $x199) $x247)))
+(let ((?x208 (* (~ 1) 2)))
+(let ((?x207 (* (~ 1) |x$|)))
+(let ((?x209 (mod ?x207 ?x208)))
+(let ((?x210 (* (~ 1) ?x209)))
+(let (($x206 (<= 2 0)))
+(let ((?x212 (ite $x206 ?x210 ?x211)))
+(let (($x205 (= 2 0)))
+(let ((?x213 (ite $x205 |x$| ?x212)))
+(let (($x214 (= ?x7 ?x213)))
+(let ((@x227 (monotonicity (monotonicity (rewrite (= ?x208 (~ 2))) (= ?x209 (mod ?x207 (~ 2)))) (= ?x210 (* (~ 1) (mod ?x207 (~ 2)))))))
+(let ((@x230 (monotonicity (rewrite (= $x206 false)) @x227 (= ?x212 (ite false (* (~ 1) (mod ?x207 (~ 2))) ?x211)))))
+(let ((@x234 (trans @x230 (rewrite (= (ite false (* (~ 1) (mod ?x207 (~ 2))) ?x211) ?x211)) (= ?x212 ?x211))))
+(let ((@x237 (monotonicity (rewrite (= $x205 false)) @x234 (= ?x213 (ite false |x$| ?x211)))))
+(let ((@x244 (monotonicity (trans @x237 (rewrite (= (ite false |x$| ?x211) ?x211)) (= ?x213 ?x211)) (= $x214 (= ?x7 ?x211)))))
+(let ((@x257 (monotonicity (trans @x244 (rewrite (= (= ?x7 ?x211) $x247)) (= $x214 $x247)) (= (or (not $x199) $x214) $x253))))
+(let ((@x260 (trans @x257 (rewrite (= $x253 $x253)) (= (or (not $x199) $x214) $x253))))
+(let ((@x261 (mp ((_ |quant-inst| |x$| 2) (or (not $x199) $x214)) @x260 $x253)))
+(let ((@x323 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x247) $x262)) (|unit-resolution| @x261 @x204 $x247) $x262)))
+(let (($x82 (>= ?x7 2)))
+(let ((?x56 (* 2 ?x7)))
+(let (($x75 (>= ?x56 3)))
+(let (($x65 (< (+ |x$| ?x56) (+ 3 |x$|))))
+(let (($x68 (not $x65)))
+(let ((@x77 (monotonicity (rewrite (= $x65 (not $x75))) (= $x68 (not (not $x75))))))
+(let ((@x86 (trans (trans @x77 (rewrite (= (not (not $x75)) $x75)) (= $x68 $x75)) (rewrite (= $x75 $x82)) (= $x68 $x82))))
+(let ((@x61 (monotonicity (rewrite (= (+ ?x7 ?x7) ?x56)) (= (+ |x$| (+ ?x7 ?x7)) (+ |x$| ?x56)))))
+(let ((@x67 (monotonicity @x61 (rewrite (= (+ |x$| 3) (+ 3 |x$|))) (= (< (+ |x$| (+ ?x7 ?x7)) (+ |x$| 3)) $x65))))
+(let ((@x70 (monotonicity @x67 (= (not (< (+ |x$| (+ ?x7 ?x7)) (+ |x$| 3))) $x68))))
+(let ((@x88 (trans @x70 @x86 (= (not (< (+ |x$| (+ ?x7 ?x7)) (+ |x$| 3))) $x82))))
+(let ((@x89 (mp (asserted (not (< (+ |x$| (+ ?x7 ?x7)) (+ |x$| 3)))) @x88 $x82)))
+((_ |th-lemma| arith farkas -1 1 1) @x89 @x323 (|unit-resolution| ((_ |th-lemma| arith) (or false $x306)) (|true-axiom| true) $x306) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
 
-31f44b6ec36399ae0bf7b30f056d07862ad51205 29 0
+fb75370f1b646783db5a9a683587f9b2b11bd686 32 0
 unsat
 ((set-logic <null>)
 (proof
 (let (($x7 (= |x$| 0.0)))
-(let ((?x13 (ite (< |x$| 0.0) (- |x$|) |x$|)))
-(let (($x14 (< 1.0 ?x13)))
-(let (($x15 (not $x14)))
-(let (($x16 (or $x14 $x15)))
+(let (($x8 (not $x7)))
+(let ((@x43 (asserted $x8)))
+(let (($x99 (<= |x$| 0.0)))
+(let ((?x45 (* 2.0 |x$|)))
+(let (($x97 (<= ?x45 0.0)))
+(let (($x93 (= ?x45 0.0)))
+(let (($x14 (< 1.0 (ite (< |x$| 0.0) (- |x$|) |x$|))))
+(let (($x16 (or $x14 (not $x14))))
 (let ((?x19 (ite $x16 4.0 2.0)))
-(let (($x21 (= (+ |x$| |x$|) (* ?x19 |x$|))))
-(let (($x23 (not (not $x21))))
-(let ((?x41 (* (~ 1.0) |x$|)))
-(let (($x31 (<= 0.0 |x$|)))
-(let ((?x47 (ite $x31 |x$| ?x41)))
-(let (($x55 (<= ?x47 1.0)))
-(let (($x56 (not $x55)))
-(let ((@x39 (trans (rewrite (= (< |x$| 0.0) (not $x31))) (monotonicity (rewrite (= $x31 $x31)) (= (not $x31) (not $x31))) (= (< |x$| 0.0) (not $x31)))))
-(let ((@x46 (monotonicity @x39 (rewrite (= (- |x$|) ?x41)) (= ?x13 (ite (not $x31) ?x41 |x$|)))))
-(let ((@x51 (trans @x46 (rewrite (= (ite (not $x31) ?x41 |x$|) ?x47)) (= ?x13 ?x47))))
-(let ((@x60 (trans (monotonicity @x51 (= $x14 (< 1.0 ?x47))) (rewrite (= (< 1.0 ?x47) $x56)) (= $x14 $x56))))
-(let ((@x67 (trans (monotonicity @x60 (= $x15 (not $x56))) (rewrite (= (not $x56) $x55)) (= $x15 $x55))))
-(let ((@x74 (trans (monotonicity @x60 @x67 (= $x16 (or $x56 $x55))) (rewrite (= (or $x56 $x55) true)) (= $x16 true))))
-(let ((@x81 (trans (monotonicity @x74 (= ?x19 (ite true 4.0 2.0))) (rewrite (= (ite true 4.0 2.0) 4.0)) (= ?x19 4.0))))
-(let ((@x87 (monotonicity (rewrite (= (+ |x$| |x$|) (* 2.0 |x$|))) (monotonicity @x81 (= (* ?x19 |x$|) (* 4.0 |x$|))) (= $x21 (= (* 2.0 |x$|) (* 4.0 |x$|))))))
-(let ((@x91 (trans @x87 (rewrite (= (= (* 2.0 |x$|) (* 4.0 |x$|)) $x7)) (= $x21 $x7))))
-(let ((@x96 (monotonicity (monotonicity @x91 (= (not $x21) (not $x7))) (= $x23 (not (not $x7))))))
-(let ((@x101 (mp (asserted $x23) (trans @x96 (rewrite (= (not (not $x7)) $x7)) (= $x23 $x7)) $x7)))
-(|unit-resolution| (asserted (not $x7)) @x101 false)))))))))))))))))))))))))))
+(let (($x23 (not (not (= (+ |x$| |x$|) (* ?x19 |x$|))))))
+(let ((@x88 (rewrite (= (not (not (= ?x45 (* 4.0 |x$|)))) (= ?x45 (* 4.0 |x$|))))))
+(let (($x82 (= (not (= (+ |x$| |x$|) (* ?x19 |x$|))) (not (= ?x45 (* 4.0 |x$|))))))
+(let (($x55 (< 1.0 (ite (< |x$| 0.0) (* (~ 1.0) |x$|) |x$|))))
+(let (($x53 (= (ite (< |x$| 0.0) (- |x$|) |x$|) (ite (< |x$| 0.0) (* (~ 1.0) |x$|) |x$|))))
+(let ((@x57 (monotonicity (monotonicity (rewrite (= (- |x$|) (* (~ 1.0) |x$|))) $x53) (= $x14 $x55))))
+(let ((@x63 (monotonicity @x57 (monotonicity @x57 (= (not $x14) (not $x55))) (= $x16 (or $x55 (not $x55))))))
+(let ((@x67 (trans @x63 (rewrite (= (or $x55 (not $x55)) true)) (= $x16 true))))
+(let ((@x74 (trans (monotonicity @x67 (= ?x19 (ite true 4.0 2.0))) (rewrite (= (ite true 4.0 2.0) 4.0)) (= ?x19 4.0))))
+(let ((@x80 (monotonicity (rewrite (= (+ |x$| |x$|) ?x45)) (monotonicity @x74 (= (* ?x19 |x$|) (* 4.0 |x$|))) (= (= (+ |x$| |x$|) (* ?x19 |x$|)) (= ?x45 (* 4.0 |x$|))))))
+(let ((@x86 (monotonicity (monotonicity @x80 $x82) (= $x23 (not (not (= ?x45 (* 4.0 |x$|))))))))
+(let ((@x95 (trans (trans @x86 @x88 (= $x23 (= ?x45 (* 4.0 |x$|)))) (rewrite (= (= ?x45 (* 4.0 |x$|)) $x93)) (= $x23 $x93))))
+(let ((@x96 (mp (asserted $x23) @x95 $x93)))
+(let ((@x108 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1) (or $x99 (not $x97))) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x93) $x97)) @x96 $x97) $x99)))
+(let (($x100 (>= |x$| 0.0)))
+(let (($x98 (>= ?x45 0.0)))
+(let ((@x115 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1) (or $x100 (not $x98))) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x93) $x98)) @x96 $x98) $x100)))
+(|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x7 (not $x99) (not $x100))) @x115 @x108 @x43 false))))))))))))))))))))))))))))))
 
-0af106a1a4c411ecd84e866591819b17883ffc09 178 0
+bba1efa8562001b979c24cfd840c5185f0dad8b2 242 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((?x436 (* (~ 1) (mod |n$| 4))))
-(let ((?x336 (mod |n$| 2)))
-(let ((?x339 (* (~ 1) ?x336)))
+(let ((?x471 (div |m$| 2)))
+(let ((?x531 (* (~ 1) ?x471)))
+(let ((?x426 (mod |m$| 2)))
+(let ((?x453 (* (~ 1) ?x426)))
+(let ((?x368 (div |n$| 4)))
+(let ((?x541 (* (~ 2) ?x368)))
+(let ((?x316 (mod |n$| 4)))
+(let ((?x350 (* (~ 1) ?x316)))
+(let ((?x7 (+ |n$| |m$|)))
+(let ((?x259 (div ?x7 2)))
+(let ((?x540 (* (~ 1) ?x259)))
+(let ((?x201 (mod ?x7 2)))
+(let ((?x240 (* (~ 1) ?x201)))
 (let ((?x13 (|mod$| |n$| 4)))
-(let ((?x193 (+ |n$| ?x13 ?x339 ?x436 (* (~ 2) (div |n$| 4)) (* (~ 1) (div |n$| 2)))))
-(let ((@x129 (|true-axiom| true)))
-(let ((@x662 (|unit-resolution| ((_ |th-lemma| arith) (or false (>= ?x336 0))) @x129 (>= ?x336 0))))
-(let ((?x203 (+ |n$| ?x339 (* (~ 2) (div |n$| 2)))))
-(let (($x201 (= ?x203 0)))
-(let ((@x525 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x201) (<= ?x203 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x201)) @x129 $x201) (<= ?x203 0))))
-(let ((?x529 (+ ?x13 ?x436)))
-(let (($x530 (= ?x529 0)))
-(let (($x604 (forall ((?v0 Int) (?v1 Int) )(!(let (($x51 (<= ?v1 0)))
-(let (($x175 (ite $x51 (= (+ (|mod$| ?v0 ?v1) (mod (* (~ 1) ?v0) (* (~ 1) ?v1))) 0) (= (+ (|mod$| ?v0 ?v1) (* (~ 1) (mod ?v0 ?v1))) 0))))
+(let ((?x9 (|mod$| ?x7 2)))
+(let ((?x534 (+ |n$| |m$| ?x9 ?x13 ?x240 ?x540 ?x350 ?x541 ?x453 ?x531)))
+(let (($x535 (>= ?x534 2)))
+(let (($x492 (>= ?x426 0)))
+(let ((@x62 (|true-axiom| true)))
+(let ((?x484 (* (~ 2) ?x471)))
+(let ((?x485 (+ |m$| ?x453 ?x484)))
+(let (($x490 (<= ?x485 0)))
+(let (($x483 (= ?x485 0)))
+(let ((@x379 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x483) $x490)) (|unit-resolution| ((_ |th-lemma| arith) (or false $x483)) @x62 $x483) $x490)))
+(let ((?x351 (+ ?x13 ?x350)))
+(let (($x366 (<= ?x351 0)))
+(let (($x352 (= ?x351 0)))
+(let (($x189 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x37 (mod ?v0 ?v1)))
+(let ((?x71 (* (~ 1) ?v1)))
+(let ((?x68 (* (~ 1) ?v0)))
+(let ((?x114 (mod ?x68 ?x71)))
+(let ((?x120 (* (~ 1) ?x114)))
+(let (($x89 (<= ?v1 0)))
+(let ((?x140 (ite $x89 ?x120 ?x37)))
 (let (($x26 (= ?v1 0)))
-(ite $x26 (= (|mod$| ?v0 ?v1) ?v0) $x175)))) :pattern ( (|mod$| ?v0 ?v1) )))
+(let ((?x145 (ite $x26 ?v0 ?x140)))
+(let ((?x36 (|mod$| ?v0 ?v1)))
+(= ?x36 ?x145))))))))))) :pattern ( (|mod$| ?v0 ?v1) )))
 ))
-(let (($x179 (forall ((?v0 Int) (?v1 Int) )(let (($x51 (<= ?v1 0)))
-(let (($x175 (ite $x51 (= (+ (|mod$| ?v0 ?v1) (mod (* (~ 1) ?v0) (* (~ 1) ?v1))) 0) (= (+ (|mod$| ?v0 ?v1) (* (~ 1) (mod ?v0 ?v1))) 0))))
+(let (($x151 (forall ((?v0 Int) (?v1 Int) )(let ((?x37 (mod ?v0 ?v1)))
+(let ((?x71 (* (~ 1) ?v1)))
+(let ((?x68 (* (~ 1) ?v0)))
+(let ((?x114 (mod ?x68 ?x71)))
+(let ((?x120 (* (~ 1) ?x114)))
+(let (($x89 (<= ?v1 0)))
+(let ((?x140 (ite $x89 ?x120 ?x37)))
 (let (($x26 (= ?v1 0)))
-(ite $x26 (= (|mod$| ?v0 ?v1) ?v0) $x175)))))
-))
-(let (($x51 (<= ?0 0)))
-(let (($x175 (ite $x51 (= (+ (|mod$| ?1 ?0) (mod (* (~ 1) ?1) (* (~ 1) ?0))) 0) (= (+ (|mod$| ?1 ?0) (* (~ 1) (mod ?1 ?0))) 0))))
-(let (($x26 (= ?0 0)))
-(let (($x176 (ite $x26 (= (|mod$| ?1 ?0) ?1) $x175)))
-(let (($x108 (forall ((?v0 Int) (?v1 Int) )(let ((?x37 (mod ?v0 ?v1)))
-(let ((?x83 (mod (* (~ 1) ?v0) (* (~ 1) ?v1))))
-(let ((?x89 (* (~ 1) ?x83)))
-(let (($x51 (<= ?v1 0)))
-(let ((?x97 (ite $x51 ?x89 ?x37)))
-(let (($x26 (= ?v1 0)))
+(let ((?x145 (ite $x26 ?v0 ?x140)))
 (let ((?x36 (|mod$| ?v0 ?v1)))
-(= ?x36 (ite $x26 ?v0 ?x97))))))))))
+(= ?x36 ?x145))))))))))))
 ))
 (let ((?x37 (mod ?1 ?0)))
-(let ((?x83 (mod (* (~ 1) ?1) (* (~ 1) ?0))))
-(let ((?x89 (* (~ 1) ?x83)))
-(let ((?x97 (ite $x51 ?x89 ?x37)))
+(let ((?x71 (* (~ 1) ?0)))
+(let ((?x68 (* (~ 1) ?1)))
+(let ((?x114 (mod ?x68 ?x71)))
+(let ((?x120 (* (~ 1) ?x114)))
+(let (($x89 (<= ?0 0)))
+(let ((?x140 (ite $x89 ?x120 ?x37)))
+(let (($x26 (= ?0 0)))
+(let ((?x145 (ite $x26 ?1 ?x140)))
 (let ((?x36 (|mod$| ?1 ?0)))
-(let (($x105 (= ?x36 (ite $x26 ?1 ?x97))))
-(let (($x43 (forall ((?v0 Int) (?v1 Int) )(let ((?x39 (- (mod (- ?v0) (- ?v1)))))
+(let (($x148 (= ?x36 ?x145)))
+(let (($x43 (forall ((?v0 Int) (?v1 Int) )(let (($x26 (= ?v1 0)))
+(let ((?x41 (ite $x26 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
+(let ((?x36 (|mod$| ?v0 ?v1)))
+(= ?x36 ?x41)))))
+))
+(let (($x134 (forall ((?v0 Int) (?v1 Int) )(let ((?x71 (* (~ 1) ?v1)))
+(let ((?x68 (* (~ 1) ?v0)))
+(let ((?x114 (mod ?x68 ?x71)))
+(let ((?x120 (* (~ 1) ?x114)))
 (let ((?x37 (mod ?v0 ?v1)))
 (let (($x27 (< 0 ?v1)))
-(let ((?x40 (ite $x27 ?x37 ?x39)))
+(let ((?x125 (ite $x27 ?x37 ?x120)))
 (let (($x26 (= ?v1 0)))
+(let ((?x128 (ite $x26 ?v0 ?x125)))
 (let ((?x36 (|mod$| ?v0 ?v1)))
-(= ?x36 (ite $x26 ?v0 ?x40)))))))))
+(= ?x36 ?x128))))))))))))
 ))
-(let ((?x39 (- (mod (- ?1) (- ?0)))))
+(let ((@x139 (monotonicity (rewrite (= (< 0 ?0) (not $x89))) (= (ite (< 0 ?0) ?x37 ?x120) (ite (not $x89) ?x37 ?x120)))))
+(let ((@x144 (trans @x139 (rewrite (= (ite (not $x89) ?x37 ?x120) ?x140)) (= (ite (< 0 ?0) ?x37 ?x120) ?x140))))
+(let ((@x147 (monotonicity @x144 (= (ite $x26 ?1 (ite (< 0 ?0) ?x37 ?x120)) ?x145))))
+(let ((@x150 (monotonicity @x147 (= (= ?x36 (ite $x26 ?1 (ite (< 0 ?0) ?x37 ?x120))) $x148))))
 (let (($x27 (< 0 ?0)))
-(let ((?x40 (ite $x27 ?x37 ?x39)))
-(let ((@x85 (monotonicity (rewrite (= (- ?1) (* (~ 1) ?1))) (rewrite (= (- ?0) (* (~ 1) ?0))) (= (mod (- ?1) (- ?0)) ?x83))))
-(let ((@x93 (trans (monotonicity @x85 (= ?x39 (- ?x83))) (rewrite (= (- ?x83) ?x89)) (= ?x39 ?x89))))
-(let ((@x96 (monotonicity (rewrite (= $x27 (not $x51))) @x93 (= ?x40 (ite (not $x51) ?x37 ?x89)))))
-(let ((@x101 (trans @x96 (rewrite (= (ite (not $x51) ?x37 ?x89) ?x97)) (= ?x40 ?x97))))
-(let ((@x107 (monotonicity (monotonicity @x101 (= (ite $x26 ?1 ?x40) (ite $x26 ?1 ?x97))) (= (= ?x36 (ite $x26 ?1 ?x40)) $x105))))
-(let ((@x135 (|mp~| (mp (asserted $x43) (|quant-intro| @x107 (= $x43 $x108)) $x108) (|nnf-pos| (refl (|~| $x105 $x105)) (|~| $x108 $x108)) $x108)))
-(let ((@x182 (mp @x135 (|quant-intro| (rewrite (= $x105 $x176)) (= $x108 $x179)) $x179)))
-(let ((@x609 (mp @x182 (|quant-intro| (refl (= $x176 $x176)) (= $x179 $x604)) $x604)))
-(let (($x289 (not $x604)))
-(let (($x480 (or $x289 $x530)))
-(let (($x531 (ite (<= 4 0) (= (+ ?x13 (mod (* (~ 1) |n$|) (* (~ 1) 4))) 0) $x530)))
-(let (($x518 (ite (= 4 0) (= ?x13 |n$|) $x531)))
-(let (($x505 (= (ite false (= (+ ?x13 (mod (* (~ 1) |n$|) (~ 4))) 0) $x530) $x530)))
-(let (($x503 (= $x531 (ite false (= (+ ?x13 (mod (* (~ 1) |n$|) (~ 4))) 0) $x530))))
-(let (($x517 (= (= (+ ?x13 (mod (* (~ 1) |n$|) (* (~ 1) 4))) 0) (= (+ ?x13 (mod (* (~ 1) |n$|) (~ 4))) 0))))
-(let (($x514 (= (+ ?x13 (mod (* (~ 1) |n$|) (* (~ 1) 4))) (+ ?x13 (mod (* (~ 1) |n$|) (~ 4))))))
-(let ((@x512 (monotonicity (rewrite (= (* (~ 1) 4) (~ 4))) (= (mod (* (~ 1) |n$|) (* (~ 1) 4)) (mod (* (~ 1) |n$|) (~ 4))))))
-(let ((@x504 (monotonicity (rewrite (= (<= 4 0) false)) (monotonicity (monotonicity @x512 $x514) $x517) $x503)))
-(let ((@x496 (monotonicity (rewrite (= (= 4 0) false)) (trans @x504 (rewrite $x505) (= $x531 $x530)) (= $x518 (ite false (= ?x13 |n$|) $x530)))))
-(let ((@x500 (trans @x496 (rewrite (= (ite false (= ?x13 |n$|) $x530) $x530)) (= $x518 $x530))))
-(let ((@x487 (trans (monotonicity @x500 (= (or $x289 $x518) $x480)) (rewrite (= $x480 $x480)) (= (or $x289 $x518) $x480))))
-(let ((@x232 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x530) (<= ?x529 0))) (|unit-resolution| (mp ((_ |quant-inst| |n$| 4) (or $x289 $x518)) @x487 $x480) @x609 $x530) (<= ?x529 0))))
-(let ((?x466 (+ |n$| ?x436 (* (~ 4) (div |n$| 4)))))
-(let (($x464 (= ?x466 0)))
-(let ((@x243 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x464) (<= ?x466 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x464)) @x129 $x464) (<= ?x466 0))))
-(let ((@x227 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x13 3)) (<= ?x13 3))) (asserted (= ?x13 3)) (<= ?x13 3))))
-(let ((@x626 ((_ |th-lemma| arith farkas 2 -1 -1 -1 -1 1) (hypothesis (>= ?x193 2)) @x227 @x243 @x232 @x525 @x662 false)))
-(let ((@x621 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x201) (>= ?x203 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x201)) @x129 $x201) (>= ?x203 0))))
-(let ((@x353 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x530) (>= ?x529 0))) (|unit-resolution| (mp ((_ |quant-inst| |n$| 4) (or $x289 $x518)) @x487 $x480) @x609 $x530) (>= ?x529 0))))
-(let ((@x560 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x464) (>= ?x466 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x464)) @x129 $x464) (>= ?x466 0))))
-(let ((@x360 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x13 3)) (>= ?x13 3))) (asserted (= ?x13 3)) (>= ?x13 3))))
-(let ((?x16 (|mod$| |n$| 2)))
-(let ((?x344 (+ ?x16 ?x339)))
-(let (($x346 (= ?x344 0)))
-(let (($x467 (or $x289 $x346)))
-(let (($x268 (<= 2 0)))
-(let (($x354 (ite $x268 (= (+ ?x16 (mod (* (~ 1) |n$|) (* (~ 1) 2))) 0) $x346)))
-(let (($x183 (= 2 0)))
-(let (($x355 (ite $x183 (= ?x16 |n$|) $x354)))
-(let (($x315 (= (ite false (= (+ ?x16 (mod (* (~ 1) |n$|) (~ 2))) 0) $x346) $x346)))
-(let (($x558 (= $x354 (ite false (= (+ ?x16 (mod (* (~ 1) |n$|) (~ 2))) 0) $x346))))
-(let (($x311 (= (= (+ ?x16 (mod (* (~ 1) |n$|) (* (~ 1) 2))) 0) (= (+ ?x16 (mod (* (~ 1) |n$|) (~ 2))) 0))))
-(let (($x330 (= (+ ?x16 (mod (* (~ 1) |n$|) (* (~ 1) 2))) (+ ?x16 (mod (* (~ 1) |n$|) (~ 2))))))
-(let ((@x230 (rewrite (= (* (~ 1) 2) (~ 2)))))
-(let ((@x328 (monotonicity @x230 (= (mod (* (~ 1) |n$|) (* (~ 1) 2)) (mod (* (~ 1) |n$|) (~ 2))))))
-(let ((@x594 (rewrite (= $x268 false))))
-(let ((@x305 (trans (monotonicity @x594 (monotonicity (monotonicity @x328 $x330) $x311) $x558) (rewrite $x315) (= $x354 $x346))))
-(let ((@x584 (rewrite (= $x183 false))))
-(let ((@x463 (trans (monotonicity @x584 @x305 (= $x355 (ite false (= ?x16 |n$|) $x346))) (rewrite (= (ite false (= ?x16 |n$|) $x346) $x346)) (= $x355 $x346))))
-(let ((@x555 (trans (monotonicity @x463 (= (or $x289 $x355) $x467)) (rewrite (= $x467 $x467)) (= (or $x289 $x355) $x467))))
-(let ((@x647 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x346) (>= ?x344 0))) (|unit-resolution| (mp ((_ |quant-inst| |n$| 2) (or $x289 $x355)) @x555 $x467) @x609 $x346) (>= ?x344 0))))
-(let (($x629 (not (>= ?x16 1))))
-(let (($x617 (<= ?x16 1)))
-(let (($x394 (<= ?x344 0)))
-(let ((@x651 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x346) $x394)) (|unit-resolution| (mp ((_ |quant-inst| |n$| 2) (or $x289 $x355)) @x555 $x467) @x609 $x346) $x394)))
-(let ((@x184 (|unit-resolution| ((_ |th-lemma| arith) (or false (not (>= ?x336 2)))) @x129 (not (>= ?x336 2)))))
-(let ((@x611 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1) (or $x617 (>= ?x336 2) (not $x394))) @x184 @x651 $x617)))
+(let ((?x125 (ite $x27 ?x37 ?x120)))
+(let ((?x128 (ite $x26 ?1 ?x125)))
+(let (($x131 (= ?x36 ?x128)))
+(let (($x132 (= (= ?x36 (ite $x26 ?1 (ite $x27 ?x37 (- (mod (- ?1) (- ?0)))))) $x131)))
+(let ((@x116 (monotonicity (rewrite (= (- ?1) ?x68)) (rewrite (= (- ?0) ?x71)) (= (mod (- ?1) (- ?0)) ?x114))))
+(let ((@x124 (trans (monotonicity @x116 (= (- (mod (- ?1) (- ?0))) (- ?x114))) (rewrite (= (- ?x114) ?x120)) (= (- (mod (- ?1) (- ?0))) ?x120))))
+(let ((@x127 (monotonicity @x124 (= (ite $x27 ?x37 (- (mod (- ?1) (- ?0)))) ?x125))))
+(let ((@x130 (monotonicity @x127 (= (ite $x26 ?1 (ite $x27 ?x37 (- (mod (- ?1) (- ?0))))) ?x128))))
+(let ((@x155 (trans (|quant-intro| (monotonicity @x130 $x132) (= $x43 $x134)) (|quant-intro| @x150 (= $x134 $x151)) (= $x43 $x151))))
+(let ((@x166 (|mp~| (mp (asserted $x43) @x155 $x151) (|nnf-pos| (refl (|~| $x148 $x148)) (|~| $x151 $x151)) $x151)))
+(let ((@x194 (mp @x166 (|quant-intro| (refl (= $x148 $x148)) (= $x151 $x189)) $x189)))
+(let (($x247 (not $x189)))
+(let (($x357 (or $x247 $x352)))
+(let ((?x317 (ite (<= 4 0) (* (~ 1) (mod (* (~ 1) |n$|) (* (~ 1) 4))) ?x316)))
+(let ((?x318 (ite (= 4 0) |n$| ?x317)))
+(let (($x319 (= ?x13 ?x318)))
+(let ((@x337 (rewrite (= (ite false (* (~ 1) (mod (* (~ 1) |n$|) (~ 4))) ?x316) ?x316))))
+(let (($x331 (= (* (~ 1) (mod (* (~ 1) |n$|) (* (~ 1) 4))) (* (~ 1) (mod (* (~ 1) |n$|) (~ 4))))))
+(let ((@x329 (monotonicity (rewrite (= (* (~ 1) 4) (~ 4))) (= (mod (* (~ 1) |n$|) (* (~ 1) 4)) (mod (* (~ 1) |n$|) (~ 4))))))
+(let ((@x335 (monotonicity (rewrite (= (<= 4 0) false)) (monotonicity @x329 $x331) (= ?x317 (ite false (* (~ 1) (mod (* (~ 1) |n$|) (~ 4))) ?x316)))))
+(let ((@x342 (monotonicity (rewrite (= (= 4 0) false)) (trans @x335 @x337 (= ?x317 ?x316)) (= ?x318 (ite false |n$| ?x316)))))
+(let ((@x349 (monotonicity (trans @x342 (rewrite (= (ite false |n$| ?x316) ?x316)) (= ?x318 ?x316)) (= $x319 (= ?x13 ?x316)))))
+(let ((@x361 (monotonicity (trans @x349 (rewrite (= (= ?x13 ?x316) $x352)) (= $x319 $x352)) (= (or $x247 $x319) $x357))))
+(let ((@x365 (mp ((_ |quant-inst| |n$| 4) (or $x247 $x319)) (trans @x361 (rewrite (= $x357 $x357)) (= (or $x247 $x319) $x357)) $x357)))
+(let ((@x570 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x352) $x366)) (|unit-resolution| @x365 @x194 $x352) $x366)))
+(let ((?x275 (* (~ 2) ?x259)))
+(let ((?x276 (+ |n$| |m$| ?x240 ?x275)))
+(let (($x281 (<= ?x276 0)))
+(let (($x274 (= ?x276 0)))
+(let ((@x560 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x274) $x281)) (|unit-resolution| ((_ |th-lemma| arith) (or false $x274)) @x62 $x274) $x281)))
+(let ((?x241 (+ ?x9 ?x240)))
+(let (($x257 (<= ?x241 0)))
+(let (($x242 (= ?x241 0)))
+(let (($x248 (or $x247 $x242)))
+(let (($x196 (<= 2 0)))
+(let ((?x202 (ite $x196 (* (~ 1) (mod (* (~ 1) ?x7) (* (~ 1) 2))) ?x201)))
+(let (($x195 (= 2 0)))
+(let ((?x203 (ite $x195 ?x7 ?x202)))
+(let (($x204 (= ?x9 ?x203)))
+(let ((?x223 (ite false (* (~ 1) (mod (+ (* (~ 1) |n$|) (* (~ 1) |m$|)) (~ 2))) ?x201)))
+(let (($x221 (= (* (~ 1) (mod (* (~ 1) ?x7) (* (~ 1) 2))) (* (~ 1) (mod (+ (* (~ 1) |n$|) (* (~ 1) |m$|)) (~ 2))))))
+(let (($x218 (= (mod (* (~ 1) ?x7) (* (~ 1) 2)) (mod (+ (* (~ 1) |n$|) (* (~ 1) |m$|)) (~ 2)))))
+(let ((@x216 (rewrite (= (* (~ 1) 2) (~ 2)))))
+(let ((@x219 (monotonicity (rewrite (= (* (~ 1) ?x7) (+ (* (~ 1) |n$|) (* (~ 1) |m$|)))) @x216 $x218)))
+(let ((@x208 (rewrite (= $x196 false))))
+(let ((@x229 (trans (monotonicity @x208 (monotonicity @x219 $x221) (= ?x202 ?x223)) (rewrite (= ?x223 ?x201)) (= ?x202 ?x201))))
+(let ((@x206 (rewrite (= $x195 false))))
+(let ((@x236 (trans (monotonicity @x206 @x229 (= ?x203 (ite false ?x7 ?x201))) (rewrite (= (ite false ?x7 ?x201) ?x201)) (= ?x203 ?x201))))
+(let ((@x246 (trans (monotonicity @x236 (= $x204 (= ?x9 ?x201))) (rewrite (= (= ?x9 ?x201) $x242)) (= $x204 $x242))))
+(let ((@x255 (trans (monotonicity @x246 (= (or $x247 $x204) $x248)) (rewrite (= $x248 $x248)) (= (or $x247 $x204) $x248))))
+(let ((@x256 (mp ((_ |quant-inst| (+ |n$| |m$|) 2) (or $x247 $x204)) @x255 $x248)))
+(let ((@x565 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x242) $x257)) (|unit-resolution| @x256 @x194 $x242) $x257)))
+(let ((?x384 (* (~ 4) ?x368)))
+(let ((?x385 (+ |n$| ?x350 ?x384)))
+(let (($x390 (<= ?x385 0)))
+(let (($x383 (= ?x385 0)))
+(let ((@x577 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x383) $x390)) (|unit-resolution| ((_ |th-lemma| arith) (or false $x383)) @x62 $x383) $x390)))
+(let (($x422 (<= ?x13 3)))
+(let (($x15 (= ?x13 3)))
+(let ((@x64 (asserted $x15)))
+(let ((@x581 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x15) $x422)) @x64 $x422)))
+(let (($x420 (<= ?x9 0)))
+(let (($x11 (= ?x9 0)))
+(let ((@x63 (asserted $x11)))
+(let ((@x553 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x11) $x420)) @x63 $x420)))
+(let ((@x494 ((_ |th-lemma| arith farkas -1 -1 2 -1 -1 -1 -1 -1 1) @x553 @x581 (hypothesis $x535) @x577 @x565 @x560 @x570 @x379 (|unit-resolution| ((_ |th-lemma| arith) (or false $x492)) @x62 $x492) false)))
+(let (($x304 (>= ?x485 0)))
+(let ((@x648 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x483) $x304)) (|unit-resolution| ((_ |th-lemma| arith) (or false $x483)) @x62 $x483) $x304)))
+(let (($x367 (>= ?x351 0)))
+(let ((@x473 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x352) $x367)) (|unit-resolution| @x365 @x194 $x352) $x367)))
+(let (($x421 (>= ?x9 0)))
+(let (($x282 (>= ?x276 0)))
+(let ((@x371 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x274) $x282)) (|unit-resolution| ((_ |th-lemma| arith) (or false $x274)) @x62 $x274) $x282)))
+(let (($x258 (>= ?x241 0)))
+(let ((@x377 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x242) $x258)) (|unit-resolution| @x256 @x194 $x242) $x258)))
+(let (($x391 (>= ?x385 0)))
+(let ((@x474 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x383) $x391)) (|unit-resolution| ((_ |th-lemma| arith) (or false $x383)) @x62 $x383) $x391)))
+(let (($x423 (>= ?x13 3)))
+(let ((@x261 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x15) $x423)) @x64 $x423)))
 (let ((?x19 (|mod$| |m$| 2)))
+(let ((?x454 (+ ?x19 ?x453)))
+(let (($x263 (>= ?x454 0)))
+(let (($x386 (= ?x454 0)))
+(let (($x486 (or $x247 $x386)))
+(let ((?x198 (* (~ 1) 2)))
+(let ((?x210 (* (~ 1) |m$|)))
+(let ((?x424 (mod ?x210 ?x198)))
+(let ((?x425 (* (~ 1) ?x424)))
+(let ((?x427 (ite $x196 ?x425 ?x426)))
+(let ((?x428 (ite $x195 |m$| ?x427)))
+(let (($x429 (= ?x19 ?x428)))
+(let ((@x594 (monotonicity (monotonicity @x216 (= ?x424 (mod ?x210 (~ 2)))) (= ?x425 (* (~ 1) (mod ?x210 (~ 2)))))))
+(let ((@x596 (monotonicity @x208 @x594 (= ?x427 (ite false (* (~ 1) (mod ?x210 (~ 2))) ?x426)))))
+(let ((@x603 (trans @x596 (rewrite (= (ite false (* (~ 1) (mod ?x210 (~ 2))) ?x426) ?x426)) (= ?x427 ?x426))))
+(let ((@x414 (trans (monotonicity @x206 @x603 (= ?x428 (ite false |m$| ?x426))) (rewrite (= (ite false |m$| ?x426) ?x426)) (= ?x428 ?x426))))
+(let ((@x482 (trans (monotonicity @x414 (= $x429 (= ?x19 ?x426))) (rewrite (= (= ?x19 ?x426) $x386)) (= $x429 $x386))))
+(let ((@x511 (trans (monotonicity @x482 (= (or $x247 $x429) $x486)) (rewrite (= $x486 $x486)) (= (or $x247 $x429) $x486))))
+(let ((@x512 (mp ((_ |quant-inst| |m$| 2) (or $x247 $x429)) @x511 $x486)))
+(let ((@x653 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x386) $x263)) (|unit-resolution| @x512 @x194 $x386) $x263)))
+(let (($x271 (>= ?x19 1)))
+(let (($x666 (not $x271)))
+(let (($x509 (<= ?x19 1)))
+(let (($x498 (>= ?x426 2)))
+(let (($x635 (not $x498)))
+(let (($x469 (<= ?x454 0)))
+(let ((@x659 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x386) $x469)) (|unit-resolution| @x512 @x194 $x386) $x469)))
+(let ((@x663 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1) (or $x509 $x498 (not $x469))) @x659 (|unit-resolution| ((_ |th-lemma| arith) (or false $x635)) @x62 $x635) $x509)))
 (let (($x20 (= ?x19 1)))
-(let ((?x274 (* (~ 1) (mod (+ |n$| |m$|) 2))))
-(let ((?x7 (+ |n$| |m$|)))
-(let ((?x9 (|mod$| ?x7 2)))
-(let ((?x316 (+ |n$| |m$| ?x9 ?x13 ?x274 (* (~ 1) (div ?x7 2)) (* (~ 1) (div |m$| 2)) ?x436 (* (~ 2) (div |n$| 4)))))
-(let (($x307 (not (>= ?x19 1))))
-(let (($x318 (<= ?x19 1)))
-(let ((?x400 (+ ?x19 (* (~ 1) (mod |m$| 2)))))
-(let (($x371 (<= ?x400 0)))
-(let (($x401 (= ?x400 0)))
-(let (($x363 (or $x289 $x401)))
-(let (($x402 (ite $x268 (= (+ ?x19 (mod (* (~ 1) |m$|) (* (~ 1) 2))) 0) $x401)))
-(let (($x403 (ite $x183 (= ?x19 |m$|) $x402)))
-(let (($x382 (= (ite false (= (+ ?x19 (mod (* (~ 1) |m$|) (~ 2))) 0) $x401) $x401)))
-(let (($x378 (= $x402 (ite false (= (+ ?x19 (mod (* (~ 1) |m$|) (~ 2))) 0) $x401))))
-(let (($x411 (= (= (+ ?x19 (mod (* (~ 1) |m$|) (* (~ 1) 2))) 0) (= (+ ?x19 (mod (* (~ 1) |m$|) (~ 2))) 0))))
-(let (($x408 (= (+ ?x19 (mod (* (~ 1) |m$|) (* (~ 1) 2))) (+ ?x19 (mod (* (~ 1) |m$|) (~ 2))))))
-(let ((@x406 (monotonicity @x230 (= (mod (* (~ 1) |m$|) (* (~ 1) 2)) (mod (* (~ 1) |m$|) (~ 2))))))
-(let ((@x386 (trans (monotonicity @x594 (monotonicity (monotonicity @x406 $x408) $x411) $x378) (rewrite $x382) (= $x402 $x401))))
-(let ((@x393 (trans (monotonicity @x584 @x386 (= $x403 (ite false (= ?x19 |m$|) $x401))) (rewrite (= (ite false (= ?x19 |m$|) $x401) $x401)) (= $x403 $x401))))
-(let ((@x212 (trans (monotonicity @x393 (= (or $x289 $x403) $x363)) (rewrite (= $x363 $x363)) (= (or $x289 $x403) $x363))))
-(let ((@x557 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x401) $x371)) (|unit-resolution| (mp ((_ |quant-inst| |m$| 2) (or $x289 $x403)) @x212 $x363) @x609 $x401) $x371)))
-(let ((@x385 (|unit-resolution| ((_ |th-lemma| arith) (or false (not (>= (mod |m$| 2) 2)))) @x129 (not (>= (mod |m$| 2) 2)))))
-(let ((@x448 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1) (or $x318 (>= (mod |m$| 2) 2) (not $x371))) @x385 @x557 $x318)))
-(let ((@x546 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x20 (not $x318) $x307)) (hypothesis (not $x20)) (or (not $x318) $x307))))
-(let ((?x351 (+ |m$| (* (~ 2) (div |m$| 2)) (* (~ 1) (mod |m$| 2)))))
-(let (($x362 (= ?x351 0)))
-(let ((@x449 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x362) (<= ?x351 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x362)) @x129 $x362) (<= ?x351 0))))
-(let ((?x554 (+ |n$| |m$| ?x274 (* (~ 2) (div ?x7 2)))))
-(let (($x552 (= ?x554 0)))
-(let ((@x261 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x552) (<= ?x554 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x552)) @x129 $x552) (<= ?x554 0))))
-(let ((?x253 (+ ?x9 ?x274)))
-(let (($x588 (= ?x253 0)))
-(let (($x290 (or $x289 $x588)))
-(let (($x589 (ite $x268 (= (+ ?x9 (mod (* (~ 1) ?x7) (* (~ 1) 2))) 0) $x588)))
-(let (($x245 (ite $x183 (= ?x9 ?x7) $x589)))
-(let ((@x569 (rewrite (= (ite false (= (+ |n$| |m$| (* (~ 1) ?x9)) 0) $x588) $x588))))
-(let (($x576 (ite false (= (+ ?x9 (mod (+ (* (~ 1) |n$|) (* (~ 1) |m$|)) (~ 2))) 0) $x588)))
-(let (($x574 (= (= (+ ?x9 (mod (* (~ 1) ?x7) (* (~ 1) 2))) 0) (= (+ ?x9 (mod (+ (* (~ 1) |n$|) (* (~ 1) |m$|)) (~ 2))) 0))))
-(let (($x236 (= (+ ?x9 (mod (* (~ 1) ?x7) (* (~ 1) 2))) (+ ?x9 (mod (+ (* (~ 1) |n$|) (* (~ 1) |m$|)) (~ 2))))))
-(let (($x233 (= (mod (* (~ 1) ?x7) (* (~ 1) 2)) (mod (+ (* (~ 1) |n$|) (* (~ 1) |m$|)) (~ 2)))))
-(let ((@x234 (monotonicity (rewrite (= (* (~ 1) ?x7) (+ (* (~ 1) |n$|) (* (~ 1) |m$|)))) @x230 $x233)))
-(let ((@x578 (monotonicity @x594 (monotonicity (monotonicity @x234 $x236) $x574) (= $x589 $x576))))
-(let ((@x257 (rewrite (= (= ?x9 ?x7) (= (+ |n$| |m$| (* (~ 1) ?x9)) 0)))))
-(let ((@x582 (monotonicity @x584 @x257 (trans @x578 (rewrite (= $x576 $x588)) (= $x589 $x588)) (= $x245 (ite false (= (+ |n$| |m$| (* (~ 1) ?x9)) 0) $x588)))))
-(let ((@x564 (monotonicity (trans @x582 @x569 (= $x245 $x588)) (= (or $x289 $x245) $x290))))
-(let ((@x566 (mp ((_ |quant-inst| (+ |n$| |m$|) 2) (or $x289 $x245)) (trans @x564 (rewrite (= $x290 $x290)) (= (or $x289 $x245) $x290)) $x290)))
-(let ((@x266 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x588) (<= ?x253 0))) (|unit-resolution| @x566 @x609 $x588) (<= ?x253 0))))
-(let ((@x286 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x9 0)) (<= ?x9 0))) (asserted (= ?x9 0)) (<= ?x9 0))))
-(let ((@x455 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x401) (>= ?x400 0))) (|unit-resolution| (mp ((_ |quant-inst| |m$| 2) (or $x289 $x403)) @x212 $x363) @x609 $x401) (>= ?x400 0))))
-(let ((@x456 ((_ |th-lemma| arith farkas -1 1 1 -2 1 1 1 1 1 1) @x455 @x286 @x227 (hypothesis (>= ?x316 2)) @x243 @x266 @x261 @x449 @x232 (hypothesis $x307) false)))
-(let ((@x373 (|unit-resolution| (lemma @x456 (or (not (>= ?x316 2)) (>= ?x19 1))) (|unit-resolution| @x546 @x448 $x307) (not (>= ?x316 2)))))
-(let ((@x471 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x9 0)) (>= ?x9 0))) (asserted (= ?x9 0)) (>= ?x9 0))))
-(let ((@x276 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x552) (>= ?x554 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x552)) @x129 $x552) (>= ?x554 0))))
-(let ((@x475 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x588) (>= ?x253 0))) (|unit-resolution| @x566 @x609 $x588) (>= ?x253 0))))
-(let ((@x532 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x362) (>= ?x351 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x362)) @x129 $x362) (>= ?x351 0))))
-(let ((@x342 (|unit-resolution| ((_ |th-lemma| arith) (or false (>= (mod |m$| 2) 0))) @x129 (>= (mod |m$| 2) 0))))
-(let ((@x349 (lemma ((_ |th-lemma| arith farkas -1/2 -1/2 -1/2 -1/2 -1/2 -1/2 -1/2 -1/2 1) @x360 @x560 @x353 @x342 @x532 @x475 @x276 @x471 @x373 false) $x20)))
-(let (($x142 (or (not (= ?x16 1)) (not $x20))))
-(let ((@x148 (monotonicity (rewrite (= (and (= ?x16 1) $x20) (not $x142))) (= (not (and (= ?x16 1) $x20)) (not (not $x142))))))
-(let ((@x152 (trans @x148 (rewrite (= (not (not $x142)) $x142)) (= (not (and (= ?x16 1) $x20)) $x142))))
-(let ((@x627 (|unit-resolution| (mp (asserted (not (and (= ?x16 1) $x20))) @x152 $x142) @x349 (not (= ?x16 1)))))
-(let ((@x636 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (= ?x16 1) (not $x617) $x629)) @x627 (or (not $x617) $x629))))
-((_ |th-lemma| arith farkas 1/2 -1/2 -1/2 -1/2 -1/2 -1/2 1) (|unit-resolution| @x636 @x611 $x629) @x647 @x360 @x560 @x353 @x621 (lemma @x626 (not (>= ?x193 2))) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
+(let (($x168 (not $x20)))
+(let ((?x16 (|mod$| |n$| 2)))
+(let (($x18 (= ?x16 1)))
+(let (($x280 (>= ?x16 1)))
+(let (($x606 (not $x280)))
+(let (($x279 (<= ?x16 1)))
+(let ((?x430 (mod |n$| 2)))
+(let ((?x437 (* (~ 1) ?x430)))
+(let ((?x438 (+ ?x16 ?x437)))
+(let (($x455 (<= ?x438 0)))
+(let (($x439 (= ?x438 0)))
+(let (($x444 (or $x247 $x439)))
+(let ((?x209 (* (~ 1) |n$|)))
+(let ((?x461 (mod ?x209 ?x198)))
+(let ((?x462 (* (~ 1) ?x461)))
+(let ((?x431 (ite $x196 ?x462 ?x430)))
+(let ((?x432 (ite $x195 |n$| ?x431)))
+(let (($x433 (= ?x16 ?x432)))
+(let ((@x522 (monotonicity (monotonicity @x216 (= ?x461 (mod ?x209 (~ 2)))) (= ?x462 (* (~ 1) (mod ?x209 (~ 2)))))))
+(let ((@x521 (monotonicity @x208 @x522 (= ?x431 (ite false (* (~ 1) (mod ?x209 (~ 2))) ?x430)))))
+(let ((@x288 (trans @x521 (rewrite (= (ite false (* (~ 1) (mod ?x209 (~ 2))) ?x430) ?x430)) (= ?x431 ?x430))))
+(let ((@x538 (trans (monotonicity @x206 @x288 (= ?x432 (ite false |n$| ?x430))) (rewrite (= (ite false |n$| ?x430) ?x430)) (= ?x432 ?x430))))
+(let ((@x443 (trans (monotonicity @x538 (= $x433 (= ?x16 ?x430))) (rewrite (= (= ?x16 ?x430) $x439)) (= $x433 $x439))))
+(let ((@x451 (trans (monotonicity @x443 (= (or $x247 $x433) $x444)) (rewrite (= $x444 $x444)) (= (or $x247 $x433) $x444))))
+(let ((@x460 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x439) $x455)) (|unit-resolution| (mp ((_ |quant-inst| |n$| 2) (or $x247 $x433)) @x451 $x444) @x194 $x439) $x455)))
+(let ((@x463 (|unit-resolution| ((_ |th-lemma| arith) (or false (not (>= ?x430 2)))) @x62 (not (>= ?x430 2)))))
+(let ((@x295 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1) (or $x279 (>= ?x430 2) (not $x455))) @x463 @x460 $x279)))
+(let ((@x292 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x18 (not $x279) $x606)) (hypothesis (not $x18)) (or (not $x279) $x606))))
+(let (($x623 (or (not (>= (+ |n$| ?x13 ?x350 ?x541 (* (~ 1) (div |n$| 2))) 2)) $x280)))
+(let ((?x491 (+ |n$| ?x437 (* (~ 2) (div |n$| 2)))))
+(let (($x397 (<= ?x491 0)))
+(let (($x508 (= ?x491 0)))
+(let ((@x614 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x508) $x397)) (|unit-resolution| ((_ |th-lemma| arith) (or false $x508)) @x62 $x508) $x397)))
+(let (($x601 (>= (+ |n$| ?x13 ?x350 ?x541 (* (~ 1) (div |n$| 2))) 2)))
+(let ((@x620 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x439) (>= ?x438 0))) (|unit-resolution| (mp ((_ |quant-inst| |n$| 2) (or $x247 $x433)) @x451 $x444) @x194 $x439) (>= ?x438 0))))
+(let ((@x621 ((_ |th-lemma| arith farkas -1 -2 1 1 1 1 1) @x620 (hypothesis $x601) @x614 @x570 @x577 @x581 (hypothesis $x606) false)))
+(let ((@x403 (|unit-resolution| (lemma @x621 $x623) (|unit-resolution| @x292 @x295 $x606) (not $x601))))
+(let ((@x406 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x508) (>= ?x491 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x508)) @x62 $x508) (>= ?x491 0))))
+(let ((@x411 (|unit-resolution| ((_ |th-lemma| arith) (or false (>= ?x430 0))) @x62 (>= ?x430 0))))
+(let (($x169 (or (not $x18) $x168)))
+(let ((@x175 (monotonicity (rewrite (= (and $x18 $x20) (not $x169))) (= (not (and $x18 $x20)) (not (not $x169))))))
+(let ((@x179 (trans @x175 (rewrite (= (not (not $x169)) $x169)) (= (not (and $x18 $x20)) $x169))))
+(let ((@x180 (mp (asserted (not (and $x18 $x20))) @x179 $x169)))
+(let ((@x664 (|unit-resolution| @x180 (lemma ((_ |th-lemma| arith farkas -1/2 -1/2 -1/2 -1/2 -1/2 1) @x411 @x406 @x473 @x474 @x261 @x403 false) $x18) $x168)))
+(let ((@x670 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x20 (not $x509) $x666)) @x664 (or (not $x509) $x666))))
+((_ |th-lemma| arith farkas 1/2 -1/2 -1/2 -1/2 -1/2 -1/2 -1/2 -1/2 -1/2 1) (|unit-resolution| @x670 @x663 $x666) @x653 @x261 @x474 @x377 @x371 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x11) $x421)) @x63 $x421) @x473 @x648 (lemma @x494 (not $x535)) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
 
-6b708fee38e9bf7615ccc8723328495d7f62521e 11 0
+5e6ffeb79676694a9ab7732936a1e448ef9134cd 12 0
 unsat
 ((set-logic AUFLIA)
 (proof
@@ -1962,11 +2100,12 @@
 ))
 (let (($x5 (not $x6)))
 (let (($x7 (not $x5)))
-(let ((@x13 (monotonicity (|elim-unused| (= $x6 false)) (= $x5 (not false)))))
-(let ((@x20 (monotonicity (trans @x13 (rewrite (= (not false) true)) (= $x5 true)) (= $x7 (not true)))))
-(mp (asserted $x7) (trans @x20 (rewrite (= (not true) false)) (= $x7 false)) false))))))))
+(let ((@x33 (monotonicity (|elim-unused| (= $x6 false)) (= $x5 (not false)))))
+(let ((@x40 (monotonicity (trans @x33 (rewrite (= (not false) true)) (= $x5 true)) (= $x7 (not true)))))
+(let ((@x44 (trans @x40 (rewrite (= (not true) false)) (= $x7 false))))
+(mp (asserted $x7) @x44 false)))))))))
 
-531451869d81515a9a811b564209ab76519736be 11 0
+d02a9dcd83dfb0d3e50a887c4f5274a79c10c85e 12 0
 unsat
 ((set-logic AUFLIRA)
 (proof
@@ -1974,1707 +2113,1663 @@
 ))
 (let (($x5 (not $x6)))
 (let (($x7 (not $x5)))
-(let ((@x13 (monotonicity (|elim-unused| (= $x6 false)) (= $x5 (not false)))))
-(let ((@x20 (monotonicity (trans @x13 (rewrite (= (not false) true)) (= $x5 true)) (= $x7 (not true)))))
-(mp (asserted $x7) (trans @x20 (rewrite (= (not true) false)) (= $x7 false)) false))))))))
-
-365761b65f00d147ff0728b709645c1e95a5cb22 22 0
-unsat
-((set-logic AUFLIA)
-(proof
-(let (($x54 (forall ((?v0 Int) )(<= ?v0 0))
-))
-(let (($x46 (forall ((?v0 Int) )(let (($x11 (<= ?v0 0)))
-(let (($x12 (not $x11)))
-(not $x12))))
-))
-(let ((@x56 (|quant-intro| (rewrite (= (not (not (<= ?0 0))) (<= ?0 0))) (= $x46 $x54))))
-(let (($x15 (exists ((?v0 Int) )(let (($x11 (<= ?v0 0)))
-(not $x11)))
-))
-(let (($x18 (not $x15)))
-(let ((@x48 (|nnf-neg| (refl (|~| (not (not (<= ?0 0))) (not (not (<= ?0 0))))) (|~| $x18 $x46))))
-(let (($x8 (exists ((?v0 Int) )(< 0 ?v0))
-))
-(let (($x9 (not $x8)))
-(let ((@x17 (|quant-intro| (rewrite (= (< 0 ?0) (not (<= ?0 0)))) (= $x8 $x15))))
-(let ((@x24 (mp (mp (asserted $x9) (monotonicity @x17 (= $x9 $x18)) $x18) (|rewrite*| (= $x18 $x18)) $x18)))
-(mp (mp (|mp~| @x24 @x48 $x46) @x56 $x54) (rewrite (= $x54 false)) false)))))))))))))
+(let ((@x33 (monotonicity (|elim-unused| (= $x6 false)) (= $x5 (not false)))))
+(let ((@x40 (monotonicity (trans @x33 (rewrite (= (not false) true)) (= $x5 true)) (= $x7 (not true)))))
+(let ((@x44 (trans @x40 (rewrite (= (not true) false)) (= $x7 false))))
+(mp (asserted $x7) @x44 false)))))))))
 
-a524cbe0a36c63dd22a617bca8ac628c3c4e0003 22 0
-unsat
-((set-logic AUFLIRA)
-(proof
-(let (($x54 (forall ((?v0 Real) )(<= ?v0 0.0))
-))
-(let (($x46 (forall ((?v0 Real) )(let (($x11 (<= ?v0 0.0)))
-(let (($x12 (not $x11)))
-(not $x12))))
-))
-(let ((@x56 (|quant-intro| (rewrite (= (not (not (<= ?0 0.0))) (<= ?0 0.0))) (= $x46 $x54))))
-(let (($x15 (exists ((?v0 Real) )(let (($x11 (<= ?v0 0.0)))
-(not $x11)))
-))
-(let (($x18 (not $x15)))
-(let ((@x48 (|nnf-neg| (refl (|~| (not (not (<= ?0 0.0))) (not (not (<= ?0 0.0))))) (|~| $x18 $x46))))
-(let (($x8 (exists ((?v0 Real) )(< 0.0 ?v0))
-))
-(let (($x9 (not $x8)))
-(let ((@x17 (|quant-intro| (rewrite (= (< 0.0 ?0) (not (<= ?0 0.0)))) (= $x8 $x15))))
-(let ((@x24 (mp (mp (asserted $x9) (monotonicity @x17 (= $x9 $x18)) $x18) (|rewrite*| (= $x18 $x18)) $x18)))
-(mp (mp (|mp~| @x24 @x48 $x46) @x56 $x54) (rewrite (= $x54 false)) false)))))))))))))
-
-52fc23e5db1b35bf2465aff4abeba68b99d17123 40 0
-unsat
-((set-logic AUFLIA)
-(declare-fun ?v0!0 () Int)
-(proof
-(let (($x89 (forall ((?v1 Int) )(<= (+ ?v1 (* (~ 1) ?v0!0)) 0))
-))
-(let (($x79 (forall ((?v1 Int) )(not (not (<= (+ ?v1 (* (~ 1) ?v0!0)) 0))))
-))
-(let (($x70 (<= (+ ?0 (* (~ 1) ?v0!0)) 0)))
-(let (($x76 (not (not $x70))))
-(let (($x61 (forall ((?v0 Int) )(exists ((?v1 Int) )(not (<= (+ ?v1 (* (~ 1) ?v0)) 0)))
-)
-))
-(let (($x64 (not $x61)))
-(let (($x72 (exists ((?v1 Int) )(let (($x70 (<= (+ ?v1 (* (~ 1) ?v0!0)) 0)))
-(not $x70)))
-))
-(let ((@x83 (trans (sk (|~| $x64 (not $x72))) (|nnf-neg| (refl (|~| $x76 $x76)) (|~| (not $x72) $x79)) (|~| $x64 $x79))))
-(let (($x19 (forall ((?v0 Int) )(exists ((?v1 Int) )(not (<= ?v1 ?v0)))
-)
-))
-(let (($x22 (not $x19)))
-(let (($x58 (exists ((?v1 Int) )(not (<= (+ ?v1 (* (~ 1) ?0)) 0)))
-))
-(let (($x16 (exists ((?v1 Int) )(not (<= ?v1 ?0)))
-))
-(let ((@x57 (monotonicity (rewrite (= (<= ?0 ?1) (<= (+ ?0 (* (~ 1) ?1)) 0))) (= (not (<= ?0 ?1)) (not (<= (+ ?0 (* (~ 1) ?1)) 0))))))
-(let ((@x66 (monotonicity (|quant-intro| (|quant-intro| @x57 (= $x16 $x58)) (= $x19 $x61)) (= $x22 $x64))))
-(let (($x9 (forall ((?v0 Int) )(exists ((?v1 Int) )(< ?v0 ?v1))
-)
-))
-(let (($x10 (not $x9)))
-(let (($x8 (exists ((?v1 Int) )(< ?0 ?v1))
-))
-(let ((@x18 (|quant-intro| (rewrite (= (< ?1 ?0) (not (<= ?0 ?1)))) (= $x8 $x16))))
-(let ((@x25 (mp (asserted $x10) (monotonicity (|quant-intro| @x18 (= $x9 $x19)) (= $x10 $x22)) $x22)))
-(let ((@x84 (|mp~| (mp (mp @x25 (|rewrite*| (= $x22 $x22)) $x22) @x66 $x64) @x83 $x79)))
-(let ((@x85 (mp @x84 (|quant-intro| (rewrite (= $x76 $x70)) (= $x79 $x89)) $x89)))
-(mp @x85 (rewrite (= $x89 false)) false))))))))))))))))))))))))
-
-750c85c0e2958b1508ba7c582f2bdbbb46fc0552 20 0
+1a820d07cf476448545d144873b309b9cfc3a238 2 0
+unknown
+(error "line 6 column 10: proof is not available")
+23ed6364c527ef515dd659de8b496cfd59df4ec7 2 0
+unknown
+(error "line 6 column 10: proof is not available")
+9722ff2e938783a69202c957c858fb219ec0cdb0 2 0
+unknown
+(error "line 6 column 10: proof is not available")
+cb87115705dc568881932b35aa82751f3f97049c 22 0
 unsat
 ((set-logic AUFLIA)
 (declare-fun ?v1!0 () Int)
 (declare-fun ?v0!1 () Int)
 (proof
-(let (($x58 (or (not (and (= ?v0!1 0) (= ?v1!0 1))) (not (= ?v0!1 ?v1!0)))))
-(let (($x22 (forall ((?v0 Int) (?v1 Int) )(or (not (and (= ?v0 0) (= ?v1 1))) (not (= ?v0 ?v1))))
+(let (($x51 (= ?v1!0 1)))
+(let (($x57 (not (or (not (and (= ?v0!1 0) $x51)) (not (= ?v0!1 ?v1!0))))))
+(let (($x41 (forall ((?v0 Int) (?v1 Int) )(or (not (and (= ?v0 0) (= ?v1 1))) (not (= ?v0 ?v1))))
 ))
-(let (($x25 (not $x22)))
+(let (($x44 (not $x41)))
 (let (($x15 (forall ((?v0 Int) (?v1 Int) )(=> (and (= ?v0 0) (= ?v1 1)) (not (= ?v0 ?v1))))
 ))
 (let (($x16 (not $x15)))
-(let (($x20 (= (=> (and (= ?1 0) (= ?0 1)) (not (= ?1 ?0))) (or (not (and (= ?1 0) (= ?0 1))) (not (= ?1 ?0))))))
-(let ((@x27 (monotonicity (|quant-intro| (rewrite $x20) (= $x15 $x22)) (= $x16 $x25))))
-(let ((@x62 (|mp~| (mp (mp (asserted $x16) @x27 $x25) (|rewrite*| (= $x25 $x25)) $x25) (sk (|~| $x25 (not $x58))) (not $x58))))
-(let ((@x67 (|and-elim| (|not-or-elim| @x62 (and (= ?v0!1 0) (= ?v1!0 1))) (= ?v1!0 1))))
-(let ((@x66 (|and-elim| (|not-or-elim| @x62 (and (= ?v0!1 0) (= ?v1!0 1))) (= ?v0!1 0))))
-(let ((@x70 (trans (symm @x66 (= 0 ?v0!1)) (|not-or-elim| @x62 (= ?v0!1 ?v1!0)) (= 0 ?v1!0))))
-(mp (trans @x70 @x67 (= 0 1)) (rewrite (= (= 0 1) false)) false))))))))))))))
+(let (($x39 (= (=> (and (= ?1 0) (= ?0 1)) (not (= ?1 ?0))) (or (not (and (= ?1 0) (= ?0 1))) (not (= ?1 ?0))))))
+(let ((@x46 (monotonicity (|quant-intro| (rewrite $x39) (= $x15 $x41)) (= $x16 $x44))))
+(let ((@x63 (|not-or-elim| (|mp~| (mp (asserted $x16) @x46 $x44) (sk (|~| $x44 $x57)) $x57) (and (= ?v0!1 0) $x51))))
+(let ((@x65 (|and-elim| @x63 $x51)))
+(let (($x54 (= ?v0!1 ?v1!0)))
+(let ((@x66 (|not-or-elim| (|mp~| (mp (asserted $x16) @x46 $x44) (sk (|~| $x44 $x57)) $x57) $x54)))
+(let ((@x68 (trans (symm (|and-elim| @x63 (= ?v0!1 0)) (= 0 ?v0!1)) @x66 (= 0 ?v1!0))))
+(mp (trans @x68 @x65 (= 0 1)) (rewrite (= (= 0 1) false)) false))))))))))))))))
 
-76c68fc9857d9b1bea2540fac5de5d93a85faffa 30 0
+d2d0a7794c4de3708d5541374fd9e0075ad5fa36 55 0
 unsat
 ((set-logic AUFLIA)
 (proof
 (let (($x14 (exists ((?v0 Int) )(forall ((?v1 Int) )(let (($x10 (<= 0 ?v1)))
-(let (($x11 (or (< ?v1 0) $x10)))
-(=> (< ?v0 ?v1) $x11))))
+(let (($x9 (< ?v1 0)))
+(let (($x11 (or $x9 $x10)))
+(let (($x7 (< ?v0 ?v1)))
+(=> $x7 $x11))))))
 )
 ))
 (let (($x15 (not $x14)))
-(let (($x50 (exists ((?v0 Int) )true)
+(let (($x43 (exists ((?v0 Int) )(forall ((?v1 Int) )(let (($x10 (<= 0 ?v1)))
+(let (($x9 (< ?v1 0)))
+(let (($x11 (or $x9 $x10)))
+(let (($x7 (< ?v0 ?v1)))
+(let (($x36 (not $x7)))
+(or $x36 $x11)))))))
+)
 ))
-(let (($x13 (forall ((?v1 Int) )(let (($x10 (<= 0 ?v1)))
-(let (($x11 (or (< ?v1 0) $x10)))
-(=> (< ?0 ?v1) $x11))))
+(let (($x46 (not $x43)))
+(let (($x86 (exists ((?v0 Int) )true)
 ))
-(let (($x43 (forall ((?v1 Int) )true)
+(let (($x40 (forall ((?v1 Int) )(let (($x10 (<= 0 ?v1)))
+(let (($x9 (< ?v1 0)))
+(let (($x11 (or $x9 $x10)))
+(let (($x7 (< ?0 ?v1)))
+(let (($x36 (not $x7)))
+(or $x36 $x11)))))))
+))
+(let (($x79 (forall ((?v1 Int) )true)
 ))
 (let (($x10 (<= 0 ?0)))
-(let (($x11 (or (< ?0 0) $x10)))
-(let (($x12 (=> (< ?1 ?0) $x11)))
-(let ((@x28 (trans (rewrite (= (< ?0 0) (not $x10))) (monotonicity (rewrite (= $x10 $x10)) (= (not $x10) (not $x10))) (= (< ?0 0) (not $x10)))))
-(let ((@x31 (monotonicity @x28 (rewrite (= $x10 $x10)) (= $x11 (or (not $x10) $x10)))))
-(let ((@x35 (trans @x31 (rewrite (= (or (not $x10) $x10) true)) (= $x11 true))))
-(let ((@x38 (monotonicity (rewrite (= (< ?1 ?0) (not (<= ?0 ?1)))) @x35 (= $x12 (=> (not (<= ?0 ?1)) true)))))
-(let ((@x42 (trans @x38 (rewrite (= (=> (not (<= ?0 ?1)) true) true)) (= $x12 true))))
-(let ((@x49 (trans (|quant-intro| @x42 (= $x13 $x43)) (|elim-unused| (= $x43 true)) (= $x13 true))))
-(let ((@x56 (trans (|quant-intro| @x49 (= $x14 $x50)) (|elim-unused| (= $x50 true)) (= $x14 true))))
-(let ((@x63 (trans (monotonicity @x56 (= $x15 (not true))) (rewrite (= (not true) false)) (= $x15 false))))
-(mp (asserted $x15) @x63 false)))))))))))))))))))
+(let (($x9 (< ?0 0)))
+(let (($x11 (or $x9 $x10)))
+(let (($x7 (< ?1 ?0)))
+(let (($x36 (not $x7)))
+(let (($x37 (or $x36 $x11)))
+(let (($x58 (<= (+ ?0 (* (~ 1) ?1)) 0)))
+(let ((@x76 (rewrite (= (or $x58 (or (not (>= ?0 0)) (>= ?0 0))) true))))
+(let ((@x71 (monotonicity (rewrite (= $x9 (not (>= ?0 0)))) (rewrite (= $x10 (>= ?0 0))) (= $x11 (or (not (>= ?0 0)) (>= ?0 0))))))
+(let ((@x64 (monotonicity (rewrite (= $x7 (not $x58))) (= $x36 (not (not $x58))))))
+(let ((@x74 (monotonicity (trans @x64 (rewrite (= (not (not $x58)) $x58)) (= $x36 $x58)) @x71 (= $x37 (or $x58 (or (not (>= ?0 0)) (>= ?0 0)))))))
+(let ((@x85 (trans (|quant-intro| (trans @x74 @x76 (= $x37 true)) (= $x40 $x79)) (|elim-unused| (= $x79 true)) (= $x40 true))))
+(let ((@x92 (trans (|quant-intro| @x85 (= $x43 $x86)) (|elim-unused| (= $x86 true)) (= $x43 true))))
+(let ((@x99 (trans (monotonicity @x92 (= $x46 (not true))) (rewrite (= (not true) false)) (= $x46 false))))
+(let (($x13 (forall ((?v1 Int) )(let (($x10 (<= 0 ?v1)))
+(let (($x9 (< ?v1 0)))
+(let (($x11 (or $x9 $x10)))
+(let (($x7 (< ?0 ?v1)))
+(=> $x7 $x11))))))
+))
+(let ((@x45 (|quant-intro| (|quant-intro| (rewrite (= (=> $x7 $x11) $x37)) (= $x13 $x40)) (= $x14 $x43))))
+(let ((@x48 (monotonicity @x45 (= $x15 $x46))))
+(mp (asserted $x15) (trans @x48 @x99 (= $x15 false)) false)))))))))))))))))))))))))))
 
-a26ec0d452d6ecde84fa66db969e7d6c80150605 38 0
+75e4df9c205f7c15d7e530b5e1e97635aed16d82 42 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let (($x47 (forall ((?v0 Int) (?v1 Int) )(let ((?x22 (+ 1 (* 2 ?v0))))
-(let ((?x12 (* 2 ?v1)))
-(let (($x28 (<= ?x12 ?x22)))
-(let (($x29 (not $x28)))
-(let (($x18 (<= ?v1 ?v0)))
-(or $x18 $x29)))))))
-))
-(let (($x50 (not $x47)))
-(let (($x95 (forall ((?v0 Int) (?v1 Int) )true)
-))
-(let ((?x22 (+ 1 (* 2 ?1))))
-(let ((?x12 (* 2 ?0)))
-(let (($x28 (<= ?x12 ?x22)))
-(let (($x29 (not $x28)))
-(let (($x18 (<= ?0 ?1)))
-(let (($x42 (or $x18 $x29)))
-(let (($x79 (>= (+ ?1 (* (~ 1) ?0)) 0)))
-(let ((@x90 (monotonicity (rewrite (= $x18 $x79)) (monotonicity (rewrite (= $x28 $x79)) (= $x29 (not $x79))) (= $x42 (or $x79 (not $x79))))))
-(let ((@x94 (trans @x90 (rewrite (= (or $x79 (not $x79)) true)) (= $x42 true))))
-(let ((@x101 (trans (|quant-intro| @x94 (= $x47 $x95)) (|elim-unused| (= $x95 true)) (= $x47 true))))
-(let ((@x108 (trans (monotonicity @x101 (= $x50 (not true))) (rewrite (= (not true) false)) (= $x50 false))))
 (let (($x15 (forall ((?v0 Int) (?v1 Int) )(let ((?x12 (* 2 ?v1)))
-(let (($x13 (< (+ (* 2 ?v0) 1) ?x12)))
-(=> (< ?v0 ?v1) $x13))))
+(let ((?x9 (* 2 ?v0)))
+(let ((?x11 (+ ?x9 1)))
+(let (($x13 (< ?x11 ?x12)))
+(let (($x7 (< ?v0 ?v1)))
+(=> $x7 $x13)))))))
 ))
 (let (($x16 (not $x15)))
-(let (($x13 (< (+ (* 2 ?1) 1) ?x12)))
-(let (($x14 (=> (< ?1 ?0) $x13)))
-(let ((@x27 (monotonicity (rewrite (= (+ (* 2 ?1) 1) ?x22)) (= $x13 (< ?x22 ?x12)))))
-(let ((@x38 (trans (trans @x27 (rewrite (= (< ?x22 ?x12) $x29)) (= $x13 $x29)) (monotonicity (rewrite (= $x28 $x28)) (= $x29 $x29)) (= $x13 $x29))))
-(let ((@x41 (monotonicity (rewrite (= (< ?1 ?0) (not $x18))) @x38 (= $x14 (=> (not $x18) $x29)))))
-(let ((@x46 (trans @x41 (rewrite (= (=> (not $x18) $x29) $x42)) (= $x14 $x42))))
-(let ((@x53 (mp (asserted $x16) (monotonicity (|quant-intro| @x46 (= $x15 $x47)) (= $x16 $x50)) $x50)))
-(mp (mp @x53 (|rewrite*| (= $x50 $x50)) $x50) @x108 false))))))))))))))))))))))))))
+(let (($x53 (forall ((?v0 Int) (?v1 Int) )(let ((?x12 (* 2 ?v1)))
+(let ((?x9 (* 2 ?v0)))
+(let ((?x38 (+ 1 ?x9)))
+(let (($x41 (< ?x38 ?x12)))
+(let (($x7 (< ?v0 ?v1)))
+(let (($x47 (not $x7)))
+(or $x47 $x41))))))))
+))
+(let (($x56 (not $x53)))
+(let (($x82 (forall ((?v0 Int) (?v1 Int) )true)
+))
+(let ((?x12 (* 2 ?0)))
+(let ((?x9 (* 2 ?1)))
+(let ((?x38 (+ 1 ?x9)))
+(let (($x41 (< ?x38 ?x12)))
+(let (($x7 (< ?1 ?0)))
+(let (($x47 (not $x7)))
+(let (($x48 (or $x47 $x41)))
+(let (($x61 (>= (+ ?1 (* (~ 1) ?0)) 0)))
+(let (($x60 (not $x61)))
+(let ((@x72 (trans (monotonicity (rewrite (= $x7 $x60)) (= $x47 (not $x60))) (rewrite (= (not $x60) $x61)) (= $x47 $x61))))
+(let ((@x77 (monotonicity @x72 (rewrite (= $x41 $x60)) (= $x48 (or $x61 $x60)))))
+(let ((@x84 (|quant-intro| (trans @x77 (rewrite (= (or $x61 $x60) true)) (= $x48 true)) (= $x53 $x82))))
+(let ((@x91 (monotonicity (trans @x84 (|elim-unused| (= $x82 true)) (= $x53 true)) (= $x56 (not true)))))
+(let ((@x95 (trans @x91 (rewrite (= (not true) false)) (= $x56 false))))
+(let ((@x43 (monotonicity (rewrite (= (+ ?x9 1) ?x38)) (= (< (+ ?x9 1) ?x12) $x41))))
+(let ((@x46 (monotonicity @x43 (= (=> $x7 (< (+ ?x9 1) ?x12)) (=> $x7 $x41)))))
+(let ((@x52 (trans @x46 (rewrite (= (=> $x7 $x41) $x48)) (= (=> $x7 (< (+ ?x9 1) ?x12)) $x48))))
+(let ((@x58 (monotonicity (|quant-intro| @x52 (= $x15 $x53)) (= $x16 $x56))))
+(mp (asserted $x16) (trans @x58 @x95 (= $x16 false)) false))))))))))))))))))))))))))
 
-bd9c4497c082a3945939358cc22879f4906afd6a 29 0
+591a3beb5d84c4e2d6724bf947c2fd4fa44c6bbc 32 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let (($x33 (forall ((?v0 Int) (?v1 Int) )(let ((?x8 (* 2 ?v0)))
-(let (($x25 (= ?x8 (+ (~ 1) (* 2 ?v1)))))
-(not $x25))))
-))
-(let (($x36 (not $x33)))
-(let (($x72 (forall ((?v0 Int) (?v1 Int) )true)
-))
-(let ((?x8 (* 2 ?1)))
-(let (($x25 (= ?x8 (+ (~ 1) (* 2 ?0)))))
-(let (($x30 (not $x25)))
-(let ((@x71 (trans (monotonicity (rewrite (= $x25 false)) (= $x30 (not false))) (rewrite (= (not false) true)) (= $x30 true))))
-(let ((@x78 (trans (|quant-intro| @x71 (= $x33 $x72)) (|elim-unused| (= $x72 true)) (= $x33 true))))
-(let ((@x85 (trans (monotonicity @x78 (= $x36 (not true))) (rewrite (= (not true) false)) (= $x36 false))))
 (let (($x14 (forall ((?v0 Int) (?v1 Int) )(let ((?x11 (* 2 ?v1)))
-(let (($x12 (= (+ (* 2 ?v0) 1) ?x11)))
-(not $x12))))
+(let ((?x8 (* 2 ?v0)))
+(let ((?x10 (+ ?x8 1)))
+(let (($x12 (= ?x10 ?x11)))
+(not $x12))))))
 ))
 (let (($x15 (not $x14)))
+(let (($x46 (forall ((?v0 Int) (?v1 Int) )(let ((?x11 (* 2 ?v1)))
+(let ((?x8 (* 2 ?v0)))
+(let ((?x37 (+ 1 ?x8)))
+(let (($x40 (= ?x37 ?x11)))
+(not $x40))))))
+))
+(let (($x49 (not $x46)))
+(let (($x61 (forall ((?v0 Int) (?v1 Int) )true)
+))
 (let ((?x11 (* 2 ?0)))
-(let (($x12 (= (+ ?x8 1) ?x11)))
-(let ((@x22 (monotonicity (rewrite (= (+ ?x8 1) (+ 1 ?x8))) (= $x12 (= (+ 1 ?x8) ?x11)))))
-(let ((@x29 (trans @x22 (rewrite (= (= (+ 1 ?x8) ?x11) $x25)) (= $x12 $x25))))
-(let ((@x35 (|quant-intro| (monotonicity @x29 (= (not $x12) $x30)) (= $x14 $x33))))
-(let ((@x42 (mp (mp (asserted $x15) (monotonicity @x35 (= $x15 $x36)) $x36) (|rewrite*| (= $x36 $x36)) $x36)))
-(mp @x42 @x85 false))))))))))))))))))))
+(let ((?x8 (* 2 ?1)))
+(let ((?x37 (+ 1 ?x8)))
+(let (($x40 (= ?x37 ?x11)))
+(let (($x43 (not $x40)))
+(let ((@x60 (trans (monotonicity (rewrite (= $x40 false)) (= $x43 (not false))) (rewrite (= (not false) true)) (= $x43 true))))
+(let ((@x67 (trans (|quant-intro| @x60 (= $x46 $x61)) (|elim-unused| (= $x61 true)) (= $x46 true))))
+(let ((@x74 (trans (monotonicity @x67 (= $x49 (not true))) (rewrite (= (not true) false)) (= $x49 false))))
+(let ((@x42 (monotonicity (rewrite (= (+ ?x8 1) ?x37)) (= (= (+ ?x8 1) ?x11) $x40))))
+(let ((@x48 (|quant-intro| (monotonicity @x42 (= (not (= (+ ?x8 1) ?x11)) $x43)) (= $x14 $x46))))
+(let ((@x51 (monotonicity @x48 (= $x15 $x49))))
+(mp (asserted $x15) (trans @x51 @x74 (= $x15 false)) false)))))))))))))))))))
 
-4561e7f574918fb0fcb2d1c3600b5565bf981ede 52 0
+ed6b5d78e5a12fb3a6471e02bc6e89ebc78c1a34 43 0
 unsat
 ((set-logic AUFLIA)
 (declare-fun ?v0!1 () Int)
 (declare-fun ?v1!0 () Int)
 (proof
-(let ((?x101 (+ ?v1!0 ?v0!1)))
-(let (($x113 (>= ?x101 2)))
-(let (($x116 (not $x113)))
-(let (($x110 (= ?x101 2)))
-(let (($x104 (<= ?x101 2)))
-(let (($x107 (not $x104)))
-(let (($x94 (or (not (<= (+ ?v0!1 ?v1!0) 2)) (= (+ ?v0!1 ?v1!0) 2) (not (>= (+ ?v0!1 ?v1!0) 2)))))
-(let (($x95 (not $x94)))
-(let ((@x103 (rewrite (= (+ ?v0!1 ?v1!0) ?x101))))
-(let ((@x118 (monotonicity (monotonicity @x103 (= (>= (+ ?v0!1 ?v1!0) 2) $x113)) (= (not (>= (+ ?v0!1 ?v1!0) 2)) $x116))))
-(let ((@x109 (monotonicity (monotonicity @x103 (= (<= (+ ?v0!1 ?v1!0) 2) $x104)) (= (not (<= (+ ?v0!1 ?v1!0) 2)) $x107))))
-(let ((@x121 (monotonicity @x109 (monotonicity @x103 (= (= (+ ?v0!1 ?v1!0) 2) $x110)) @x118 (= $x94 (or $x107 $x110 $x116)))))
-(let (($x80 (forall ((?v0 Int) (?v1 Int) )(let ((?x8 (+ ?v0 ?v1)))
+(let ((?x78 (+ ?v1!0 ?v0!1)))
+(let (($x90 (>= ?x78 2)))
+(let (($x93 (not $x90)))
+(let (($x87 (= ?x78 2)))
+(let (($x81 (<= ?x78 2)))
+(let (($x84 (not $x81)))
+(let (($x71 (or (not (<= (+ ?v0!1 ?v1!0) 2)) (= (+ ?v0!1 ?v1!0) 2) (not (>= (+ ?v0!1 ?v1!0) 2)))))
+(let (($x72 (not $x71)))
+(let ((@x80 (rewrite (= (+ ?v0!1 ?v1!0) ?x78))))
+(let ((@x95 (monotonicity (monotonicity @x80 (= (>= (+ ?v0!1 ?v1!0) 2) $x90)) (= (not (>= (+ ?v0!1 ?v1!0) 2)) $x93))))
+(let ((@x86 (monotonicity (monotonicity @x80 (= (<= (+ ?v0!1 ?v1!0) 2) $x81)) (= (not (<= (+ ?v0!1 ?v1!0) 2)) $x84))))
+(let ((@x98 (monotonicity @x86 (monotonicity @x80 (= (= (+ ?v0!1 ?v1!0) 2) $x87)) @x95 (= $x71 (or $x84 $x87 $x93)))))
+(let (($x58 (forall ((?v0 Int) (?v1 Int) )(let (($x39 (not (>= (+ ?v0 ?v1) 2))))
+(let ((?x8 (+ ?v0 ?v1)))
 (let (($x10 (= ?x8 2)))
-(let (($x18 (not (<= ?x8 2))))
-(or $x18 $x10 (not (>= ?x8 2)))))))
+(let (($x44 (not (<= ?x8 2))))
+(or $x44 $x10 $x39))))))
 ))
-(let (($x83 (not $x80)))
-(let (($x41 (forall ((?v0 Int) (?v1 Int) )(let ((?x8 (+ ?v0 ?v1)))
-(let (($x21 (<= 2 ?x8)))
-(let (($x22 (not $x21)))
-(let (($x10 (= ?x8 2)))
-(let (($x18 (not (<= ?x8 2))))
-(or $x18 $x10 $x22)))))))
-))
-(let (($x44 (not $x41)))
-(let ((?x8 (+ ?1 ?0)))
-(let (($x10 (= ?x8 2)))
-(let (($x18 (not (<= ?x8 2))))
-(let (($x21 (<= 2 ?x8)))
-(let (($x22 (not $x21)))
-(let (($x36 (or $x18 $x10 $x22)))
-(let ((@x76 (monotonicity (rewrite (= $x21 (>= ?x8 2))) (= $x22 (not (>= ?x8 2))))))
-(let ((@x82 (|quant-intro| (monotonicity @x76 (= $x36 (or $x18 $x10 (not (>= ?x8 2))))) (= $x41 $x80))))
+(let (($x61 (not $x58)))
 (let (($x14 (forall ((?v0 Int) (?v1 Int) )(or (< 2 (+ ?v0 ?v1)) (or (= (+ ?v0 ?v1) 2) (< (+ ?v0 ?v1) 2))))
 ))
 (let (($x15 (not $x14)))
+(let (($x39 (not (>= (+ ?1 ?0) 2))))
+(let ((?x8 (+ ?1 ?0)))
+(let (($x10 (= ?x8 2)))
+(let (($x44 (not (<= ?x8 2))))
+(let (($x53 (or $x44 $x10 $x39)))
 (let (($x13 (or (< 2 ?x8) (or $x10 (< ?x8 2)))))
-(let ((@x29 (trans (rewrite (= (< ?x8 2) $x22)) (monotonicity (rewrite (= $x21 $x21)) (= $x22 $x22)) (= (< ?x8 2) $x22))))
-(let ((@x35 (monotonicity (rewrite (= (< 2 ?x8) $x18)) (monotonicity @x29 (= (or $x10 (< ?x8 2)) (or $x10 $x22))) (= $x13 (or $x18 (or $x10 $x22))))))
-(let ((@x40 (trans @x35 (rewrite (= (or $x18 (or $x10 $x22)) $x36)) (= $x13 $x36))))
-(let ((@x47 (mp (asserted $x15) (monotonicity (|quant-intro| @x40 (= $x14 $x41)) (= $x15 $x44)) $x44)))
-(let ((@x86 (mp (mp @x47 (|rewrite*| (= $x44 $x44)) $x44) (monotonicity @x82 (= $x44 $x83)) $x83)))
-(let ((@x99 (mp (|mp~| @x86 (sk (|~| $x83 $x95)) $x95) (monotonicity @x121 (= $x95 (not (or $x107 $x110 $x116)))) (not (or $x107 $x110 $x116)))))
-(let ((@x131 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x110 $x107 $x116)) (|not-or-elim| @x99 $x104) (or $x110 $x116))))
-(|unit-resolution| @x131 (|not-or-elim| @x99 $x113) (|not-or-elim| @x99 (not $x110)) false)))))))))))))))))))))))))))))))))))))
+(let ((@x49 (monotonicity (rewrite (= (< ?x8 2) $x39)) (= (or $x10 (< ?x8 2)) (or $x10 $x39)))))
+(let ((@x52 (monotonicity (rewrite (= (< 2 ?x8) $x44)) @x49 (= $x13 (or $x44 (or $x10 $x39))))))
+(let ((@x57 (trans @x52 (rewrite (= (or $x44 (or $x10 $x39)) $x53)) (= $x13 $x53))))
+(let ((@x64 (mp (asserted $x15) (monotonicity (|quant-intro| @x57 (= $x14 $x58)) (= $x15 $x61)) $x61)))
+(let ((@x76 (mp (|mp~| @x64 (sk (|~| $x61 $x72)) $x72) (monotonicity @x98 (= $x72 (not (or $x84 $x87 $x93)))) (not (or $x84 $x87 $x93)))))
+(let ((@x103 (|not-or-elim| @x76 (not $x87))))
+(let ((@x104 (|not-or-elim| @x76 $x90)))
+(let ((@x77 (|not-or-elim| @x76 $x81)))
+(|unit-resolution| (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x87 $x84 $x93)) @x77 (or $x87 $x93)) @x104 @x103 false)))))))))))))))))))))))))))))))))
 
-230760924531c91da933509839308feff344fdd2 50 0
+092a8c0984dc61be1fab786d699cb79093b7c5f2 46 0
 unsat
 ((set-logic AUFLIA)
 (declare-fun ?v0!0 () Int)
 (proof
-(let (($x103 (<= ?v0!0 0)))
-(let (($x106 (<= ?v0!0 (~ 1))))
-(let (($x107 (not $x106)))
-(let ((@x125 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x107 $x103)) (hypothesis (not $x103)) $x107)))
-(let (($x96 (forall ((?v0 Int) )(let (($x36 (not (<= ?v0 (~ 1)))))
-(let (($x16 (<= ?v0 0)))
-(ite $x16 (not (>= ?v0 1)) $x36))))
+(let (($x81 (<= ?v0!0 0)))
+(let (($x84 (<= ?v0!0 (~ 1))))
+(let (($x85 (not $x84)))
+(let ((@x103 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x85 $x81)) (hypothesis (not $x81)) $x85)))
+(let (($x82 (>= ?v0!0 1)))
+(let (($x83 (not $x82)))
+(let (($x86 (ite $x81 $x83 $x85)))
+(let (($x87 (not $x86)))
+(let (($x71 (forall ((?v0 Int) )(let (($x56 (not (<= ?v0 (~ 1)))))
+(let (($x59 (not (>= ?v0 1))))
+(ite (<= ?v0 0) $x59 $x56))))
 ))
-(let (($x99 (not $x96)))
-(let (($x58 (forall ((?v0 Int) )(let (($x36 (not (<= ?v0 (~ 1)))))
-(let (($x41 (<= 1 ?v0)))
-(let (($x42 (not $x41)))
-(let (($x16 (<= ?v0 0)))
-(ite $x16 $x42 $x36))))))
-))
-(let (($x61 (not $x58)))
-(let (($x36 (not (<= ?0 (~ 1)))))
-(let (($x41 (<= 1 ?0)))
-(let (($x42 (not $x41)))
-(let (($x16 (<= ?0 0)))
-(let (($x53 (ite $x16 $x42 $x36)))
-(let ((@x92 (monotonicity (rewrite (= $x41 (>= ?0 1))) (= $x42 (not (>= ?0 1))))))
-(let ((@x98 (|quant-intro| (monotonicity @x92 (= $x53 (ite $x16 (not (>= ?0 1)) $x36))) (= $x58 $x96))))
-(let (($x13 (forall ((?v0 Int) )(let (($x10 (< 0 (+ ?v0 1))))
-(ite (< 0 ?v0) $x10 (< ?v0 1))))
+(let (($x74 (not $x71)))
+(let (($x13 (forall ((?v0 Int) )(let (($x11 (< ?v0 1)))
+(let (($x7 (< 0 ?v0)))
+(ite $x7 (< 0 (+ ?v0 1)) $x11))))
 ))
 (let (($x14 (not $x13)))
-(let (($x10 (< 0 (+ ?0 1))))
-(let (($x12 (ite (< 0 ?0) $x10 (< ?0 1))))
-(let ((@x49 (trans (rewrite (= (< ?0 1) $x42)) (monotonicity (rewrite (= $x41 $x41)) (= $x42 $x42)) (= (< ?0 1) $x42))))
-(let ((@x38 (monotonicity (rewrite (= (<= (+ 1 ?0) 0) (<= ?0 (~ 1)))) (= (not (<= (+ 1 ?0) 0)) $x36))))
-(let ((@x29 (rewrite (= (< 0 (+ 1 ?0)) (not (<= (+ 1 ?0) 0))))))
-(let ((@x25 (monotonicity (rewrite (= (+ ?0 1) (+ 1 ?0))) (= $x10 (< 0 (+ 1 ?0))))))
-(let ((@x40 (trans (trans @x25 @x29 (= $x10 (not (<= (+ 1 ?0) 0)))) @x38 (= $x10 $x36))))
-(let ((@x52 (monotonicity (rewrite (= (< 0 ?0) (not $x16))) @x40 @x49 (= $x12 (ite (not $x16) $x36 $x42)))))
-(let ((@x57 (trans @x52 (rewrite (= (ite (not $x16) $x36 $x42) $x53)) (= $x12 $x53))))
-(let ((@x64 (mp (asserted $x14) (monotonicity (|quant-intro| @x57 (= $x13 $x58)) (= $x14 $x61)) $x61)))
-(let ((@x102 (mp (mp @x64 (|rewrite*| (= $x61 $x61)) $x61) (monotonicity @x98 (= $x61 $x99)) $x99)))
-(let ((@x112 (|mp~| @x102 (sk (|~| $x99 (not (ite $x103 (not (>= ?v0!0 1)) $x107)))) (not (ite $x103 (not (>= ?v0!0 1)) $x107)))))
-(let ((@x127 (|unit-resolution| (|def-axiom| (or (ite $x103 (not (>= ?v0!0 1)) $x107) $x103 $x106)) @x112 (or $x103 $x106))))
-(let ((@x129 (lemma (|unit-resolution| @x127 @x125 (hypothesis (not $x103)) false) $x103)))
-(let (($x104 (>= ?v0!0 1)))
-(let (($x105 (not $x104)))
-(let ((@x134 (|unit-resolution| (|def-axiom| (or (ite $x103 $x105 $x107) (not $x103) $x104)) @x112 (or (not $x103) $x104))))
-(|unit-resolution| @x134 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x105 (not $x103))) @x129 $x105) @x129 false)))))))))))))))))))))))))))))))))))))
+(let (($x44 (forall ((?v0 Int) )(let (($x11 (< ?v0 1)))
+(let (($x38 (< 0 (+ 1 ?v0))))
+(let (($x7 (< 0 ?v0)))
+(ite $x7 $x38 $x11)))))
+))
+(let (($x56 (not (<= ?0 (~ 1)))))
+(let (($x59 (not (>= ?0 1))))
+(let (($x66 (ite (<= ?0 0) $x59 $x56)))
+(let (($x11 (< ?0 1)))
+(let (($x38 (< 0 (+ 1 ?0))))
+(let (($x7 (< 0 ?0)))
+(let (($x41 (ite $x7 $x38 $x11)))
+(let ((@x65 (monotonicity (rewrite (= $x7 (not (<= ?0 0)))) (rewrite (= $x38 $x56)) (rewrite (= $x11 $x59)) (= $x41 (ite (not (<= ?0 0)) $x56 $x59)))))
+(let ((@x70 (trans @x65 (rewrite (= (ite (not (<= ?0 0)) $x56 $x59) $x66)) (= $x41 $x66))))
+(let ((@x76 (monotonicity (|quant-intro| @x70 (= $x44 $x71)) (= (not $x44) $x74))))
+(let ((@x40 (monotonicity (rewrite (= (+ ?0 1) (+ 1 ?0))) (= (< 0 (+ ?0 1)) $x38))))
+(let ((@x43 (monotonicity @x40 (= (ite $x7 (< 0 (+ ?0 1)) $x11) $x41))))
+(let ((@x49 (monotonicity (|quant-intro| @x43 (= $x13 $x44)) (= $x14 (not $x44)))))
+(let ((@x90 (|mp~| (mp (asserted $x14) (trans @x49 @x76 (= $x14 $x74)) $x74) (sk (|~| $x74 $x87)) $x87)))
+(let ((@x106 (|unit-resolution| (|unit-resolution| (|def-axiom| (or $x86 $x81 $x84)) @x90 (or $x81 $x84)) @x103 (hypothesis (not $x81)) false)))
+(let ((@x107 (lemma @x106 $x81)))
+(let ((@x112 (|unit-resolution| (|def-axiom| (or $x86 (not $x81) $x82)) @x90 (or (not $x81) $x82))))
+(|unit-resolution| @x112 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x83 (not $x81))) @x107 $x83) @x107 false)))))))))))))))))))))))))))))))))
 
-1e9c0d6f38cf8e68fc9ae85612e77618e349b0b4 40 0
+a5ac1b17c244dd3aef6c7c1289500bca02b482d0 2 0
+unknown
+(error "line 6 column 10: proof is not available")
+f697308f77e23a8625c050b2aa7a7f131faf390d 2 0
+unknown
+(error "line 6 column 10: proof is not available")
+ad02a5379962c0c41aaf5c95191947c03228f5e6 39 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let (($x80 (forall ((?v0 Int) )(let (($x24 (not (<= ?v0 0))))
-(or (not (>= ?v0 0)) $x24)))
-))
-(let (($x479 (not $x80)))
-(let (($x89 (not (<= 0 0))))
-(let (($x164 (not (>= 0 0))))
-(let (($x175 (or $x164 $x89)))
-(let (($x140 (or $x479 $x175)))
-(let ((@x501 (monotonicity (rewrite (= (<= 0 0) true)) (= $x89 (not true)))))
-(let ((@x160 (monotonicity (rewrite (= (>= 0 0) true)) (= $x164 (not true)))))
-(let ((@x156 (monotonicity (trans @x160 (rewrite (= (not true) false)) (= $x164 false)) (trans @x501 (rewrite (= (not true) false)) (= $x89 false)) (= $x175 (or false false)))))
-(let ((@x137 (trans @x156 (rewrite (= (or false false) false)) (= $x175 false))))
-(let ((@x484 (trans (monotonicity @x137 (= $x140 (or $x479 false))) (rewrite (= (or $x479 false) $x479)) (= $x140 $x479))))
-(let (($x24 (not (<= ?0 0))))
-(let (($x77 (or (not (>= ?0 0)) $x24)))
-(let (($x30 (forall ((?v0 Int) )(let (($x24 (not (<= ?v0 0))))
-(let (($x14 (<= 0 ?v0)))
-(let (($x15 (not $x14)))
-(or $x15 $x24)))))
+(let (($x16 (exists ((?v0 Int) (?v1 Int) (?v2 Int) )(let ((?x11 (- 6)))
+(let ((?x12 (* ?x11 ?v1)))
+(let ((?x9 (* 4 ?v0)))
+(let ((?x13 (+ ?x9 ?x12)))
+(= ?x13 1))))))
 ))
-(let ((@x76 (monotonicity (rewrite (= (<= 0 ?0) (>= ?0 0))) (= (not (<= 0 ?0)) (not (>= ?0 0))))))
-(let ((@x82 (|quant-intro| (monotonicity @x76 (= (or (not (<= 0 ?0)) $x24) $x77)) (= $x30 $x80))))
-(let (($x10 (forall ((?v0 Int) )(or (< ?v0 0) (< 0 ?v0)))
+(let (($x7 (not $x16)))
+(let (($x17 (not $x7)))
+(let (($x59 (exists ((?v0 Int) (?v1 Int) )(let ((?x56 (* (~ 6) ?v1)))
+(let ((?x55 (* 4 ?v0)))
+(let ((?x57 (+ ?x55 ?x56)))
+(= ?x57 1)))))
 ))
-(let (($x11 (ite $x10 false true)))
-(let (($x12 (not $x11)))
-(let (($x14 (<= 0 ?0)))
-(let (($x15 (not $x14)))
-(let (($x27 (or $x15 $x24)))
-(let ((@x22 (trans (rewrite (= (< ?0 0) $x15)) (monotonicity (rewrite (= $x14 $x14)) (= $x15 $x15)) (= (< ?0 0) $x15))))
-(let ((@x29 (monotonicity @x22 (rewrite (= (< 0 ?0) $x24)) (= (or (< ?0 0) (< 0 ?0)) $x27))))
-(let ((@x35 (monotonicity (|quant-intro| @x29 (= $x10 $x30)) (= $x11 (ite $x30 false true)))))
-(let ((@x40 (trans @x35 (rewrite (= (ite $x30 false true) (not $x30))) (= $x11 (not $x30)))))
-(let ((@x47 (trans (monotonicity @x40 (= $x12 (not (not $x30)))) (rewrite (= (not (not $x30)) $x30)) (= $x12 $x30))))
-(let ((@x83 (mp (mp (mp (asserted $x12) @x47 $x30) (|rewrite*| (= $x30 $x30)) $x30) @x82 $x80)))
-(|unit-resolution| (|mp~| @x83 (|nnf-pos| (refl (|~| $x77 $x77)) (|~| $x80 $x80)) $x80) (mp ((_ |quant-inst| 0) $x140) @x484 $x479) false)))))))))))))))))))))))))))))))
-
-ce79a1fda8f32a486e67471071f239d5db3b39f0 47 0
-unsat
-((set-logic AUFLIA)
-(proof
-(let (($x111 (forall ((?v0 Int) )(let (($x28 (not (<= ?v0 0))))
-(or (not (>= ?v0 0)) $x28)))
+(let (($x75 (exists ((?v0 Int) (?v1 Int) )false)
 ))
-(let (($x507 (not $x111)))
-(let (($x119 (not (<= 0 0))))
-(let (($x193 (not (>= 0 0))))
-(let (($x204 (or $x193 $x119)))
-(let (($x169 (or $x507 $x204)))
-(let ((@x529 (monotonicity (rewrite (= (<= 0 0) true)) (= $x119 (not true)))))
-(let ((@x189 (monotonicity (rewrite (= (>= 0 0) true)) (= $x193 (not true)))))
-(let ((@x185 (monotonicity (trans @x189 (rewrite (= (not true) false)) (= $x193 false)) (trans @x529 (rewrite (= (not true) false)) (= $x119 false)) (= $x204 (or false false)))))
-(let ((@x166 (trans @x185 (rewrite (= (or false false) false)) (= $x204 false))))
-(let ((@x512 (trans (monotonicity @x166 (= $x169 (or $x507 false))) (rewrite (= (or $x507 false) $x507)) (= $x169 $x507))))
-(let (($x28 (not (<= ?0 0))))
-(let (($x108 (or (not (>= ?0 0)) $x28)))
-(let (($x34 (forall ((?v0 Int) )(let (($x28 (not (<= ?v0 0))))
-(let (($x18 (<= 0 ?v0)))
-(let (($x19 (not $x18)))
-(or $x19 $x28)))))
-))
-(let ((@x107 (monotonicity (rewrite (= (<= 0 ?0) (>= ?0 0))) (= (not (<= 0 ?0)) (not (>= ?0 0))))))
-(let ((@x113 (|quant-intro| (monotonicity @x107 (= (or (not (<= 0 ?0)) $x28) $x108)) (= $x34 $x111))))
-(let (($x67 (ite $x34 (<= (~ 1) 0) (<= 3 0))))
-(let ((@x76 (monotonicity (rewrite (= (<= (~ 1) 0) true)) (rewrite (= (<= 3 0) false)) (= $x67 (ite $x34 true false)))))
-(let ((@x80 (trans @x76 (rewrite (= (ite $x34 true false) $x34)) (= $x67 $x34))))
-(let ((@x82 (trans (rewrite (= (<= (ite $x34 (~ 1) 3) 0) $x67)) @x80 (= (<= (ite $x34 (~ 1) 3) 0) $x34))))
-(let ((?x40 (ite $x34 (~ 1) 3)))
-(let (($x46 (<= ?x40 0)))
-(let (($x10 (forall ((?v0 Int) )(or (< ?v0 0) (< 0 ?v0)))
+(let ((@x79 (|quant-intro| (rewrite (= (= (+ (* 4 ?1) (* (~ 6) ?0)) 1) false)) (= $x59 $x75))))
+(let ((@x83 (trans @x79 (|elim-unused| (= $x75 false)) (= $x59 false))))
+(let (($x51 (exists ((?v0 Int) (?v1 Int) (?v2 Int) )(let ((?x42 (* (~ 6) ?v1)))
+(let ((?x9 (* 4 ?v0)))
+(let ((?x45 (+ ?x9 ?x42)))
+(= ?x45 1)))))
 ))
-(let (($x15 (< 0 (ite $x10 (- 1) 3))))
-(let (($x16 (not $x15)))
-(let (($x18 (<= 0 ?0)))
-(let (($x19 (not $x18)))
-(let (($x31 (or $x19 $x28)))
-(let ((@x26 (trans (rewrite (= (< ?0 0) $x19)) (monotonicity (rewrite (= $x18 $x18)) (= $x19 $x19)) (= (< ?0 0) $x19))))
-(let ((@x33 (monotonicity @x26 (rewrite (= (< 0 ?0) $x28)) (= (or (< ?0 0) (< 0 ?0)) $x31))))
-(let ((@x42 (monotonicity (|quant-intro| @x33 (= $x10 $x34)) (rewrite (= (- 1) (~ 1))) (= (ite $x10 (- 1) 3) ?x40))))
-(let ((@x51 (trans (monotonicity @x42 (= $x15 (< 0 ?x40))) (rewrite (= (< 0 ?x40) (not $x46))) (= $x15 (not $x46)))))
-(let ((@x58 (trans (monotonicity @x51 (= $x16 (not (not $x46)))) (rewrite (= (not (not $x46)) $x46)) (= $x16 $x46))))
-(let ((@x83 (mp (mp (mp (asserted $x16) @x58 $x46) (|rewrite*| (= $x46 $x46)) $x46) @x82 $x34)))
-(let ((@x117 (|mp~| (mp @x83 @x113 $x111) (|nnf-pos| (refl (|~| $x108 $x108)) (|~| $x111 $x111)) $x111)))
-(|unit-resolution| @x117 (mp ((_ |quant-inst| 0) $x169) @x512 $x507) false))))))))))))))))))))))))))))))))))))))
+(let ((?x42 (* (~ 6) ?1)))
+(let ((?x9 (* 4 ?2)))
+(let ((?x45 (+ ?x9 ?x42)))
+(let (($x48 (= ?x45 1)))
+(let ((?x11 (- 6)))
+(let ((?x12 (* ?x11 ?1)))
+(let ((?x13 (+ ?x9 ?x12)))
+(let (($x15 (= ?x13 1)))
+(let ((@x47 (monotonicity (monotonicity (rewrite (= ?x11 (~ 6))) (= ?x12 ?x42)) (= ?x13 ?x45))))
+(let ((@x63 (trans (|quant-intro| (monotonicity @x47 (= $x15 $x48)) (= $x16 $x51)) (|elim-unused| (= $x51 $x59)) (= $x16 $x59))))
+(let ((@x69 (monotonicity (monotonicity @x63 (= $x7 (not $x59))) (= $x17 (not (not $x59))))))
+(let ((@x73 (trans @x69 (rewrite (= (not (not $x59)) $x59)) (= $x17 $x59))))
+(mp (asserted $x17) (trans @x73 @x83 (= $x17 false)) false)))))))))))))))))))))))
 
-a8c954d45da95df62d2ec9e6e7c43aa1fee0cd56 21 0
-unsat
-((set-logic AUFLIA)
-(proof
-(let (($x39 (exists ((?v0 Int) (?v1 Int) )(= (+ (* 4 ?v0) (* (~ 6) ?v1)) 1))
-))
-(let (($x79 (exists ((?v0 Int) (?v1 Int) )false)
-))
-(let ((@x83 (|quant-intro| (rewrite (= (= (+ (* 4 ?1) (* (~ 6) ?0)) 1) false)) (= $x39 $x79))))
-(let (($x16 (exists ((?v0 Int) (?v1 Int) (?v2 Int) )(= (+ (* 4 ?v0) (* (- 6) ?v1)) 1))
-))
-(let (($x17 (not (not $x16))))
-(let (($x31 (exists ((?v0 Int) (?v1 Int) (?v2 Int) )(= (+ (* 4 ?v0) (* (~ 6) ?v1)) 1))
-))
-(let (($x29 (= (= (+ (* 4 ?2) (* (- 6) ?1)) 1) (= (+ (* 4 ?2) (* (~ 6) ?1)) 1))))
-(let (($x26 (= (+ (* 4 ?2) (* (- 6) ?1)) (+ (* 4 ?2) (* (~ 6) ?1)))))
-(let ((@x24 (monotonicity (rewrite (= (- 6) (~ 6))) (= (* (- 6) ?1) (* (~ 6) ?1)))))
-(let ((@x33 (|quant-intro| (monotonicity (monotonicity @x24 $x26) $x29) (= $x16 $x31))))
-(let ((@x46 (monotonicity (trans @x33 (|elim-unused| (= $x31 $x39)) (= $x16 $x39)) (= (not $x16) (not $x39)))))
-(let ((@x53 (trans (monotonicity @x46 (= $x17 (not (not $x39)))) (rewrite (= (not (not $x39)) $x39)) (= $x17 $x39))))
-(mp (mp (mp (asserted $x17) @x53 $x39) (|rewrite*| (= $x39 $x39)) $x39) (trans @x83 (|elim-unused| (= $x79 false)) (= $x39 false)) false)))))))))))))))
-
-a029fa4a7b0e95c1814546efbbdea2800c05d654 41 0
+8a423de6b668d07fe5d90dcad74d7fbb1fcb9c11 52 0
 unsat
 ((set-logic AUFLIA)
 (declare-fun ?v1!1 () Int)
 (declare-fun ?v2!0 () Int)
 (proof
-(let (($x107 (or (not (and (not (<= ?v1!1 0)) (not (<= ?v2!0 0)))) (not (<= (+ ?v2!0 ?v1!1) 0)))))
-(let (($x89 (forall ((?v1 Int) (?v2 Int) )(or (not (and (not (<= ?v1 0)) (not (<= ?v2 0)))) (not (<= (+ ?v2 ?v1) 0))))
-))
-(let (($x92 (not $x89)))
-(let (($x42 (forall ((?v1 Int) (?v2 Int) )(let (($x30 (not (<= (+ ?v1 ?v2) 0))))
-(or (not (and (not (<= ?v1 0)) (not (<= ?v2 0)))) $x30)))
+(let ((?x103 (+ ?v2!0 ?v1!1)))
+(let (($x104 (<= ?x103 0)))
+(let (($x106 (or (not (and (not (<= ?v1!1 0)) (not (<= ?v2!0 0)))) (not $x104))))
+(let (($x86 (forall ((?v1 Int) (?v2 Int) )(or (not (and (not (<= ?v1 0)) (not (<= ?v2 0)))) (not (<= (+ ?v2 ?v1) 0))))
 ))
-(let (($x52 (not $x42)))
-(let (($x86 (or (not (and (not (<= ?1 0)) (not (<= ?0 0)))) (not (<= (+ ?0 ?1) 0)))))
-(let (($x30 (not (<= (+ ?1 ?0) 0))))
-(let (($x37 (or (not (and (not (<= ?1 0)) (not (<= ?0 0)))) $x30)))
-(let ((@x82 (monotonicity (rewrite (= (+ ?1 ?0) (+ ?0 ?1))) (= (<= (+ ?1 ?0) 0) (<= (+ ?0 ?1) 0)))))
-(let ((@x88 (monotonicity (monotonicity @x82 (= $x30 (not (<= (+ ?0 ?1) 0)))) (= $x37 $x86))))
-(let (($x15 (exists ((?v0 Int) )(forall ((?v1 Int) (?v2 Int) )(=> (and (< 0 ?v1) (< 0 ?v2)) (< 0 (+ ?v1 ?v2))))
+(let (($x89 (not $x86)))
+(let (($x15 (exists ((?v0 Int) )(forall ((?v1 Int) (?v2 Int) )(let (($x10 (and (< 0 ?v1) (< 0 ?v2))))
+(=> $x10 (< 0 (+ ?v1 ?v2)))))
 )
 ))
 (let (($x16 (not $x15)))
-(let (($x45 (exists ((?v0 Int) )(forall ((?v1 Int) (?v2 Int) )(let (($x30 (not (<= (+ ?v1 ?v2) 0))))
-(or (not (and (not (<= ?v1 0)) (not (<= ?v2 0)))) $x30)))
+(let (($x52 (forall ((?v1 Int) (?v2 Int) )(let ((?x37 (+ ?v2 ?v1)))
+(let (($x40 (< 0 ?x37)))
+(or (not (and (< 0 ?v1) (< 0 ?v2))) $x40))))
+))
+(let (($x83 (or (not (and (not (<= ?1 0)) (not (<= ?0 0)))) (not (<= (+ ?0 ?1) 0)))))
+(let ((?x37 (+ ?0 ?1)))
+(let (($x40 (< 0 ?x37)))
+(let (($x47 (or (not (and (< 0 ?1) (< 0 ?0))) $x40)))
+(let (($x77 (= (not (and (< 0 ?1) (< 0 ?0))) (not (and (not (<= ?1 0)) (not (<= ?0 0)))))))
+(let (($x10 (and (< 0 ?1) (< 0 ?0))))
+(let ((@x75 (monotonicity (rewrite (= (< 0 ?1) (not (<= ?1 0)))) (rewrite (= (< 0 ?0) (not (<= ?0 0)))) (= $x10 (and (not (<= ?1 0)) (not (<= ?0 0)))))))
+(let ((@x85 (monotonicity (monotonicity @x75 $x77) (rewrite (= $x40 (not (<= ?x37 0)))) (= $x47 $x83))))
+(let ((@x91 (monotonicity (|quant-intro| @x85 (= $x52 $x86)) (= (not $x52) $x89))))
+(let (($x55 (exists ((?v0 Int) )(forall ((?v1 Int) (?v2 Int) )(let ((?x37 (+ ?v2 ?v1)))
+(let (($x40 (< 0 ?x37)))
+(or (not (and (< 0 ?v1) (< 0 ?v2))) $x40))))
 )
 ))
-(let (($x14 (forall ((?v1 Int) (?v2 Int) )(=> (and (< 0 ?v1) (< 0 ?v2)) (< 0 (+ ?v1 ?v2))))
+(let (($x14 (forall ((?v1 Int) (?v2 Int) )(let (($x10 (and (< 0 ?v1) (< 0 ?v2))))
+(=> $x10 (< 0 (+ ?v1 ?v2)))))
 ))
-(let (($x13 (=> (and (< 0 ?1) (< 0 ?0)) (< 0 (+ ?1 ?0)))))
-(let (($x38 (= (=> (and (not (<= ?1 0)) (not (<= ?0 0))) $x30) $x37)))
-(let (($x34 (= $x13 (=> (and (not (<= ?1 0)) (not (<= ?0 0))) $x30))))
-(let (($x26 (and (not (<= ?1 0)) (not (<= ?0 0)))))
-(let ((@x28 (monotonicity (rewrite (= (< 0 ?1) (not (<= ?1 0)))) (rewrite (= (< 0 ?0) (not (<= ?0 0)))) (= (and (< 0 ?1) (< 0 ?0)) $x26))))
-(let ((@x41 (trans (monotonicity @x28 (rewrite (= (< 0 (+ ?1 ?0)) $x30)) $x34) (rewrite $x38) (= $x13 $x37))))
-(let ((@x51 (trans (|quant-intro| (|quant-intro| @x41 (= $x14 $x42)) (= $x15 $x45)) (|elim-unused| (= $x45 $x42)) (= $x15 $x42))))
-(let ((@x58 (mp (mp (asserted $x16) (monotonicity @x51 (= $x16 $x52)) $x52) (|rewrite*| (= $x52 $x52)) $x52)))
-(let ((@x97 (mp @x58 (monotonicity (|quant-intro| @x88 (= $x42 $x89)) (= $x52 $x92)) $x92)))
-(let ((@x117 (|not-or-elim| (|mp~| @x97 (sk (|~| $x92 (not $x107))) (not $x107)) (<= (+ ?v2!0 ?v1!1) 0))))
-(let ((@x114 (|not-or-elim| (|mp~| @x97 (sk (|~| $x92 (not $x107))) (not $x107)) (and (not (<= ?v1!1 0)) (not (<= ?v2!0 0))))))
-((_ |th-lemma| arith farkas 1 1 1) (|and-elim| @x114 (not (<= ?v2!0 0))) (|and-elim| @x114 (not (<= ?v1!1 0))) @x117 false))))))))))))))))))))))))))))
+(let ((@x42 (monotonicity (rewrite (= (+ ?1 ?0) ?x37)) (= (< 0 (+ ?1 ?0)) $x40))))
+(let ((@x45 (monotonicity @x42 (= (=> $x10 (< 0 (+ ?1 ?0))) (=> $x10 $x40)))))
+(let ((@x51 (trans @x45 (rewrite (= (=> $x10 $x40) $x47)) (= (=> $x10 (< 0 (+ ?1 ?0))) $x47))))
+(let ((@x61 (trans (|quant-intro| (|quant-intro| @x51 (= $x14 $x52)) (= $x15 $x55)) (|elim-unused| (= $x55 $x52)) (= $x15 $x52))))
+(let ((@x93 (trans (monotonicity @x61 (= $x16 (not $x52))) @x91 (= $x16 $x89))))
+(let ((@x110 (|mp~| (mp (asserted $x16) @x93 $x89) (sk (|~| $x89 (not $x106))) (not $x106))))
+(let ((@x116 (|not-or-elim| @x110 $x104)))
+(let (($x97 (<= ?v1!1 0)))
+(let (($x98 (not $x97)))
+(let ((@x114 (|and-elim| (|not-or-elim| @x110 (and $x98 (not (<= ?v2!0 0)))) $x98)))
+(let (($x99 (<= ?v2!0 0)))
+(let (($x100 (not $x99)))
+(let ((@x115 (|and-elim| (|not-or-elim| @x110 (and $x98 $x100)) $x100)))
+((_ |th-lemma| arith farkas 1 1 1) @x115 @x114 @x116 false)))))))))))))))))))))))))))))))))))
 
-d41dfe74c924188d8570a9d71b541c5781066b63 41 0
+7c93c190dc21779c8214786ce8c1fd4de433814f 46 0
 unsat
 ((set-logic AUFLIRA)
 (declare-fun ?v1!1 () Int)
 (declare-fun ?v2!0 () Real)
 (proof
-(let (($x95 (not (<= ?v1!1 (~ 1)))))
-(let (($x96 (or (not (and (not (<= ?v1!1 0)) (not (<= ?v2!0 0.0)))) $x95)))
-(let (($x52 (forall ((?v1 Int) (?v2 Real) )(let (($x38 (not (<= ?v1 (~ 1)))))
-(or (not (and (not (<= ?v1 0)) (not (<= ?v2 0.0)))) $x38)))
+(let (($x103 (<= ?v1!1 (~ 1))))
+(let (($x104 (not $x103)))
+(let (($x105 (or (not (and (not (<= ?v1!1 0)) (not (<= ?v2!0 0.0)))) $x104)))
+(let (($x86 (forall ((?v1 Int) (?v2 Real) )(or (not (and (not (<= ?v1 0)) (not (<= ?v2 0.0)))) (not (<= ?v1 (~ 1)))))
 ))
-(let (($x62 (not $x52)))
-(let (($x18 (exists ((?v0 Int) )(forall ((?v1 Int) (?v2 Real) )(let (($x15 (< (- 1) ?v1)))
-(=> (and (< 0 ?v1) (< 0.0 ?v2)) $x15)))
+(let (($x89 (not $x86)))
+(let (($x18 (exists ((?v0 Int) )(forall ((?v1 Int) (?v2 Real) )(let (($x12 (and (< 0 ?v1) (< 0.0 ?v2))))
+(=> $x12 (< (- 1) ?v1))))
 )
 ))
 (let (($x5 (not $x18)))
-(let (($x55 (exists ((?v0 Int) )(forall ((?v1 Int) (?v2 Real) )(let (($x38 (not (<= ?v1 (~ 1)))))
-(or (not (and (not (<= ?v1 0)) (not (<= ?v2 0.0)))) $x38)))
+(let (($x52 (forall ((?v1 Int) (?v2 Real) )(let (($x40 (< (~ 1) ?v1)))
+(or (not (and (< 0 ?v1) (< 0.0 ?v2))) $x40)))
+))
+(let (($x83 (or (not (and (not (<= ?1 0)) (not (<= ?0 0.0)))) (not (<= ?1 (~ 1))))))
+(let (($x40 (< (~ 1) ?1)))
+(let (($x47 (or (not (and (< 0 ?1) (< 0.0 ?0))) $x40)))
+(let (($x77 (= (not (and (< 0 ?1) (< 0.0 ?0))) (not (and (not (<= ?1 0)) (not (<= ?0 0.0)))))))
+(let (($x12 (and (< 0 ?1) (< 0.0 ?0))))
+(let ((@x75 (monotonicity (rewrite (= (< 0 ?1) (not (<= ?1 0)))) (rewrite (= (< 0.0 ?0) (not (<= ?0 0.0)))) (= $x12 (and (not (<= ?1 0)) (not (<= ?0 0.0)))))))
+(let ((@x85 (monotonicity (monotonicity @x75 $x77) (rewrite (= $x40 (not (<= ?1 (~ 1))))) (= $x47 $x83))))
+(let ((@x91 (monotonicity (|quant-intro| @x85 (= $x52 $x86)) (= (not $x52) $x89))))
+(let (($x55 (exists ((?v0 Int) )(forall ((?v1 Int) (?v2 Real) )(let (($x40 (< (~ 1) ?v1)))
+(or (not (and (< 0 ?v1) (< 0.0 ?v2))) $x40)))
 )
 ))
-(let (($x17 (forall ((?v1 Int) (?v2 Real) )(let (($x15 (< (- 1) ?v1)))
-(=> (and (< 0 ?v1) (< 0.0 ?v2)) $x15)))
+(let (($x17 (forall ((?v1 Int) (?v2 Real) )(let (($x12 (and (< 0 ?v1) (< 0.0 ?v2))))
+(=> $x12 (< (- 1) ?v1))))
 ))
-(let (($x38 (not (<= ?1 (~ 1)))))
-(let (($x47 (or (not (and (not (<= ?1 0)) (not (<= ?0 0.0)))) $x38)))
-(let (($x15 (< (- 1) ?1)))
-(let (($x16 (=> (and (< 0 ?1) (< 0.0 ?0)) $x15)))
-(let (($x48 (= (=> (and (not (<= ?1 0)) (not (<= ?0 0.0))) $x38) $x47)))
-(let (($x44 (= $x16 (=> (and (not (<= ?1 0)) (not (<= ?0 0.0))) $x38))))
-(let ((@x36 (monotonicity (rewrite (= (- 1) (~ 1))) (= $x15 (< (~ 1) ?1)))))
-(let (($x28 (and (not (<= ?1 0)) (not (<= ?0 0.0)))))
-(let ((@x30 (monotonicity (rewrite (= (< 0 ?1) (not (<= ?1 0)))) (rewrite (= (< 0.0 ?0) (not (<= ?0 0.0)))) (= (and (< 0 ?1) (< 0.0 ?0)) $x28))))
-(let ((@x45 (monotonicity @x30 (trans @x36 (rewrite (= (< (~ 1) ?1) $x38)) (= $x15 $x38)) $x44)))
-(let ((@x54 (|quant-intro| (trans @x45 (rewrite $x48) (= $x16 $x47)) (= $x17 $x52))))
-(let ((@x61 (trans (|quant-intro| @x54 (= $x18 $x55)) (|elim-unused| (= $x55 $x52)) (= $x18 $x52))))
-(let ((@x68 (mp (mp (asserted $x5) (monotonicity @x61 (= $x5 $x62)) $x62) (|rewrite*| (= $x62 $x62)) $x62)))
-(let ((@x106 (|not-or-elim| (|mp~| @x68 (sk (|~| $x62 (not $x96))) (not $x96)) (<= ?v1!1 (~ 1)))))
-(let ((@x103 (|not-or-elim| (|mp~| @x68 (sk (|~| $x62 (not $x96))) (not $x96)) (and (not (<= ?v1!1 0)) (not (<= ?v2!0 0.0))))))
-(let ((@x107 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x95 (<= ?v1!1 0))) (|and-elim| @x103 (not (<= ?v1!1 0))) $x95)))
-(|unit-resolution| @x107 @x106 false)))))))))))))))))))))))))))
+(let ((@x42 (monotonicity (rewrite (= (- 1) (~ 1))) (= (< (- 1) ?1) $x40))))
+(let ((@x45 (monotonicity @x42 (= (=> $x12 (< (- 1) ?1)) (=> $x12 $x40)))))
+(let ((@x51 (trans @x45 (rewrite (= (=> $x12 $x40) $x47)) (= (=> $x12 (< (- 1) ?1)) $x47))))
+(let ((@x61 (trans (|quant-intro| (|quant-intro| @x51 (= $x17 $x52)) (= $x18 $x55)) (|elim-unused| (= $x55 $x52)) (= $x18 $x52))))
+(let ((@x93 (trans (monotonicity @x61 (= $x5 (not $x52))) @x91 (= $x5 $x89))))
+(let ((@x109 (|mp~| (mp (asserted $x5) @x93 $x89) (sk (|~| $x89 (not $x105))) (not $x105))))
+(let ((@x115 (|not-or-elim| @x109 $x103)))
+(let (($x97 (<= ?v1!1 0)))
+(let (($x98 (not $x97)))
+(let ((@x113 (|and-elim| (|not-or-elim| @x109 (and $x98 (not (<= ?v2!0 0.0)))) $x98)))
+(|unit-resolution| (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x104 $x97)) @x113 $x104) @x115 false)))))))))))))))))))))))))))))))
 
-9c97136863512513fe9fd8b8cb83fdb885e5f3a5 115 0
+39a3c02f6687608102bd092d376b8901575e5356 2 0
+unknown
+(error "line 6 column 10: proof is not available")
+3bdf1da3a49c7c0ce726c85bf6e844aabdd6afa0 36 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let (($x156 (forall ((?v0 Int) )(let (($x16 (<= ?v0 0)))
-(let (($x17 (not $x16)))
-(let (($x150 (or (not false) $x17)))
-(not $x150)))))
-))
-(let (($x178 (forall ((?v0 Int) )false)
-))
-(let (($x16 (<= ?0 0)))
-(let (($x17 (not $x16)))
-(let (($x150 (or (not false) $x17)))
-(let ((@x166 (monotonicity (rewrite (= (not false) true)) (= $x150 (or true $x17)))))
-(let ((@x170 (trans @x166 (rewrite (= (or true $x17) true)) (= $x150 true))))
-(let ((@x177 (trans (monotonicity @x170 (= (not $x150) (not true))) (rewrite (= (not true) false)) (= (not $x150) false))))
-(let ((@x184 (trans (|quant-intro| @x177 (= $x156 $x178)) (|elim-unused| (= $x178 false)) (= $x156 false))))
-(let (($x126 (forall ((?v0 Int) )(let (($x16 (<= ?v0 0)))
-(let (($x17 (not $x16)))
-(let (($x82 (forall ((?v1 Int) )(let (($x16 (<= ?v1 0)))
-(let (($x17 (not $x16)))
-(or (not (>= (+ ?v1 (* (~ 1) ?v0)) 0)) $x17))))
-))
-(let (($x85 (not $x82)))
-(let (($x88 (or $x85 $x17)))
-(not $x88)))))))
-))
-(let (($x142 (forall ((?v0 Int) )(let (($x16 (<= ?v0 0)))
-(let (($x17 (not $x16)))
-(let (($x130 (forall ((?v1 Int) )(let (($x16 (<= ?v1 0)))
-(not $x16)))
-))
-(not (or (not $x130) $x17))))))
-))
-(let ((@x160 (trans (rewrite (= $x126 $x142)) (rewrite (= $x142 $x156)) (= $x126 $x156))))
-(let (($x122 (forall ((?v0 Int) )(let (($x16 (<= ?v0 0)))
-(let (($x82 (forall ((?v1 Int) )(let (($x16 (<= ?v1 0)))
-(let (($x17 (not $x16)))
-(or (not (>= (+ ?v1 (* (~ 1) ?v0)) 0)) $x17))))
-))
-(and $x82 $x16))))
-))
-(let (($x82 (forall ((?v1 Int) )(let (($x16 (<= ?v1 0)))
-(let (($x17 (not $x16)))
-(or (not (>= (+ ?v1 (* (~ 1) ?0)) 0)) $x17))))
-))
-(let (($x85 (not $x82)))
-(let (($x88 (or $x85 $x17)))
-(let (($x108 (not $x88)))
-(let (($x119 (and $x82 $x16)))
-(let (($x111 (forall ((?v0 Int) )(let (($x16 (<= ?v0 0)))
-(let (($x17 (not $x16)))
-(let (($x104 (not $x17)))
-(let (($x82 (forall ((?v1 Int) )(let (($x16 (<= ?v1 0)))
-(let (($x17 (not $x16)))
-(or (not (>= (+ ?v1 (* (~ 1) ?v0)) 0)) $x17))))
-))
-(and $x82 $x104))))))
-))
-(let ((@x121 (monotonicity (rewrite (= (not $x17) $x16)) (= (and $x82 (not $x17)) $x119))))
-(let (($x91 (exists ((?v0 Int) )(let (($x16 (<= ?v0 0)))
-(let (($x17 (not $x16)))
-(let (($x82 (forall ((?v1 Int) )(let (($x16 (<= ?v1 0)))
-(let (($x17 (not $x16)))
-(or (not (>= (+ ?v1 (* (~ 1) ?v0)) 0)) $x17))))
-))
-(let (($x85 (not $x82)))
-(or $x85 $x17))))))
-))
-(let (($x94 (not $x91)))
-(let (($x79 (or (not (>= (+ ?0 (* (~ 1) ?1)) 0)) $x17)))
-(let ((@x103 (|nnf-neg| (|nnf-pos| (refl (|~| $x79 $x79)) (|~| $x82 $x82)) (|~| (not $x85) $x82))))
-(let ((@x110 (|nnf-neg| @x103 (refl (|~| (not $x17) (not $x17))) (|~| $x108 (and $x82 (not $x17))))))
-(let (($x41 (exists ((?v0 Int) )(let (($x16 (<= ?v0 0)))
-(let (($x17 (not $x16)))
-(let (($x29 (forall ((?v1 Int) )(let (($x16 (<= ?v1 0)))
-(let (($x17 (not $x16)))
-(or (not (<= ?v0 ?v1)) $x17))))
-))
-(or (not $x29) $x17)))))
-))
-(let (($x44 (not $x41)))
-(let (($x29 (forall ((?v1 Int) )(let (($x16 (<= ?v1 0)))
-(let (($x17 (not $x16)))
-(or (not (<= ?0 ?v1)) $x17))))
-))
-(let (($x36 (or (not $x29) $x17)))
-(let ((@x78 (monotonicity (rewrite (= (<= ?1 ?0) (>= (+ ?0 (* (~ 1) ?1)) 0))) (= (not (<= ?1 ?0)) (not (>= (+ ?0 (* (~ 1) ?1)) 0))))))
-(let ((@x84 (|quant-intro| (monotonicity @x78 (= (or (not (<= ?1 ?0)) $x17) $x79)) (= $x29 $x82))))
-(let ((@x90 (monotonicity (monotonicity @x84 (= (not $x29) $x85)) (= $x36 $x88))))
-(let (($x13 (exists ((?v0 Int) )(let (($x9 (< 0 ?v0)))
-(let (($x11 (forall ((?v1 Int) )(let (($x9 (< 0 ?v1)))
-(let (($x7 (<= ?v0 ?v1)))
-(=> $x7 $x9))))
-))
-(=> $x11 $x9))))
+(let (($x13 (forall ((?v0 Int) )(let ((?x10 (* 2 |a$|)))
+(let ((?x9 (* 2 ?v0)))
+(let (($x11 (< ?x9 ?x10)))
+(let (($x7 (< ?v0 |a$|)))
+(=> $x7 $x11))))))
 ))
 (let (($x14 (not $x13)))
-(let (($x9 (< 0 ?0)))
-(let (($x11 (forall ((?v1 Int) )(let (($x9 (< 0 ?v1)))
-(let (($x7 (<= ?0 ?v1)))
-(=> $x7 $x9))))
+(let (($x40 (forall ((?v0 Int) )(let ((?x10 (* 2 |a$|)))
+(let ((?x9 (* 2 ?v0)))
+(let (($x11 (< ?x9 ?x10)))
+(let (($x7 (< ?v0 |a$|)))
+(let (($x36 (not $x7)))
+(or $x36 $x11)))))))
+))
+(let (($x43 (not $x40)))
+(let (($x69 (forall ((?v0 Int) )true)
 ))
-(let (($x12 (=> $x11 $x9)))
-(let ((@x26 (rewrite (= (=> (<= ?1 ?0) $x17) (or (not (<= ?1 ?0)) $x17)))))
-(let ((@x22 (monotonicity (rewrite (= $x9 $x17)) (= (=> (<= ?1 ?0) $x9) (=> (<= ?1 ?0) $x17)))))
-(let ((@x28 (trans @x22 @x26 (= (=> (<= ?1 ?0) $x9) (or (not (<= ?1 ?0)) $x17)))))
-(let ((@x34 (monotonicity (|quant-intro| @x28 (= $x11 $x29)) (rewrite (= $x9 $x17)) (= $x12 (=> $x29 $x17)))))
-(let ((@x43 (|quant-intro| (trans @x34 (rewrite (= (=> $x29 $x17) $x36)) (= $x12 $x36)) (= $x13 $x41))))
-(let ((@x50 (mp (mp (asserted $x14) (monotonicity @x43 (= $x14 $x44)) $x44) (|rewrite*| (= $x44 $x44)) $x44)))
-(let ((@x97 (mp @x50 (monotonicity (|quant-intro| @x90 (= $x41 $x91)) (= $x44 $x94)) $x94)))
-(let ((@x115 (mp (|mp~| @x97 (|nnf-neg| @x110 (|~| $x94 $x111)) $x111) (|quant-intro| @x121 (= $x111 $x122)) $x122)))
-(let ((@x129 (mp @x115 (|quant-intro| (rewrite (= $x119 $x108)) (= $x122 $x126)) $x126)))
-(mp (mp @x129 @x160 $x156) @x184 false)))))))))))))))))))))))))))))))))))))))))))))))))
+(let ((?x10 (* 2 |a$|)))
+(let ((?x9 (* 2 ?0)))
+(let (($x11 (< ?x9 ?x10)))
+(let (($x7 (< ?0 |a$|)))
+(let (($x36 (not $x7)))
+(let (($x37 (or $x36 $x11)))
+(let (($x48 (>= (+ ?0 (* (~ 1) |a$|)) 0)))
+(let (($x47 (not $x48)))
+(let ((@x59 (trans (monotonicity (rewrite (= $x7 $x47)) (= $x36 (not $x47))) (rewrite (= (not $x47) $x48)) (= $x36 $x48))))
+(let ((@x64 (monotonicity @x59 (rewrite (= $x11 $x47)) (= $x37 (or $x48 $x47)))))
+(let ((@x71 (|quant-intro| (trans @x64 (rewrite (= (or $x48 $x47) true)) (= $x37 true)) (= $x40 $x69))))
+(let ((@x78 (monotonicity (trans @x71 (|elim-unused| (= $x69 true)) (= $x40 true)) (= $x43 (not true)))))
+(let ((@x82 (trans @x78 (rewrite (= (not true) false)) (= $x43 false))))
+(let ((@x45 (monotonicity (|quant-intro| (rewrite (= (=> $x7 $x11) $x37)) (= $x13 $x40)) (= $x14 $x43))))
+(mp (asserted $x14) (trans @x45 @x82 (= $x14 false)) false))))))))))))))))))))))
 
-cf41882047cdb0b0d0cbb2e29bd4abf71d67b407 28 0
-unsat
-((set-logic AUFLIA)
-(proof
-(let (($x32 (forall ((?v0 Int) )(let (($x21 (not (<= (* 2 |a$|) (* 2 ?v0)))))
-(let (($x16 (<= |a$| ?v0)))
-(or $x16 $x21))))
-))
-(let (($x35 (not $x32)))
-(let (($x80 (forall ((?v0 Int) )true)
-))
-(let (($x21 (not (<= (* 2 |a$|) (* 2 ?0)))))
-(let (($x16 (<= |a$| ?0)))
-(let (($x27 (or $x16 $x21)))
-(let (($x64 (>= (+ ?0 (* (~ 1) |a$|)) 0)))
-(let ((@x72 (monotonicity (rewrite (= (<= (* 2 |a$|) (* 2 ?0)) $x64)) (= $x21 (not $x64)))))
-(let ((@x75 (monotonicity (rewrite (= $x16 $x64)) @x72 (= $x27 (or $x64 (not $x64))))))
-(let ((@x79 (trans @x75 (rewrite (= (or $x64 (not $x64)) true)) (= $x27 true))))
-(let ((@x86 (trans (|quant-intro| @x79 (= $x32 $x80)) (|elim-unused| (= $x80 true)) (= $x32 true))))
-(let ((@x93 (trans (monotonicity @x86 (= $x35 (not true))) (rewrite (= (not true) false)) (= $x35 false))))
-(let (($x13 (forall ((?v0 Int) )(=> (< ?v0 |a$|) (< (* 2 ?v0) (* 2 |a$|))))
-))
-(let (($x14 (not $x13)))
-(let (($x12 (=> (< ?0 |a$|) (< (* 2 ?0) (* 2 |a$|)))))
-(let ((@x26 (monotonicity (rewrite (= (< ?0 |a$|) (not $x16))) (rewrite (= (< (* 2 ?0) (* 2 |a$|)) $x21)) (= $x12 (=> (not $x16) $x21)))))
-(let ((@x31 (trans @x26 (rewrite (= (=> (not $x16) $x21) $x27)) (= $x12 $x27))))
-(let ((@x38 (mp (asserted $x14) (monotonicity (|quant-intro| @x31 (= $x13 $x32)) (= $x14 $x35)) $x35)))
-(mp (mp @x38 (|rewrite*| (= $x35 $x35)) $x35) @x93 false)))))))))))))))))))))
-
-2cfb4d9213b7aff75941c49db378297fcba62a29 38 0
+0737ab0e9619ba68da155fd5dcce2691243e7d8d 24 0
 unsat
 ((set-logic AUFLIA)
 (declare-fun ?v1!0 () Int)
 (proof
-(let (($x73 (forall ((?v1 Int) )(let (($x15 (not (<= ?v1 0))))
-(or $x15 (not (>= ?v1 1)))))
+(let (($x62 (>= ?v1!0 1)))
+(let (($x50 (forall ((?v1 Int) )(or (not (<= ?v1 0)) (not (>= ?v1 1))))
 ))
-(let (($x76 (not $x73)))
-(let (($x86 (|~| $x76 (not (or (not (<= ?v1!0 0)) (not (>= ?v1!0 1)))))))
-(let (($x33 (forall ((?v1 Int) )(let (($x18 (<= 1 ?v1)))
-(let (($x19 (not $x18)))
-(let (($x15 (not (<= ?v1 0))))
-(or $x15 $x19)))))
-))
-(let (($x38 (not $x33)))
-(let (($x18 (<= 1 ?0)))
-(let (($x19 (not $x18)))
-(let (($x15 (not (<= ?0 0))))
-(let (($x27 (or $x15 $x19)))
-(let ((@x69 (monotonicity (rewrite (= $x18 (>= ?0 1))) (= $x19 (not (>= ?0 1))))))
-(let ((@x75 (|quant-intro| (monotonicity @x69 (= $x27 (or $x15 (not (>= ?0 1))))) (= $x33 $x73))))
+(let (($x53 (not $x50)))
 (let (($x12 (forall ((?v0 Int) (?v1 Int) )(or (< 0 ?v1) (< ?v1 1)))
 ))
 (let (($x5 (not $x12)))
-(let (($x30 (forall ((?v0 Int) (?v1 Int) )(let (($x18 (<= 1 ?v1)))
-(let (($x19 (not $x18)))
-(let (($x15 (not (<= ?v1 0))))
-(or $x15 $x19)))))
+(let (($x33 (forall ((?v1 Int) )(or (< 0 ?v1) (< ?v1 1)))
 ))
-(let ((@x26 (trans (rewrite (= (< ?0 1) $x19)) (monotonicity (rewrite (= $x18 $x18)) (= $x19 $x19)) (= (< ?0 1) $x19))))
-(let ((@x29 (monotonicity (rewrite (= (< 0 ?0) $x15)) @x26 (= (or (< 0 ?0) (< ?0 1)) $x27))))
-(let ((@x37 (trans (|quant-intro| @x29 (= $x12 $x30)) (|elim-unused| (= $x30 $x33)) (= $x12 $x33))))
-(let ((@x44 (mp (mp (asserted $x5) (monotonicity @x37 (= $x5 $x38)) $x38) (|rewrite*| (= $x38 $x38)) $x38)))
-(let ((@x88 (|mp~| (mp @x44 (monotonicity @x75 (= $x38 $x76)) $x76) (sk $x86) (not (or (not (<= ?v1!0 0)) (not (>= ?v1!0 1)))))))
-(let (($x83 (not (>= ?v1!0 1))))
-(let ((@x93 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x83 (not (<= ?v1!0 0)))) (|not-or-elim| @x88 (<= ?v1!0 0)) $x83)))
-(|unit-resolution| @x93 (|not-or-elim| @x88 (>= ?v1!0 1)) false))))))))))))))))))))))))
+(let (($x11 (or (< 0 ?0) (< ?0 1))))
+(let ((@x49 (monotonicity (rewrite (= (< 0 ?0) (not (<= ?0 0)))) (rewrite (= (< ?0 1) (not (>= ?0 1)))) (= $x11 (or (not (<= ?0 0)) (not (>= ?0 1)))))))
+(let ((@x55 (monotonicity (|quant-intro| @x49 (= $x33 $x50)) (= (not $x33) $x53))))
+(let ((@x57 (trans (monotonicity (|elim-unused| (= $x12 $x33)) (= $x5 (not $x33))) @x55 (= $x5 $x53))))
+(let ((@x68 (|mp~| (mp (asserted $x5) @x57 $x53) (sk (|~| $x53 (not (or (not (<= ?v1!0 0)) (not $x62))))) (not (or (not (<= ?v1!0 0)) (not $x62))))))
+(let ((@x72 (|not-or-elim| @x68 $x62)))
+(let (($x63 (not $x62)))
+(let (($x60 (<= ?v1!0 0)))
+(let ((@x71 (|not-or-elim| @x68 $x60)))
+(|unit-resolution| (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x63 (not $x60))) @x71 $x63) @x72 false))))))))))))))))))
 
-abbcc5cc077b58e7142b658090ed462f7a37de5b 19 0
+40bda8c0d6f113a97f5dc1db7c4465fe4cb9ac06 26 0
 unsat
 ((set-logic <null>)
 (proof
-(let (($x29 (<= |b$| 0)))
-(let (($x30 (not $x29)))
-(let (($x37 (or (not (and (not (<= |a$| 0)) (not (<= (* |a$| |b$|) 0)))) $x30)))
-(let (($x13 (=> (and (< 0 |a$|) (< 0 (* |a$| |b$|))) (< 0 |b$|))))
-(let (($x14 (not $x13)))
-(let (($x23 (not (<= (* |a$| |b$|) 0))))
-(let (($x19 (not (<= |a$| 0))))
-(let (($x26 (and $x19 $x23)))
-(let ((@x28 (monotonicity (rewrite (= (< 0 |a$|) $x19)) (rewrite (= (< 0 (* |a$| |b$|)) $x23)) (= (and (< 0 |a$|) (< 0 (* |a$| |b$|))) $x26))))
-(let ((@x35 (monotonicity @x28 (rewrite (= (< 0 |b$|) $x30)) (= $x13 (=> $x26 $x30)))))
-(let ((@x44 (monotonicity (trans @x35 (rewrite (= (=> $x26 $x30) $x37)) (= $x13 $x37)) (= $x14 (not $x37)))))
-(let ((@x58 (mp (|not-or-elim| (mp (asserted $x14) @x44 (not $x37)) $x29) (|rewrite*| (= $x29 $x29)) $x29)))
-(let ((@x47 (|and-elim| (|not-or-elim| (mp (asserted $x14) @x44 (not $x37)) $x26) $x19)))
-(let ((@x48 (|and-elim| (|not-or-elim| (mp (asserted $x14) @x44 (not $x37)) $x26) $x23)))
-((_ |th-lemma| arith farkas 1 1 1) (mp @x48 (|rewrite*| (= $x23 $x23)) $x23) (mp @x47 (|rewrite*| (= $x19 $x19)) $x19) @x58 false)))))))))))))))))
+(let (($x56 (<= |b$| 0)))
+(let (($x60 (or (not (and (not (<= |a$| 0)) (not (<= (* |a$| |b$|) 0)))) (not $x56))))
+(let (($x63 (not $x60)))
+(let (($x14 (not (=> (and (< 0 |a$|) (< 0 (* |a$| |b$|))) (< 0 |b$|)))))
+(let (($x12 (< 0 |b$|)))
+(let (($x36 (or (not (and (< 0 |a$|) (< 0 (* |a$| |b$|)))) $x12)))
+(let (($x54 (= (not (and (< 0 |a$|) (< 0 (* |a$| |b$|)))) (not (and (not (<= |a$| 0)) (not (<= (* |a$| |b$|) 0)))))))
+(let ((?x9 (* |a$| |b$|)))
+(let (($x46 (<= ?x9 0)))
+(let (($x47 (not $x46)))
+(let (($x42 (<= |a$| 0)))
+(let (($x43 (not $x42)))
+(let (($x50 (and $x43 $x47)))
+(let (($x11 (and (< 0 |a$|) (< 0 ?x9))))
+(let ((@x52 (monotonicity (rewrite (= (< 0 |a$|) $x43)) (rewrite (= (< 0 ?x9) $x47)) (= $x11 $x50))))
+(let ((@x62 (monotonicity (monotonicity @x52 $x54) (rewrite (= $x12 (not $x56))) (= $x36 $x60))))
+(let ((@x41 (monotonicity (rewrite (= (=> $x11 $x12) $x36)) (= $x14 (not $x36)))))
+(let ((@x67 (trans @x41 (monotonicity @x62 (= (not $x36) $x63)) (= $x14 $x63))))
+(let ((@x72 (|not-or-elim| (mp (asserted $x14) @x67 $x63) $x56)))
+(let ((@x70 (|and-elim| (|not-or-elim| (mp (asserted $x14) @x67 $x63) $x50) $x43)))
+(let ((@x71 (|and-elim| (|not-or-elim| (mp (asserted $x14) @x67 $x63) $x50) $x47)))
+((_ |th-lemma| arith farkas 1 1 1) @x71 @x70 @x72 false))))))))))))))))))))))))
 
-4ef1d4e9c1eb07f7b6dde03db0c786dd6cdb3835 28 0
+3f9914c501829bba4f4b416ce311c4f49855326d 26 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((?x35 (+ 1 |y$|)))
-(let ((?x38 (* |a$| ?x35)))
-(let ((?x41 (+ (* |a$| |x$|) ?x38)))
-(let ((?x27 (+ 1 |x$| |y$|)))
-(let ((?x32 (* |a$| ?x27)))
-(let (($x44 (= ?x32 ?x41)))
-(let (($x47 (not $x44)))
-(let ((@x72 (monotonicity (rewrite (= ?x35 ?x35)) (= (+ |x$| ?x35) (+ |x$| ?x35)))))
-(let ((@x75 (trans @x72 (rewrite (= (+ |x$| ?x35) ?x27)) (= (+ |x$| ?x35) ?x27))))
-(let ((@x80 (monotonicity (monotonicity @x75 (= (* |a$| (+ |x$| ?x35)) ?x32)) (= (+ (* |a$| (+ |x$| ?x35)) 0) (+ ?x32 0)))))
-(let ((@x84 (trans @x80 (rewrite (= (+ ?x32 0) ?x32)) (= (+ (* |a$| (+ |x$| ?x35)) 0) ?x32))))
-(let ((@x63 (monotonicity (monotonicity (rewrite (= ?x35 ?x35)) (= ?x38 ?x38)) (= ?x41 ?x41))))
-(let ((@x70 (trans @x63 (rewrite (= ?x41 (+ (* |a$| (+ |x$| ?x35)) 0))) (= ?x41 (+ (* |a$| (+ |x$| ?x35)) 0)))))
-(let ((@x88 (monotonicity (monotonicity (rewrite (= ?x27 ?x27)) (= ?x32 ?x32)) (trans @x70 @x84 (= ?x41 ?x32)) (= $x44 (= ?x32 ?x32)))))
-(let ((@x95 (monotonicity (trans @x88 (rewrite (= (= ?x32 ?x32) true)) (= $x44 true)) (= $x47 (not true)))))
-(let (($x16 (= (* |a$| (+ (+ |x$| 1) |y$|)) (+ (* |a$| |x$|) (* |a$| (+ |y$| 1))))))
+(let ((?x13 (+ |y$| 1)))
+(let ((?x14 (* |a$| ?x13)))
+(let ((?x12 (* |a$| |x$|)))
+(let ((?x15 (+ ?x12 ?x14)))
+(let ((?x8 (+ |x$| 1)))
+(let ((?x10 (+ ?x8 |y$|)))
+(let ((?x11 (* |a$| ?x10)))
+(let (($x16 (= ?x11 ?x15)))
 (let (($x17 (not $x16)))
-(let ((@x40 (monotonicity (rewrite (= (+ |y$| 1) ?x35)) (= (* |a$| (+ |y$| 1)) ?x38))))
-(let ((@x43 (monotonicity @x40 (= (+ (* |a$| |x$|) (* |a$| (+ |y$| 1))) ?x41))))
-(let ((@x26 (monotonicity (rewrite (= (+ |x$| 1) (+ 1 |x$|))) (= (+ (+ |x$| 1) |y$|) (+ (+ 1 |x$|) |y$|)))))
-(let ((@x31 (trans @x26 (rewrite (= (+ (+ 1 |x$|) |y$|) ?x27)) (= (+ (+ |x$| 1) |y$|) ?x27))))
-(let ((@x46 (monotonicity (monotonicity @x31 (= (* |a$| (+ (+ |x$| 1) |y$|)) ?x32)) @x43 (= $x16 $x44))))
-(let ((@x53 (mp (mp (asserted $x17) (monotonicity @x46 (= $x17 $x47)) $x47) (|rewrite*| (= $x47 $x47)) $x47)))
-(mp @x53 (trans @x95 (rewrite (= (not true) false)) (= $x47 false)) false))))))))))))))))))))))))))
+(let (($x80 (= (= (+ |a$| ?x12 (* |a$| |y$|)) (+ |a$| ?x12 (* |a$| |y$|))) true)))
+(let (($x78 (= $x16 (= (+ |a$| ?x12 (* |a$| |y$|)) (+ |a$| ?x12 (* |a$| |y$|))))))
+(let ((@x74 (rewrite (= (+ ?x12 (+ |a$| (* |a$| |y$|))) (+ |a$| ?x12 (* |a$| |y$|))))))
+(let ((@x64 (monotonicity (rewrite (= ?x13 (+ 1 |y$|))) (= ?x14 (* |a$| (+ 1 |y$|))))))
+(let ((@x69 (trans @x64 (rewrite (= (* |a$| (+ 1 |y$|)) (+ |a$| (* |a$| |y$|)))) (= ?x14 (+ |a$| (* |a$| |y$|))))))
+(let ((@x76 (trans (monotonicity @x69 (= ?x15 (+ ?x12 (+ |a$| (* |a$| |y$|))))) @x74 (= ?x15 (+ |a$| ?x12 (* |a$| |y$|))))))
+(let ((@x56 (rewrite (= (* |a$| (+ 1 |x$| |y$|)) (+ |a$| ?x12 (* |a$| |y$|))))))
+(let ((@x44 (monotonicity (rewrite (= ?x8 (+ 1 |x$|))) (= ?x10 (+ (+ 1 |x$|) |y$|)))))
+(let ((@x49 (trans @x44 (rewrite (= (+ (+ 1 |x$|) |y$|) (+ 1 |x$| |y$|))) (= ?x10 (+ 1 |x$| |y$|)))))
+(let ((@x58 (trans (monotonicity @x49 (= ?x11 (* |a$| (+ 1 |x$| |y$|)))) @x56 (= ?x11 (+ |a$| ?x12 (* |a$| |y$|))))))
+(let ((@x86 (monotonicity (trans (monotonicity @x58 @x76 $x78) (rewrite $x80) (= $x16 true)) (= $x17 (not true)))))
+(let ((@x90 (trans @x86 (rewrite (= (not true) false)) (= $x17 false))))
+(mp (asserted $x17) @x90 false))))))))))))))))))))))))
 
-d53ca0a1797e1fff3e579ce36e7f8e25e5b2afcb 25 0
+f65cca85cf5c1c666974448574788ae3b34595b7 23 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((?x38 (* |x$| |y$|)))
-(let ((?x39 (* 2.0 ?x38)))
-(let ((?x26 (* |x$| (+ 1.0 (* (~ 1.0) |y$|)))))
-(let ((?x32 (* (~ 1.0) ?x26)))
-(let ((?x9 (* |x$| (+ 1.0 |y$|))))
-(let ((?x33 (+ ?x9 ?x32)))
-(let (($x42 (= ?x33 ?x39)))
-(let (($x45 (not $x42)))
-(let ((@x81 (rewrite (= (* (~ 1.0) (+ |x$| (* (~ 1.0) ?x38))) (+ (* (~ 1.0) |x$|) ?x38)))))
-(let ((@x77 (monotonicity (rewrite (= ?x26 (+ |x$| (* (~ 1.0) ?x38)))) (= ?x32 (* (~ 1.0) (+ |x$| (* (~ 1.0) ?x38)))))))
-(let ((@x86 (monotonicity (rewrite (= ?x9 (+ |x$| ?x38))) (trans @x77 @x81 (= ?x32 (+ (* (~ 1.0) |x$|) ?x38))) (= ?x33 (+ (+ |x$| ?x38) (+ (* (~ 1.0) |x$|) ?x38))))))
-(let ((@x89 (trans @x86 (rewrite (= (+ (+ |x$| ?x38) (+ (* (~ 1.0) |x$|) ?x38)) ?x39)) $x42)))
-(let ((@x96 (trans (monotonicity @x89 (= $x42 (= ?x39 ?x39))) (rewrite (= (= ?x39 ?x39) true)) (= $x42 true))))
-(let ((@x103 (trans (monotonicity @x96 (= $x45 (not true))) (rewrite (= (not true) false)) (= $x45 false))))
-(let (($x17 (not (= (- ?x9 (* |x$| (- 1.0 |y$|))) (* (* 2.0 |x$|) |y$|)))))
-(let (($x43 (= (= (- ?x9 (* |x$| (- 1.0 |y$|))) (* (* 2.0 |x$|) |y$|)) $x42)))
-(let ((@x28 (monotonicity (rewrite (= (- 1.0 |y$|) (+ 1.0 (* (~ 1.0) |y$|)))) (= (* |x$| (- 1.0 |y$|)) ?x26))))
-(let ((@x31 (monotonicity @x28 (= (- ?x9 (* |x$| (- 1.0 |y$|))) (- ?x9 ?x26)))))
-(let ((@x37 (trans @x31 (rewrite (= (- ?x9 ?x26) ?x33)) (= (- ?x9 (* |x$| (- 1.0 |y$|))) ?x33))))
-(let ((@x47 (monotonicity (monotonicity @x37 (rewrite (= (* (* 2.0 |x$|) |y$|) ?x39)) $x43) (= $x17 $x45))))
-(mp (mp (asserted $x17) @x47 $x45) @x103 false)))))))))))))))))))))))
+(let ((?x14 (* 2.0 |x$|)))
+(let ((?x15 (* ?x14 |y$|)))
+(let ((?x10 (- 1.0 |y$|)))
+(let ((?x11 (* |x$| ?x10)))
+(let ((?x8 (+ 1.0 |y$|)))
+(let ((?x9 (* |x$| ?x8)))
+(let ((?x12 (- ?x9 ?x11)))
+(let (($x16 (= ?x12 ?x15)))
+(let (($x17 (not $x16)))
+(let ((@x71 (rewrite (= (= (* 2.0 (* |x$| |y$|)) (* 2.0 (* |x$| |y$|))) true))))
+(let ((?x39 (* |x$| |y$|)))
+(let ((?x61 (* 2.0 ?x39)))
+(let ((@x54 (rewrite (= (* |x$| (+ 1.0 (* (~ 1.0) |y$|))) (+ |x$| (* (~ 1.0) ?x39))))))
+(let ((@x50 (monotonicity (rewrite (= ?x10 (+ 1.0 (* (~ 1.0) |y$|)))) (= ?x11 (* |x$| (+ 1.0 (* (~ 1.0) |y$|)))))))
+(let ((@x59 (monotonicity (rewrite (= ?x9 (+ |x$| ?x39))) (trans @x50 @x54 (= ?x11 (+ |x$| (* (~ 1.0) ?x39)))) (= ?x12 (- (+ |x$| ?x39) (+ |x$| (* (~ 1.0) ?x39)))))))
+(let ((@x64 (trans @x59 (rewrite (= (- (+ |x$| ?x39) (+ |x$| (* (~ 1.0) ?x39))) ?x61)) (= ?x12 ?x61))))
+(let ((@x73 (trans (monotonicity @x64 (rewrite (= ?x15 ?x61)) (= $x16 (= ?x61 ?x61))) @x71 (= $x16 true))))
+(let ((@x80 (trans (monotonicity @x73 (= $x17 (not true))) (rewrite (= (not true) false)) (= $x17 false))))
+(mp (asserted $x17) @x80 false)))))))))))))))))))))
 
-3d315c543a59bb7c2ba5e19237e3c8b29ad17b62 74 0
+2643ba95811453f95121cf28c15c748e73c8c127 51 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((?x165 (* (~ 1) |e$|)))
-(let ((?x163 (* (~ 1) |b$|)))
-(let ((?x176 (+ ?x163 ?x165)))
+(let ((?x25 (+ |b$| |d$|)))
+(let ((?x26 (+ ?x25 |e$|)))
 (let ((?x8 (+ 1 |p$|)))
-(let ((?x181 (* ?x8 ?x176)))
-(let ((?x51 (+ 2 (* 2 |p$|))))
+(let ((?x27 (* ?x8 ?x26)))
+(let ((?x22 (* |d$| |p$|)))
+(let ((?x20 (* ?x8 |d$|)))
 (let ((?x11 (+ |b$| |e$|)))
-(let ((?x59 (* ?x11 ?x51)))
-(let ((?x187 (+ ?x59 ?x181)))
+(let ((?x18 (* 2 ?x8)))
+(let ((?x19 (* ?x18 ?x11)))
+(let ((?x21 (+ ?x19 ?x20)))
+(let ((?x23 (+ ?x21 ?x22)))
+(let ((?x24 (+ |u$| ?x23)))
+(let ((?x28 (- ?x24 ?x27)))
+(let ((?x15 (* |p$| |d$|)))
 (let ((?x12 (* ?x8 ?x11)))
-(let (($x194 (= ?x12 ?x187)))
-(let (($x197 (not $x194)))
-(let ((?x220 (* |p$| |e$|)))
-(let ((?x219 (* |p$| |b$|)))
-(let ((?x221 (+ |b$| |e$| ?x219 ?x220)))
-(let ((?x236 (+ (+ (* 2 |b$|) (* 2 |e$|) (* 2 ?x219) (* 2 ?x220)) (+ ?x163 ?x165 (* (~ 1) ?x219) (* (~ 1) ?x220)))))
-(let (($x229 (= ?x59 (+ (* 2 |b$|) (* 2 |e$|) (* 2 ?x219) (* 2 ?x220)))))
-(let ((@x238 (monotonicity (rewrite $x229) (rewrite (= ?x181 (+ ?x163 ?x165 (* (~ 1) ?x219) (* (~ 1) ?x220)))) (= ?x187 ?x236))))
-(let ((@x245 (monotonicity (rewrite (= ?x12 ?x221)) (trans @x238 (rewrite (= ?x236 ?x221)) (= ?x187 ?x221)) (= $x194 (= ?x221 ?x221)))))
-(let ((@x252 (monotonicity (trans @x245 (rewrite (= (= ?x221 ?x221) true)) (= $x194 true)) (= $x197 (not true)))))
-(let ((?x86 (+ |b$| |d$| |e$|)))
-(let ((?x89 (* ?x8 ?x86)))
-(let ((?x96 (* (~ 1) ?x89)))
-(let ((?x64 (* |d$| ?x8)))
-(let ((?x121 (+ ?x59 ?x64 ?x96)))
-(let (($x124 (= ?x12 ?x121)))
-(let (($x127 (not $x124)))
-(let ((?x157 (+ ?x59 (* ?x8 (+ |d$| (* (~ 1) ?x86))) 0)))
-(let ((?x166 (+ ?x163 (* (~ 1) |d$|) ?x165)))
-(let ((?x154 (* (~ 1) ?x86)))
-(let (($x167 (= ?x154 ?x166)))
-(let ((@x169 (trans (monotonicity (rewrite (= ?x86 ?x86)) (= ?x154 ?x154)) (rewrite $x167) $x167)))
-(let ((@x175 (monotonicity (trans @x169 (rewrite (= ?x166 ?x166)) $x167) (= (+ |d$| ?x154) (+ |d$| ?x166)))))
-(let ((@x180 (trans @x175 (rewrite (= (+ |d$| ?x166) ?x176)) (= (+ |d$| ?x154) ?x176))))
-(let ((@x135 (rewrite (= ?x8 ?x8))))
-(let ((@x143 (monotonicity (rewrite (= ?x11 ?x11)) (rewrite (= ?x51 ?x51)) (= ?x59 ?x59))))
-(let ((@x186 (monotonicity @x143 (monotonicity @x135 @x180 (= (* ?x8 (+ |d$| ?x154)) ?x181)) (= ?x157 (+ ?x59 ?x181 0)))))
-(let ((@x151 (monotonicity (monotonicity @x135 (rewrite (= ?x86 ?x86)) (= ?x89 ?x89)) (= ?x96 ?x96))))
-(let ((@x153 (monotonicity @x143 (monotonicity @x135 (= ?x64 ?x64)) @x151 (= ?x121 ?x121))))
-(let ((@x193 (trans (trans @x153 (rewrite (= ?x121 ?x157)) (= ?x121 ?x157)) (trans @x186 (rewrite (= (+ ?x59 ?x181 0) ?x187)) (= ?x157 ?x187)) (= ?x121 ?x187))))
-(let ((@x196 (monotonicity (monotonicity @x135 (rewrite (= ?x11 ?x11)) (= ?x12 ?x12)) @x193 (= $x124 $x194))))
-(let ((@x126 (monotonicity (rewrite (= (+ 0 ?x59 ?x64 ?x96) ?x121)) (= (= ?x12 (+ 0 ?x59 ?x64 ?x96)) $x124))))
-(let ((@x129 (monotonicity @x126 (= (not (= ?x12 (+ 0 ?x59 ?x64 ?x96))) $x127))))
-(let (($x112 (= ?x12 (+ 0 ?x59 ?x64 ?x96))))
-(let (($x117 (not $x112)))
-(let ((?x22 (* |d$| |p$|)))
-(let ((?x23 (+ (+ (* (* 2 ?x8) ?x11) (* ?x8 |d$|)) ?x22)))
-(let ((?x24 (+ |u$| ?x23)))
-(let ((?x28 (- ?x24 (* ?x8 (+ (+ |b$| |d$|) |e$|)))))
-(let ((?x16 (+ (+ |u$| ?x12) (* |p$| |d$|))))
+(let ((?x13 (+ |u$| ?x12)))
+(let ((?x16 (+ ?x13 ?x15)))
 (let (($x29 (= ?x16 ?x28)))
 (let (($x30 (not $x29)))
-(let ((@x114 (rewrite (= (= (+ |u$| ?x12 ?x22) (+ |u$| ?x59 ?x64 ?x22 ?x96)) $x112))))
-(let ((@x104 (rewrite (= (+ (+ |u$| ?x59 ?x64 ?x22) ?x96) (+ |u$| ?x59 ?x64 ?x22 ?x96)))))
-(let ((?x81 (+ |u$| ?x59 ?x64 ?x22)))
-(let ((?x97 (+ ?x81 ?x96)))
-(let ((@x91 (monotonicity (rewrite (= (+ (+ |b$| |d$|) |e$|) ?x86)) (= (* ?x8 (+ (+ |b$| |d$|) |e$|)) ?x89))))
-(let ((@x53 (monotonicity (rewrite (= (* 2 1) 2)) (= (+ (* 2 1) (* 2 |p$|)) ?x51))))
-(let ((@x55 (trans (rewrite (= (* 2 ?x8) (+ (* 2 1) (* 2 |p$|)))) @x53 (= (* 2 ?x8) ?x51))))
-(let ((@x63 (trans (monotonicity @x55 (= (* (* 2 ?x8) ?x11) (* ?x51 ?x11))) (rewrite (= (* ?x51 ?x11) ?x59)) (= (* (* 2 ?x8) ?x11) ?x59))))
-(let ((@x69 (monotonicity @x63 (rewrite (= (* ?x8 |d$|) ?x64)) (= (+ (* (* 2 ?x8) ?x11) (* ?x8 |d$|)) (+ ?x59 ?x64)))))
-(let ((@x77 (trans (monotonicity @x69 (= ?x23 (+ (+ ?x59 ?x64) ?x22))) (rewrite (= (+ (+ ?x59 ?x64) ?x22) (+ ?x59 ?x64 ?x22))) (= ?x23 (+ ?x59 ?x64 ?x22)))))
-(let ((@x85 (trans (monotonicity @x77 (= ?x24 (+ |u$| (+ ?x59 ?x64 ?x22)))) (rewrite (= (+ |u$| (+ ?x59 ?x64 ?x22)) ?x81)) (= ?x24 ?x81))))
-(let ((@x101 (trans (monotonicity @x85 @x91 (= ?x28 (- ?x81 ?x89))) (rewrite (= (- ?x81 ?x89) ?x97)) (= ?x28 ?x97))))
-(let ((@x38 (monotonicity (rewrite (= (* |p$| |d$|) ?x22)) (= ?x16 (+ (+ |u$| ?x12) ?x22)))))
-(let ((@x43 (trans @x38 (rewrite (= (+ (+ |u$| ?x12) ?x22) (+ |u$| ?x12 ?x22))) (= ?x16 (+ |u$| ?x12 ?x22)))))
-(let ((@x109 (monotonicity @x43 (trans @x101 @x104 (= ?x28 (+ |u$| ?x59 ?x64 ?x22 ?x96))) (= $x29 (= (+ |u$| ?x12 ?x22) (+ |u$| ?x59 ?x64 ?x22 ?x96))))))
-(let ((@x120 (mp (asserted $x30) (monotonicity (trans @x109 @x114 (= $x29 $x112)) (= $x30 $x117)) $x117)))
-(let ((@x200 (mp (mp (mp @x120 @x129 $x127) (|rewrite*| (= $x127 $x127)) $x127) (monotonicity @x196 (= $x127 $x197)) $x197)))
-(mp @x200 (trans @x252 (rewrite (= (not true) false)) (= $x197 false)) false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
+(let ((?x53 (* |p$| |e$|)))
+(let ((?x52 (* |p$| |b$|)))
+(let ((?x68 (+ |u$| |b$| |e$| ?x15 ?x52 ?x53)))
+(let ((?x125 (+ |b$| |e$| |d$| ?x15 ?x52 ?x53)))
+(let ((?x83 (* 2 ?x53)))
+(let ((?x81 (* 2 ?x52)))
+(let ((?x82 (* 2 |e$|)))
+(let ((?x80 (* 2 |b$|)))
+(let ((?x114 (+ |u$| ?x80 ?x82 |d$| (* 2 ?x15) ?x81 ?x83)))
+(let ((@x124 (monotonicity (rewrite (= ?x26 (+ |b$| |e$| |d$|))) (= ?x27 (* ?x8 (+ |b$| |e$| |d$|))))))
+(let ((@x129 (trans @x124 (rewrite (= (* ?x8 (+ |b$| |e$| |d$|)) ?x125)) (= ?x27 ?x125))))
+(let ((@x116 (rewrite (= (+ |u$| (+ ?x80 ?x82 |d$| (* 2 ?x15) ?x81 ?x83)) ?x114))))
+(let ((?x106 (+ ?x80 ?x82 |d$| (* 2 ?x15) ?x81 ?x83)))
+(let ((?x95 (+ ?x80 ?x82 |d$| ?x15 ?x81 ?x83)))
+(let ((@x86 (rewrite (= (* (+ 2 (* 2 |p$|)) ?x11) (+ ?x80 ?x82 ?x81 ?x83)))))
+(let ((@x79 (monotonicity (rewrite (= ?x18 (+ 2 (* 2 |p$|)))) (= ?x19 (* (+ 2 (* 2 |p$|)) ?x11)))))
+(let ((@x94 (monotonicity (trans @x79 @x86 (= ?x19 (+ ?x80 ?x82 ?x81 ?x83))) (rewrite (= ?x20 (+ |d$| ?x15))) (= ?x21 (+ (+ ?x80 ?x82 ?x81 ?x83) (+ |d$| ?x15))))))
+(let ((@x99 (trans @x94 (rewrite (= (+ (+ ?x80 ?x82 ?x81 ?x83) (+ |d$| ?x15)) ?x95)) (= ?x21 ?x95))))
+(let ((@x110 (trans (monotonicity @x99 (rewrite (= ?x22 ?x15)) (= ?x23 (+ ?x95 ?x15))) (rewrite (= (+ ?x95 ?x15) ?x106)) (= ?x23 ?x106))))
+(let ((@x118 (trans (monotonicity @x110 (= ?x24 (+ |u$| ?x106))) @x116 (= ?x24 ?x114))))
+(let ((@x137 (trans (monotonicity @x118 @x129 (= ?x28 (- ?x114 ?x125))) (rewrite (= (- ?x114 ?x125) ?x68)) (= ?x28 ?x68))))
+(let ((@x62 (rewrite (= (+ |u$| (+ |b$| |e$| ?x52 ?x53)) (+ |u$| |b$| |e$| ?x52 ?x53)))))
+(let ((@x59 (monotonicity (rewrite (= ?x12 (+ |b$| |e$| ?x52 ?x53))) (= ?x13 (+ |u$| (+ |b$| |e$| ?x52 ?x53))))))
+(let ((@x67 (monotonicity (trans @x59 @x62 (= ?x13 (+ |u$| |b$| |e$| ?x52 ?x53))) (= ?x16 (+ (+ |u$| |b$| |e$| ?x52 ?x53) ?x15)))))
+(let ((@x72 (trans @x67 (rewrite (= (+ (+ |u$| |b$| |e$| ?x52 ?x53) ?x15) ?x68)) (= ?x16 ?x68))))
+(let ((@x143 (trans (monotonicity @x72 @x137 (= $x29 (= ?x68 ?x68))) (rewrite (= (= ?x68 ?x68) true)) (= $x29 true))))
+(let ((@x150 (trans (monotonicity @x143 (= $x30 (not true))) (rewrite (= (not true) false)) (= $x30 false))))
+(mp (asserted $x30) @x150 false)))))))))))))))))))))))))))))))))))))))))))))))))
 
-895910b3e061efd8f207e0c25a2edc00b81271b2 97 0
+9377273e8e637d8916ed13b81bd56a602ea76d29 126 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let ((?x8 (* 2 (|of_nat$| |x$|))))
-(let ((?x545 (+ ?x8 (* (~ 1) (|of_nat$| (|nat$| ?x8))))))
-(let (($x543 (= ?x545 0)))
-(let (($x205 (>= (|of_nat$| |x$|) 0)))
-(let ((?x224 (|of_nat$| (|nat$| ?x8))))
-(let (($x499 (>= ?x224 1)))
-(let (($x517 (= (|of_nat$| (|nat$| 1)) 1)))
-(let (($x558 (forall ((?v0 Int) )(!(let (($x25 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(or (not (>= ?v0 0)) $x25)) :pattern ( (|nat$| ?v0) )))
-))
-(let (($x109 (forall ((?v0 Int) )(let (($x25 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(or (not (>= ?v0 0)) $x25)))
+(let ((?x7 (|of_nat$| |x$|)))
+(let ((?x8 (* 2 ?x7)))
+(let ((?x9 (|nat$| ?x8)))
+(let ((?x147 (|of_nat$| ?x9)))
+(let ((?x160 (* (~ 1) ?x147)))
+(let ((?x161 (+ ?x8 ?x160)))
+(let (($x177 (<= ?x161 0)))
+(let (($x158 (= ?x161 0)))
+(let (($x150 (>= ?x7 0)))
+(let (($x239 (>= ?x147 1)))
+(let (($x237 (= ?x147 1)))
+(let ((?x11 (|nat$| 1)))
+(let ((?x200 (|of_nat$| ?x11)))
+(let (($x201 (= ?x200 1)))
+(let (($x128 (forall ((?v0 Int) )(!(let ((?x23 (|nat$| ?v0)))
+(let ((?x24 (|of_nat$| ?x23)))
+(let (($x25 (= ?x24 ?v0)))
+(let (($x66 (>= ?v0 0)))
+(let (($x67 (not $x66)))
+(or $x67 $x25)))))) :pattern ( (|nat$| ?v0) )))
 ))
-(let (($x25 (= (|of_nat$| (|nat$| ?0)) ?0)))
-(let (($x106 (or (not (>= ?0 0)) $x25)))
-(let (($x48 (forall ((?v0 Int) )(let (($x25 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
+(let (($x73 (forall ((?v0 Int) )(let ((?x23 (|nat$| ?v0)))
+(let ((?x24 (|of_nat$| ?x23)))
+(let (($x25 (= ?x24 ?v0)))
+(let (($x66 (>= ?v0 0)))
+(let (($x67 (not $x66)))
+(or $x67 $x25)))))))
+))
+(let ((?x23 (|nat$| ?0)))
+(let ((?x24 (|of_nat$| ?x23)))
+(let (($x25 (= ?x24 ?0)))
+(let (($x66 (>= ?0 0)))
+(let (($x67 (not $x66)))
+(let (($x70 (or $x67 $x25)))
+(let (($x27 (forall ((?v0 Int) )(let ((?x23 (|nat$| ?v0)))
+(let ((?x24 (|of_nat$| ?x23)))
+(let (($x25 (= ?x24 ?v0)))
 (let (($x22 (<= 0 ?v0)))
-(let (($x43 (not $x22)))
-(or $x43 $x25)))))
+(=> $x22 $x25))))))
 ))
-(let ((@x105 (monotonicity (rewrite (= (<= 0 ?0) (>= ?0 0))) (= (not (<= 0 ?0)) (not (>= ?0 0))))))
-(let ((@x111 (|quant-intro| (monotonicity @x105 (= (or (not (<= 0 ?0)) $x25) $x106)) (= $x48 $x109))))
-(let (($x27 (forall ((?v0 Int) )(let (($x25 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(let (($x22 (<= 0 ?v0)))
-(=> $x22 $x25))))
+(let (($x61 (forall ((?v0 Int) )(let ((?x23 (|nat$| ?v0)))
+(let ((?x24 (|of_nat$| ?x23)))
+(let (($x25 (= ?x24 ?v0)))
+(or (not (<= 0 ?v0)) $x25)))))
 ))
-(let ((@x46 (rewrite (= (=> (<= 0 ?0) $x25) (or (not (<= 0 ?0)) $x25)))))
-(let ((@x42 (monotonicity (rewrite (= (<= 0 ?0) (<= 0 ?0))) (= (=> (<= 0 ?0) $x25) (=> (<= 0 ?0) $x25)))))
-(let ((@x47 (trans @x42 @x46 (= (=> (<= 0 ?0) $x25) (or (not (<= 0 ?0)) $x25)))))
-(let ((@x77 (mp (mp (asserted $x27) (|quant-intro| @x47 (= $x27 $x48)) $x48) (|rewrite*| (= $x48 $x48)) $x48)))
-(let ((@x128 (|mp~| (mp @x77 @x111 $x109) (|nnf-pos| (refl (|~| $x106 $x106)) (|~| $x109 $x109)) $x109)))
-(let (($x538 (not $x558)))
-(let (($x501 (or $x538 $x517)))
-(let ((@x521 (monotonicity (rewrite (= (>= 1 0) true)) (= (not (>= 1 0)) (not true)))))
-(let ((@x231 (trans @x521 (rewrite (= (not true) false)) (= (not (>= 1 0)) false))))
-(let ((@x235 (monotonicity @x231 (= (or (not (>= 1 0)) $x517) (or false $x517)))))
-(let ((@x515 (trans @x235 (rewrite (= (or false $x517) $x517)) (= (or (not (>= 1 0)) $x517) $x517))))
-(let ((@x505 (monotonicity @x515 (= (or $x538 (or (not (>= 1 0)) $x517)) $x501))))
-(let ((@x508 (trans @x505 (rewrite (= $x501 $x501)) (= (or $x538 (or (not (>= 1 0)) $x517)) $x501))))
-(let ((@x509 (mp ((_ |quant-inst| 1) (or $x538 (or (not (>= 1 0)) $x517))) @x508 $x501)))
-(let ((@x329 (|unit-resolution| @x509 (mp @x128 (|quant-intro| (refl (= $x106 $x106)) (= $x109 $x558)) $x558) $x517)))
-(let (($x12 (= (|nat$| ?x8) (|nat$| 1))))
-(let ((@x38 (mp (asserted (not (not $x12))) (rewrite (= (not (not $x12)) $x12)) $x12)))
-(let ((@x367 (monotonicity (mp @x38 (|rewrite*| (= $x12 $x12)) $x12) (= ?x224 (|of_nat$| (|nat$| 1))))))
-(let ((@x479 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x224 1)) $x499)) (trans @x367 @x329 (= ?x224 1)) $x499)))
-(let ((@x383 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x499) (not (<= ?x224 0)))) @x479 (not (<= ?x224 0)))))
-(let ((@x386 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x224 0)) (<= ?x224 0))) @x383 (not (= ?x224 0)))))
-(let (($x527 (= ?x224 0)))
-(let (($x529 (or $x205 $x527)))
-(let (($x564 (forall ((?v0 Int) )(!(let (($x29 (= (|of_nat$| (|nat$| ?v0)) 0)))
-(let (($x102 (>= ?v0 0)))
-(or $x102 $x29))) :pattern ( (|nat$| ?v0) )))
+(let ((@x69 (monotonicity (rewrite (= (<= 0 ?0) $x66)) (= (not (<= 0 ?0)) $x67))))
+(let ((@x75 (|quant-intro| (monotonicity @x69 (= (or (not (<= 0 ?0)) $x25) $x70)) (= $x61 $x73))))
+(let ((@x60 (rewrite (= (=> (<= 0 ?0) $x25) (or (not (<= 0 ?0)) $x25)))))
+(let ((@x78 (mp (asserted $x27) (trans (|quant-intro| @x60 (= $x27 $x61)) @x75 (= $x27 $x73)) $x73)))
+(let ((@x133 (mp (|mp~| @x78 (|nnf-pos| (refl (|~| $x70 $x70)) (|~| $x73 $x73)) $x73) (|quant-intro| (refl (= $x70 $x70)) (= $x73 $x128)) $x128)))
+(let (($x165 (not $x128)))
+(let (($x219 (or $x165 $x201)))
+(let ((@x204 (rewrite (= (>= 1 0) true))))
+(let ((@x211 (trans (monotonicity @x204 (= (not (>= 1 0)) (not true))) (rewrite (= (not true) false)) (= (not (>= 1 0)) false))))
+(let ((@x214 (monotonicity @x211 (= (or (not (>= 1 0)) $x201) (or false $x201)))))
+(let ((@x218 (trans @x214 (rewrite (= (or false $x201) $x201)) (= (or (not (>= 1 0)) $x201) $x201))))
+(let ((@x223 (monotonicity @x218 (= (or $x165 (or (not (>= 1 0)) $x201)) $x219))))
+(let ((@x226 (trans @x223 (rewrite (= $x219 $x219)) (= (or $x165 (or (not (>= 1 0)) $x201)) $x219))))
+(let ((@x227 (mp ((_ |quant-inst| 1) (or $x165 (or (not (>= 1 0)) $x201))) @x226 $x219)))
+(let (($x12 (= ?x9 ?x11)))
+(let ((@x56 (mp (asserted (not (not $x12))) (rewrite (= (not (not $x12)) $x12)) $x12)))
+(let ((@x252 (trans (monotonicity @x56 (= ?x147 ?x200)) (|unit-resolution| @x227 @x133 $x201) $x237)))
+(let ((@x261 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x239) (not (<= ?x147 0)))) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x237) $x239)) @x252 $x239) (not (<= ?x147 0)))))
+(let ((@x265 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x147 0)) (<= ?x147 0))) @x261 (not (= ?x147 0)))))
+(let (($x179 (= ?x147 0)))
+(let (($x181 (or $x150 $x179)))
+(let (($x134 (forall ((?v0 Int) )(!(let ((?x23 (|nat$| ?v0)))
+(let ((?x24 (|of_nat$| ?x23)))
+(let (($x29 (= ?x24 0)))
+(let (($x66 (>= ?v0 0)))
+(or $x66 $x29))))) :pattern ( (|nat$| ?v0) )))
 ))
-(let (($x116 (forall ((?v0 Int) )(let (($x29 (= (|of_nat$| (|nat$| ?v0)) 0)))
-(let (($x102 (>= ?v0 0)))
-(or $x102 $x29))))
+(let (($x99 (forall ((?v0 Int) )(let ((?x23 (|nat$| ?v0)))
+(let ((?x24 (|of_nat$| ?x23)))
+(let (($x29 (= ?x24 0)))
+(let (($x66 (>= ?v0 0)))
+(or $x66 $x29))))))
 ))
-(let (($x29 (= (|of_nat$| (|nat$| ?0)) 0)))
-(let (($x102 (>= ?0 0)))
-(let (($x113 (or $x102 $x29)))
-(let (($x65 (forall ((?v0 Int) )(let (($x29 (= (|of_nat$| (|nat$| ?v0)) 0)))
-(let (($x22 (<= 0 ?v0)))
-(or $x22 $x29))))
+(let ((@x138 (|quant-intro| (refl (= (or $x66 (= ?x24 0)) (or $x66 (= ?x24 0)))) (= $x99 $x134))))
+(let ((@x118 (|nnf-pos| (refl (|~| (or $x66 (= ?x24 0)) (or $x66 (= ?x24 0)))) (|~| $x99 $x99))))
+(let (($x31 (forall ((?v0 Int) )(let ((?x23 (|nat$| ?v0)))
+(let ((?x24 (|of_nat$| ?x23)))
+(let (($x29 (= ?x24 0)))
+(let (($x28 (< ?v0 0)))
+(=> $x28 $x29))))))
 ))
-(let ((@x115 (monotonicity (rewrite (= (<= 0 ?0) $x102)) (= (or (<= 0 ?0) $x29) $x113))))
-(let (($x31 (forall ((?v0 Int) )(let (($x29 (= (|of_nat$| (|nat$| ?v0)) 0)))
-(=> (< ?v0 0) $x29)))
+(let (($x84 (forall ((?v0 Int) )(let ((?x23 (|nat$| ?v0)))
+(let ((?x24 (|of_nat$| ?x23)))
+(let (($x29 (= ?x24 0)))
+(let (($x28 (< ?v0 0)))
+(let (($x80 (not $x28)))
+(or $x80 $x29)))))))
 ))
-(let ((@x62 (rewrite (= (=> (not (<= 0 ?0)) $x29) (or (<= 0 ?0) $x29)))))
-(let ((@x55 (monotonicity (rewrite (= (<= 0 ?0) (<= 0 ?0))) (= (not (<= 0 ?0)) (not (<= 0 ?0))))))
-(let ((@x56 (trans (rewrite (= (< ?0 0) (not (<= 0 ?0)))) @x55 (= (< ?0 0) (not (<= 0 ?0))))))
-(let ((@x59 (monotonicity @x56 (= (=> (< ?0 0) $x29) (=> (not (<= 0 ?0)) $x29)))))
-(let ((@x64 (trans @x59 @x62 (= (=> (< ?0 0) $x29) (or (<= 0 ?0) $x29)))))
-(let ((@x80 (mp (mp (asserted $x31) (|quant-intro| @x64 (= $x31 $x65)) $x65) (|rewrite*| (= $x65 $x65)) $x65)))
-(let ((@x133 (|mp~| (mp @x80 (|quant-intro| @x115 (= $x65 $x116)) $x116) (|nnf-pos| (refl (|~| $x113 $x113)) (|~| $x116 $x116)) $x116)))
-(let (($x168 (not $x564)))
-(let (($x532 (or $x168 $x205 $x527)))
-(let ((@x531 (monotonicity (rewrite (= (>= ?x8 0) $x205)) (= (or (>= ?x8 0) $x527) $x529))))
-(let ((@x535 (monotonicity @x531 (= (or $x168 (or (>= ?x8 0) $x527)) (or $x168 $x529)))))
-(let ((@x227 (trans @x535 (rewrite (= (or $x168 $x529) $x532)) (= (or $x168 (or (>= ?x8 0) $x527)) $x532))))
-(let ((@x387 (|unit-resolution| (mp ((_ |quant-inst| (* 2 (|of_nat$| |x$|))) (or $x168 (or (>= ?x8 0) $x527))) @x227 $x532) (mp @x133 (|quant-intro| (refl (= $x113 $x113)) (= $x116 $x564)) $x564) $x529)))
-(let (($x197 (not $x205)))
-(let (($x546 (or $x197 $x543)))
-(let (($x200 (or $x538 $x197 $x543)))
-(let (($x201 (or $x538 (or (not (>= ?x8 0)) (= ?x224 ?x8)))))
-(let ((@x537 (monotonicity (rewrite (= (>= ?x8 0) $x205)) (= (not (>= ?x8 0)) $x197))))
-(let ((@x548 (monotonicity @x537 (rewrite (= (= ?x224 ?x8) $x543)) (= (or (not (>= ?x8 0)) (= ?x224 ?x8)) $x546))))
-(let ((@x187 (trans (monotonicity @x548 (= $x201 (or $x538 $x546))) (rewrite (= (or $x538 $x546) $x200)) (= $x201 $x200))))
-(let ((@x389 (|unit-resolution| (mp ((_ |quant-inst| (* 2 (|of_nat$| |x$|))) $x201) @x187 $x200) (mp @x128 (|quant-intro| (refl (= $x106 $x106)) (= $x109 $x558)) $x558) $x546)))
-(let ((@x472 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x543) (<= ?x545 0))) (|unit-resolution| @x389 (|unit-resolution| @x387 @x386 $x205) $x543) (<= ?x545 0))))
-(let ((@x463 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x543) (>= ?x545 0))) (|unit-resolution| @x389 (|unit-resolution| @x387 @x386 $x205) $x543) (>= ?x545 0))))
-(let ((@x475 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x224 1)) (<= ?x224 1))) (trans @x367 @x329 (= ?x224 1)) (<= ?x224 1))))
-((_ |th-lemma| arith gcd-test -1/2 -1/2 -1/2 -1/2) @x479 @x475 @x463 @x472 false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
+(let (($x29 (= ?x24 0)))
+(let (($x96 (or $x66 $x29)))
+(let (($x28 (< ?0 0)))
+(let (($x80 (not $x28)))
+(let (($x81 (or $x80 $x29)))
+(let ((@x95 (trans (monotonicity (rewrite (= $x28 $x67)) (= $x80 (not $x67))) (rewrite (= (not $x67) $x66)) (= $x80 $x66))))
+(let ((@x103 (trans (|quant-intro| (rewrite (= (=> $x28 $x29) $x81)) (= $x31 $x84)) (|quant-intro| (monotonicity @x95 (= $x81 $x96)) (= $x84 $x99)) (= $x31 $x99))))
+(let ((@x139 (mp (|mp~| (mp (asserted $x31) @x103 $x99) @x118 $x99) @x138 $x134)))
+(let (($x184 (not $x134)))
+(let (($x185 (or $x184 $x150 $x179)))
+(let ((@x152 (rewrite (= (>= ?x8 0) $x150))))
+(let ((@x190 (monotonicity (monotonicity @x152 (= (or (>= ?x8 0) $x179) $x181)) (= (or $x184 (or (>= ?x8 0) $x179)) (or $x184 $x181)))))
+(let ((@x194 (trans @x190 (rewrite (= (or $x184 $x181) $x185)) (= (or $x184 (or (>= ?x8 0) $x179)) $x185))))
+(let ((@x195 (mp ((_ |quant-inst| (* 2 ?x7)) (or $x184 (or (>= ?x8 0) $x179))) @x194 $x185)))
+(let (($x153 (not $x150)))
+(let (($x162 (or $x153 $x158)))
+(let (($x166 (or $x165 $x153 $x158)))
+(let (($x148 (= ?x147 ?x8)))
+(let (($x142 (>= ?x8 0)))
+(let (($x143 (not $x142)))
+(let (($x149 (or $x143 $x148)))
+(let (($x167 (or $x165 $x149)))
+(let ((@x164 (monotonicity (monotonicity @x152 (= $x143 $x153)) (rewrite (= $x148 $x158)) (= $x149 $x162))))
+(let ((@x175 (trans (monotonicity @x164 (= $x167 (or $x165 $x162))) (rewrite (= (or $x165 $x162) $x166)) (= $x167 $x166))))
+(let ((@x176 (mp ((_ |quant-inst| (* 2 ?x7)) $x167) @x175 $x166)))
+(let ((@x269 (|unit-resolution| (|unit-resolution| @x176 @x133 $x162) (|unit-resolution| (|unit-resolution| @x195 @x139 $x181) @x265 $x150) $x158)))
+(let (($x178 (>= ?x161 0)))
+(let (($x238 (<= ?x147 1)))
+((_ |th-lemma| arith gcd-test -1/2 -1/2 -1/2 -1/2) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x237) $x239)) @x252 $x239) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x237) $x238)) @x252 $x238) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x158) $x178)) @x269 $x178) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x158) $x177)) @x269 $x177) false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
 
-348e0e0e2aff481fb0a9d832ecbb8299820ba5ad 23 0
+7540f10f61e5a987b0848b309bd25f2a2ae1cd0a 22 0
 unsat
 ((set-logic AUFLIA)
 (proof
 (let ((?x6 (|of_nat$| |a$|)))
-(let (($x50 (>= ?x6 4)))
+(let (($x71 (>= ?x6 4)))
+(let (($x78 (not (or (>= ?x6 3) (not $x71)))))
 (let (($x12 (< (* 2 ?x6) 7)))
-(let (($x13 (=> (< ?x6 3) $x12)))
-(let (($x14 (not $x13)))
-(let (($x53 (not $x50)))
-(let (($x36 (<= 3 ?x6)))
-(let (($x61 (or $x36 $x53)))
-(let ((@x55 (monotonicity (rewrite (= (<= 7 (* 2 ?x6)) $x50)) (= (not (<= 7 (* 2 ?x6))) $x53))))
-(let ((@x57 (trans (rewrite (= $x12 (not (<= 7 (* 2 ?x6))))) @x55 (= $x12 $x53))))
-(let ((@x43 (monotonicity (rewrite (= $x36 $x36)) (= (not $x36) (not $x36)))))
-(let ((@x44 (trans (rewrite (= (< ?x6 3) (not $x36))) @x43 (= (< ?x6 3) (not $x36)))))
-(let ((@x65 (trans (monotonicity @x44 @x57 (= $x13 (=> (not $x36) $x53))) (rewrite (= (=> (not $x36) $x53) $x61)) (= $x13 $x61))))
-(let ((@x69 (mp (asserted $x14) (monotonicity @x65 (= $x14 (not $x61))) (not $x61))))
-(let ((@x142 (monotonicity (rewrite (= $x36 (>= ?x6 3))) (= (not $x36) (not (>= ?x6 3))))))
-(let (($x37 (not $x36)))
-(let ((@x116 (mp (mp (|not-or-elim| @x69 $x37) (|rewrite*| (= $x37 $x37)) $x37) @x43 $x37)))
-(let ((@x265 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x53 (>= ?x6 3))) (mp (mp @x116 @x43 $x37) @x142 (not (>= ?x6 3))) $x53)))
-(|unit-resolution| @x265 (mp (|not-or-elim| @x69 $x50) (|rewrite*| (= $x50 $x50)) $x50) false)))))))))))))))))))))
+(let (($x8 (< ?x6 3)))
+(let (($x52 (not $x8)))
+(let (($x53 (or $x52 $x12)))
+(let ((@x65 (monotonicity (rewrite (= $x8 (not (>= ?x6 3)))) (= $x52 (not (not (>= ?x6 3)))))))
+(let ((@x69 (trans @x65 (rewrite (= (not (not (>= ?x6 3))) (>= ?x6 3))) (= $x52 (>= ?x6 3)))))
+(let ((@x77 (monotonicity @x69 (rewrite (= $x12 (not $x71))) (= $x53 (or (>= ?x6 3) (not $x71))))))
+(let ((@x58 (monotonicity (rewrite (= (=> $x8 $x12) $x53)) (= (not (=> $x8 $x12)) (not $x53)))))
+(let ((@x82 (trans @x58 (monotonicity @x77 (= (not $x53) $x78)) (= (not (=> $x8 $x12)) $x78))))
+(let ((@x85 (|not-or-elim| (mp (asserted (not (=> $x8 $x12))) @x82 $x78) $x71)))
+(let (($x72 (not $x71)))
+(let (($x61 (>= ?x6 3)))
+(let (($x59 (not $x61)))
+(let ((@x84 (|not-or-elim| (mp (asserted (not (=> $x8 $x12))) @x82 $x78) $x59)))
+(|unit-resolution| (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x72 $x61)) @x84 $x72) @x85 false))))))))))))))))))))
 
-754dd3a2aa33c6ad39bf93726c67d09ed642aeda 115 0
+3a9a1f0f87885c249813dfb78d14e1062fc20ce3 147 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let ((?x11 (|of_nat$| (|nat$| (+ 1 (|of_nat$| |y$|))))))
-(let ((?x128 (+ (* (~ 1) (|of_nat$| |y$|)) ?x11)))
-(let ((?x134 (|of_nat$| (|nat$| ?x128))))
 (let ((?x8 (|of_nat$| |y$|)))
-(let (($x554 (= (+ ?x8 (* (~ 1) ?x11) ?x134) 0)))
-(let ((?x589 (+ ?x8 (* (~ 1) ?x11))))
-(let (($x270 (<= ?x589 0)))
-(let (($x572 (<= ?x589 (~ 1))))
-(let (($x579 (= ?x589 (~ 1))))
-(let (($x251 (>= ?x8 (~ 1))))
-(let (($x409 (>= ?x8 0)))
-(let (($x519 (= (|of_nat$| (|nat$| ?x8)) 0)))
-(let (($x605 (forall ((?v0 Int) )(!(let (($x31 (= (|of_nat$| (|nat$| ?v0)) 0)))
-(let (($x143 (>= ?v0 0)))
-(or $x143 $x31))) :pattern ( (|nat$| ?v0) )))
-))
-(let (($x158 (forall ((?v0 Int) )(let (($x31 (= (|of_nat$| (|nat$| ?v0)) 0)))
-(let (($x143 (>= ?v0 0)))
-(or $x143 $x31))))
+(let ((?x9 (+ 1 ?x8)))
+(let ((?x10 (|nat$| ?x9)))
+(let ((?x11 (|of_nat$| ?x10)))
+(let ((?x57 (* (~ 1) ?x8)))
+(let ((?x58 (+ ?x57 ?x11)))
+(let ((?x61 (|nat$| ?x58)))
+(let ((?x64 (|of_nat$| ?x61)))
+(let ((?x195 (* (~ 1) ?x11)))
+(let ((?x246 (+ ?x8 ?x195 ?x64)))
+(let (($x265 (>= ?x246 0)))
+(let (($x247 (= ?x246 0)))
+(let ((?x196 (+ ?x8 ?x195)))
+(let (($x240 (<= ?x196 0)))
+(let (($x215 (<= ?x196 (~ 1))))
+(let (($x197 (= ?x196 (~ 1))))
+(let (($x189 (>= ?x8 (~ 1))))
+(let (($x283 (>= ?x8 0)))
+(let ((?x172 (|nat$| ?x8)))
+(let ((?x284 (|of_nat$| ?x172)))
+(let (($x285 (= ?x284 0)))
+(let (($x286 (or $x283 $x285)))
+(let (($x166 (forall ((?v0 Int) )(!(let ((?x25 (|nat$| ?v0)))
+(let ((?x26 (|of_nat$| ?x25)))
+(let (($x31 (= ?x26 0)))
+(let (($x97 (>= ?v0 0)))
+(or $x97 $x31))))) :pattern ( (|nat$| ?v0) )))
 ))
-(let (($x31 (= (|of_nat$| (|nat$| ?0)) 0)))
-(let (($x143 (>= ?0 0)))
-(let (($x155 (or $x143 $x31)))
-(let (($x94 (forall ((?v0 Int) )(let (($x31 (= (|of_nat$| (|nat$| ?v0)) 0)))
-(let (($x24 (<= 0 ?v0)))
-(or $x24 $x31))))
+(let (($x131 (forall ((?v0 Int) )(let ((?x25 (|nat$| ?v0)))
+(let ((?x26 (|of_nat$| ?x25)))
+(let (($x31 (= ?x26 0)))
+(let (($x97 (>= ?v0 0)))
+(or $x97 $x31))))))
 ))
-(let ((@x157 (monotonicity (rewrite (= (<= 0 ?0) $x143)) (= (or (<= 0 ?0) $x31) $x155))))
-(let (($x33 (forall ((?v0 Int) )(let (($x31 (= (|of_nat$| (|nat$| ?v0)) 0)))
-(=> (< ?v0 0) $x31)))
+(let ((?x25 (|nat$| ?0)))
+(let ((?x26 (|of_nat$| ?x25)))
+(let (($x31 (= ?x26 0)))
+(let (($x97 (>= ?0 0)))
+(let (($x128 (or $x97 $x31)))
+(let (($x33 (forall ((?v0 Int) )(let ((?x25 (|nat$| ?v0)))
+(let ((?x26 (|of_nat$| ?x25)))
+(let (($x31 (= ?x26 0)))
+(let (($x30 (< ?v0 0)))
+(=> $x30 $x31))))))
 ))
-(let ((@x91 (rewrite (= (=> (not (<= 0 ?0)) $x31) (or (<= 0 ?0) $x31)))))
-(let ((@x84 (monotonicity (rewrite (= (<= 0 ?0) (<= 0 ?0))) (= (not (<= 0 ?0)) (not (<= 0 ?0))))))
-(let ((@x85 (trans (rewrite (= (< ?0 0) (not (<= 0 ?0)))) @x84 (= (< ?0 0) (not (<= 0 ?0))))))
-(let ((@x88 (monotonicity @x85 (= (=> (< ?0 0) $x31) (=> (not (<= 0 ?0)) $x31)))))
-(let ((@x93 (trans @x88 @x91 (= (=> (< ?0 0) $x31) (or (<= 0 ?0) $x31)))))
-(let ((@x109 (mp (mp (asserted $x33) (|quant-intro| @x93 (= $x33 $x94)) $x94) (|rewrite*| (= $x94 $x94)) $x94)))
-(let ((@x175 (|mp~| (mp @x109 (|quant-intro| @x157 (= $x94 $x158)) $x158) (|nnf-pos| (refl (|~| $x155 $x155)) (|~| $x158 $x158)) $x158)))
-(let ((@x425 (rewrite (= (or (not $x605) (or $x409 $x519)) (or (not $x605) $x409 $x519)))))
-(let ((@x418 (mp ((_ |quant-inst| (|of_nat$| |y$|)) (or (not $x605) (or $x409 $x519))) @x425 (or (not $x605) $x409 $x519))))
-(let ((@x508 (|unit-resolution| @x418 (mp @x175 (|quant-intro| (refl (= $x155 $x155)) (= $x158 $x605)) $x605) (or $x409 $x519))))
-(let (($x591 (forall ((?v0 |Nat$|) )(!(= (|nat$| (|of_nat$| ?v0)) ?v0) :pattern ( (|of_nat$| ?v0) )))
+(let (($x116 (forall ((?v0 Int) )(let ((?x25 (|nat$| ?v0)))
+(let ((?x26 (|of_nat$| ?x25)))
+(let (($x31 (= ?x26 0)))
+(let (($x30 (< ?v0 0)))
+(let (($x112 (not $x30)))
+(or $x112 $x31)))))))
+))
+(let ((@x123 (monotonicity (rewrite (= (< ?0 0) (not $x97))) (= (not (< ?0 0)) (not (not $x97))))))
+(let ((@x127 (trans @x123 (rewrite (= (not (not $x97)) $x97)) (= (not (< ?0 0)) $x97))))
+(let ((@x133 (|quant-intro| (monotonicity @x127 (= (or (not (< ?0 0)) $x31) $x128)) (= $x116 $x131))))
+(let ((@x115 (rewrite (= (=> (< ?0 0) $x31) (or (not (< ?0 0)) $x31)))))
+(let ((@x136 (mp (asserted $x33) (trans (|quant-intro| @x115 (= $x33 $x116)) @x133 (= $x33 $x131)) $x131)))
+(let ((@x171 (mp (|mp~| @x136 (|nnf-pos| (refl (|~| $x128 $x128)) (|~| $x131 $x131)) $x131) (|quant-intro| (refl (= $x128 $x128)) (= $x131 $x166)) $x166)))
+(let (($x222 (not $x166)))
+(let (($x289 (or $x222 $x283 $x285)))
+(let ((@x294 (mp ((_ |quant-inst| (|of_nat$| |y$|)) (or $x222 $x286)) (rewrite (= (or $x222 $x286) $x289)) $x289)))
+(let ((@x316 (|unit-resolution| (|unit-resolution| @x294 @x171 $x286) (hypothesis (not $x283)) $x285)))
+(let (($x173 (= ?x172 |y$|)))
+(let (($x153 (forall ((?v0 |Nat$|) )(!(= (|nat$| (|of_nat$| ?v0)) ?v0) :pattern ( (|of_nat$| ?v0) )))
 ))
 (let (($x22 (forall ((?v0 |Nat$|) )(= (|nat$| (|of_nat$| ?v0)) ?v0))
 ))
-(let ((@x596 (trans (rewrite (= $x22 $x591)) (rewrite (= $x591 $x591)) (= $x22 $x591))))
-(let ((@x166 (refl (|~| (= (|nat$| (|of_nat$| ?0)) ?0) (= (|nat$| (|of_nat$| ?0)) ?0)))))
-(let ((@x163 (|mp~| (mp (asserted $x22) (|rewrite*| (= $x22 $x22)) $x22) (|nnf-pos| @x166 (|~| $x22 $x22)) $x22)))
-(let ((@x510 (|unit-resolution| ((_ |quant-inst| |y$|) (or (not $x591) (= (|nat$| ?x8) |y$|))) (mp @x163 @x596 $x591) (= (|nat$| ?x8) |y$|))))
-(let ((@x497 (monotonicity (symm @x510 (= |y$| (|nat$| ?x8))) (= ?x8 (|of_nat$| (|nat$| ?x8))))))
-(let ((@x498 (trans @x497 (|unit-resolution| @x508 (hypothesis (not $x409)) $x519) (= ?x8 0))))
-(let ((@x502 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x8 0)) $x409)) (hypothesis (not $x409)) @x498 false)))
-(let ((@x490 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x409) $x251)) (lemma @x502 $x409) $x251)))
-(let (($x585 (not $x251)))
-(let (($x580 (or $x585 $x579)))
-(let (($x599 (forall ((?v0 Int) )(!(let (($x27 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(or (not (>= ?v0 0)) $x27)) :pattern ( (|nat$| ?v0) )))
+(let ((@x155 (refl (= (= (|nat$| (|of_nat$| ?0)) ?0) (= (|nat$| (|of_nat$| ?0)) ?0)))))
+(let ((@x140 (refl (|~| (= (|nat$| (|of_nat$| ?0)) ?0) (= (|nat$| (|of_nat$| ?0)) ?0)))))
+(let ((@x158 (mp (|mp~| (asserted $x22) (|nnf-pos| @x140 (|~| $x22 $x22)) $x22) (|quant-intro| @x155 (= $x22 $x153)) $x153)))
+(let (($x176 (not $x153)))
+(let (($x177 (or $x176 $x173)))
+(let ((@x178 ((_ |quant-inst| |y$|) $x177)))
+(let ((@x321 (monotonicity (symm (|unit-resolution| @x178 @x158 $x173) (= |y$| ?x172)) (= ?x8 ?x284))))
+(let ((@x326 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x8 0)) $x283)) (hypothesis (not $x283)) (trans @x321 @x316 (= ?x8 0)) false)))
+(let ((@x329 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x283) $x189)) (lemma @x326 $x283) $x189)))
+(let (($x192 (not $x189)))
+(let (($x200 (or $x192 $x197)))
+(let (($x160 (forall ((?v0 Int) )(!(let ((?x25 (|nat$| ?v0)))
+(let ((?x26 (|of_nat$| ?x25)))
+(let (($x27 (= ?x26 ?v0)))
+(let (($x97 (>= ?v0 0)))
+(let (($x99 (not $x97)))
+(or $x99 $x27)))))) :pattern ( (|nat$| ?v0) )))
 ))
-(let (($x151 (forall ((?v0 Int) )(let (($x27 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(or (not (>= ?v0 0)) $x27)))
+(let (($x105 (forall ((?v0 Int) )(let ((?x25 (|nat$| ?v0)))
+(let ((?x26 (|of_nat$| ?x25)))
+(let (($x27 (= ?x26 ?v0)))
+(let (($x97 (>= ?v0 0)))
+(let (($x99 (not $x97)))
+(or $x99 $x27)))))))
 ))
-(let (($x27 (= (|of_nat$| (|nat$| ?0)) ?0)))
-(let (($x148 (or (not $x143) $x27)))
-(let (($x77 (forall ((?v0 Int) )(let (($x27 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
+(let ((@x162 (refl (= (or (not $x97) (= ?x26 ?0)) (or (not $x97) (= ?x26 ?0))))))
+(let ((@x143 (refl (|~| (or (not $x97) (= ?x26 ?0)) (or (not $x97) (= ?x26 ?0))))))
+(let (($x29 (forall ((?v0 Int) )(let ((?x25 (|nat$| ?v0)))
+(let ((?x26 (|of_nat$| ?x25)))
+(let (($x27 (= ?x26 ?v0)))
 (let (($x24 (<= 0 ?v0)))
-(let (($x72 (not $x24)))
-(or $x72 $x27)))))
+(=> $x24 $x27))))))
 ))
-(let ((@x147 (monotonicity (rewrite (= (<= 0 ?0) $x143)) (= (not (<= 0 ?0)) (not $x143)))))
-(let ((@x153 (|quant-intro| (monotonicity @x147 (= (or (not (<= 0 ?0)) $x27) $x148)) (= $x77 $x151))))
-(let (($x29 (forall ((?v0 Int) )(let (($x27 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(let (($x24 (<= 0 ?v0)))
-(=> $x24 $x27))))
+(let (($x93 (forall ((?v0 Int) )(let ((?x25 (|nat$| ?v0)))
+(let ((?x26 (|of_nat$| ?x25)))
+(let (($x27 (= ?x26 ?v0)))
+(or (not (<= 0 ?v0)) $x27)))))
 ))
-(let ((@x75 (rewrite (= (=> (<= 0 ?0) $x27) (or (not (<= 0 ?0)) $x27)))))
-(let ((@x71 (monotonicity (rewrite (= (<= 0 ?0) (<= 0 ?0))) (= (=> (<= 0 ?0) $x27) (=> (<= 0 ?0) $x27)))))
-(let ((@x76 (trans @x71 @x75 (= (=> (<= 0 ?0) $x27) (or (not (<= 0 ?0)) $x27)))))
-(let ((@x106 (mp (mp (asserted $x29) (|quant-intro| @x76 (= $x29 $x77)) $x77) (|rewrite*| (= $x77 $x77)) $x77)))
-(let ((@x170 (|mp~| (mp @x106 @x153 $x151) (|nnf-pos| (refl (|~| $x148 $x148)) (|~| $x151 $x151)) $x151)))
-(let (($x224 (not $x599)))
-(let (($x565 (or $x224 $x585 $x579)))
-(let (($x227 (or $x224 (or (not (>= (+ 1 ?x8) 0)) (= ?x11 (+ 1 ?x8))))))
-(let (($x245 (= (or (not (>= (+ 1 ?x8) 0)) (= ?x11 (+ 1 ?x8))) $x580)))
-(let ((@x587 (monotonicity (rewrite (= (>= (+ 1 ?x8) 0) $x251)) (= (not (>= (+ 1 ?x8) 0)) $x585))))
-(let ((@x566 (monotonicity (monotonicity @x587 (rewrite (= (= ?x11 (+ 1 ?x8)) $x579)) $x245) (= $x227 (or $x224 $x580)))))
-(let ((@x571 (mp ((_ |quant-inst| (+ 1 ?x8)) $x227) (trans @x566 (rewrite (= (or $x224 $x580) $x565)) (= $x227 $x565)) $x565)))
-(let ((@x491 (|unit-resolution| @x571 (mp @x170 (|quant-intro| (refl (= $x148 $x148)) (= $x151 $x599)) $x599) $x580)))
-(let ((@x475 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x579) $x572)) (|unit-resolution| @x491 @x490 $x579) $x572)))
-(let (($x551 (not $x270)))
-(let (($x542 (or $x551 $x554)))
-(let (($x545 (or $x224 $x551 $x554)))
-(let (($x546 (or $x224 (or (not (>= ?x128 0)) (= ?x134 ?x128)))))
-(let ((@x276 (monotonicity (rewrite (= (>= ?x128 0) $x270)) (= (not (>= ?x128 0)) $x551))))
-(let ((@x544 (monotonicity @x276 (rewrite (= (= ?x134 ?x128) $x554)) (= (or (not (>= ?x128 0)) (= ?x134 ?x128)) $x542))))
-(let ((@x532 (trans (monotonicity @x544 (= $x546 (or $x224 $x542))) (rewrite (= (or $x224 $x542) $x545)) (= $x546 $x545))))
-(let ((@x480 (|unit-resolution| (mp ((_ |quant-inst| (+ (* (~ 1) ?x8) ?x11)) $x546) @x532 $x545) (mp @x170 (|quant-intro| (refl (= $x148 $x148)) (= $x151 $x599)) $x599) $x542)))
-(let ((@x481 (|unit-resolution| @x480 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x572) $x270)) @x475 $x270) $x554)))
-(let ((@x485 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x554) (>= (+ ?x8 (* (~ 1) ?x11) ?x134) 0))) @x481 (>= (+ ?x8 (* (~ 1) ?x11) ?x134) 0))))
-(let ((?x42 (+ ?x11 (* (~ 1) ?x8))))
-(let ((?x45 (|nat$| ?x42)))
-(let ((?x48 (|of_nat$| ?x45)))
-(let (($x54 (<= ?x48 0)))
-(let ((@x136 (monotonicity (monotonicity (rewrite (= ?x42 ?x128)) (= ?x45 (|nat$| ?x128))) (= ?x48 ?x134))))
-(let (($x16 (< (* 0 ?x11) (|of_nat$| (|nat$| (- ?x11 ?x8))))))
-(let (($x17 (not $x16)))
-(let ((@x47 (monotonicity (rewrite (= (- ?x11 ?x8) ?x42)) (= (|nat$| (- ?x11 ?x8)) ?x45))))
-(let ((@x53 (monotonicity (rewrite (= (* 0 ?x11) 0)) (monotonicity @x47 (= (|of_nat$| (|nat$| (- ?x11 ?x8))) ?x48)) (= $x16 (< 0 ?x48)))))
-(let ((@x59 (trans @x53 (rewrite (= (< 0 ?x48) (not $x54))) (= $x16 (not $x54)))))
-(let ((@x66 (trans (monotonicity @x59 (= $x17 (not (not $x54)))) (rewrite (= (not (not $x54)) $x54)) (= $x17 $x54))))
-(let ((@x142 (mp (mp (mp (asserted $x17) @x66 $x54) (|rewrite*| (= $x54 $x54)) $x54) (monotonicity @x136 (= $x54 (<= ?x134 0))) (<= ?x134 0))))
-((_ |th-lemma| arith farkas -1 -1 1) @x142 @x475 @x485 false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
+(let (($x27 (= ?x26 ?0)))
+(let (($x99 (not $x97)))
+(let (($x102 (or $x99 $x27)))
+(let (($x90 (or (not (<= 0 ?0)) $x27)))
+(let ((@x101 (monotonicity (rewrite (= (<= 0 ?0) $x97)) (= (not (<= 0 ?0)) $x99))))
+(let ((@x95 (|quant-intro| (rewrite (= (=> (<= 0 ?0) $x27) $x90)) (= $x29 $x93))))
+(let ((@x109 (trans @x95 (|quant-intro| (monotonicity @x101 (= $x90 $x102)) (= $x93 $x105)) (= $x29 $x105))))
+(let ((@x146 (|mp~| (mp (asserted $x29) @x109 $x105) (|nnf-pos| @x143 (|~| $x105 $x105)) $x105)))
+(let ((@x165 (mp @x146 (|quant-intro| @x162 (= $x105 $x160)) $x160)))
+(let (($x203 (not $x160)))
+(let (($x204 (or $x203 $x192 $x197)))
+(let (($x188 (or (not (>= ?x9 0)) (= ?x11 ?x9))))
+(let (($x205 (or $x203 $x188)))
+(let ((@x194 (monotonicity (rewrite (= (>= ?x9 0) $x189)) (= (not (>= ?x9 0)) $x192))))
+(let ((@x202 (monotonicity @x194 (rewrite (= (= ?x11 ?x9) $x197)) (= $x188 $x200))))
+(let ((@x213 (trans (monotonicity @x202 (= $x205 (or $x203 $x200))) (rewrite (= (or $x203 $x200) $x204)) (= $x205 $x204))))
+(let ((@x214 (mp ((_ |quant-inst| (+ 1 ?x8)) $x205) @x213 $x204)))
+(let ((@x335 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x197) $x215)) (|unit-resolution| (|unit-resolution| @x214 @x165 $x200) @x329 $x197) $x215)))
+(let (($x243 (not $x240)))
+(let (($x250 (or $x243 $x247)))
+(let (($x253 (or $x203 $x243 $x247)))
+(let (($x239 (or (not (>= ?x58 0)) (= ?x64 ?x58))))
+(let (($x254 (or $x203 $x239)))
+(let ((@x245 (monotonicity (rewrite (= (>= ?x58 0) $x240)) (= (not (>= ?x58 0)) $x243))))
+(let ((@x252 (monotonicity @x245 (rewrite (= (= ?x64 ?x58) $x247)) (= $x239 $x250))))
+(let ((@x262 (trans (monotonicity @x252 (= $x254 (or $x203 $x250))) (rewrite (= (or $x203 $x250) $x253)) (= $x254 $x253))))
+(let ((@x263 (mp ((_ |quant-inst| (+ ?x57 ?x11)) $x254) @x262 $x253)))
+(let ((@x341 (|unit-resolution| (|unit-resolution| @x263 @x165 $x250) (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x215) $x240)) @x335 $x240) $x247)))
+(let (($x73 (<= ?x64 0)))
+(let ((@x79 (monotonicity (rewrite (= (< 0 ?x64) (not $x73))) (= (not (< 0 ?x64)) (not (not $x73))))))
+(let ((@x83 (trans @x79 (rewrite (= (not (not $x73)) $x73)) (= (not (< 0 ?x64)) $x73))))
+(let (($x67 (< 0 ?x64)))
+(let (($x70 (not $x67)))
+(let (($x17 (not (< (* 0 ?x11) (|of_nat$| (|nat$| (- ?x11 ?x8)))))))
+(let ((@x63 (monotonicity (rewrite (= (- ?x11 ?x8) ?x58)) (= (|nat$| (- ?x11 ?x8)) ?x61))))
+(let ((@x69 (monotonicity (rewrite (= (* 0 ?x11) 0)) (monotonicity @x63 (= (|of_nat$| (|nat$| (- ?x11 ?x8))) ?x64)) (= (< (* 0 ?x11) (|of_nat$| (|nat$| (- ?x11 ?x8)))) $x67))))
+(let ((@x86 (mp (asserted $x17) (trans (monotonicity @x69 (= $x17 $x70)) @x83 (= $x17 $x73)) $x73)))
+((_ |th-lemma| arith farkas -1 -1 1) @x86 @x335 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x247) $x265)) @x341 $x265) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
 
-0f5c33836eb7c04b103caf9bdb4756aba933ece2 112 0
+72e646f619a773762ccf2e62425eb512a9cd35f3 144 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let ((?x11 (|of_nat$| (|nat$| (+ 1 (|of_nat$| |y$|))))))
-(let ((?x75 (+ (~ 1) ?x11)))
-(let ((?x82 (|nat$| ?x75)))
-(let ((?x335 (|of_nat$| ?x82)))
 (let ((?x8 (|of_nat$| |y$|)))
-(let (($x419 (>= (+ ?x8 (* (~ 1) ?x335)) 0)))
-(let (($x85 (= ?x82 |y$|)))
-(let (($x54 (<= ?x11 0)))
-(let (($x13 (ite (< 0 ?x11) true false)))
-(let (($x18 (not $x13)))
-(let (($x19 (=> $x18 false)))
-(let (($x46 (not $x19)))
-(let ((@x60 (monotonicity (rewrite (= (< 0 ?x11) (not $x54))) (= $x13 (ite (not $x54) true false)))))
-(let ((@x64 (trans @x60 (rewrite (= (ite (not $x54) true false) (not $x54))) (= $x13 (not $x54)))))
-(let ((@x106 (trans (monotonicity @x64 (= $x18 (not (not $x54)))) (rewrite (= (not (not $x54)) $x54)) (= $x18 $x54))))
-(let ((@x113 (trans (monotonicity @x106 (= $x19 (=> $x54 false))) (rewrite (= (=> $x54 false) (not $x54))) (= $x19 (not $x54)))))
-(let ((@x117 (trans (monotonicity @x113 (= $x46 (not (not $x54)))) (rewrite (= (not (not $x54)) $x54)) (= $x46 $x54))))
-(let (($x22 (not (or false (or (= $x13 (= (|nat$| (- ?x11 1)) |y$|)) $x19)))))
-(let ((@x43 (|not-or-elim| (asserted $x22) (not (or (= $x13 (= (|nat$| (- ?x11 1)) |y$|)) $x19)))))
-(let ((@x51 (monotonicity (|iff-true| (mp (|not-or-elim| @x43 $x46) @x117 $x54) (= $x54 true)) (= (= $x54 $x85) (= true $x85)))))
-(let ((@x152 (trans @x51 (rewrite (= (= true $x85) $x85)) (= (= $x54 $x85) $x85))))
-(let (($x94 (= $x54 $x85)))
+(let ((?x9 (+ 1 ?x8)))
+(let ((?x10 (|nat$| ?x9)))
+(let ((?x11 (|of_nat$| ?x10)))
+(let ((?x62 (+ (~ 1) ?x11)))
+(let ((?x65 (|nat$| ?x62)))
+(let ((?x281 (|of_nat$| ?x65)))
+(let ((?x291 (* (~ 1) ?x281)))
+(let ((?x330 (+ ?x8 ?x291)))
+(let (($x332 (>= ?x330 0)))
+(let (($x329 (= ?x8 ?x281)))
+(let (($x68 (= ?x65 |y$|)))
+(let (($x102 (<= ?x11 0)))
+(let (($x112 (not (or (= (not $x102) $x68) (not $x102)))))
+(let (($x19 (=> (not (ite (< 0 ?x11) true false)) false)))
+(let (($x12 (< 0 ?x11)))
+(let (($x13 (ite $x12 true false)))
 (let (($x17 (= $x13 (= (|nat$| (- ?x11 1)) |y$|))))
-(let (($x44 (not $x17)))
-(let ((@x74 (monotonicity (rewrite (= (* (~ 1) 1) (~ 1))) (= (+ ?x11 (* (~ 1) 1)) (+ ?x11 (~ 1))))))
-(let ((@x79 (trans @x74 (rewrite (= (+ ?x11 (~ 1)) ?x75)) (= (+ ?x11 (* (~ 1) 1)) ?x75))))
-(let ((@x81 (trans (rewrite (= (- ?x11 1) (+ ?x11 (* (~ 1) 1)))) @x79 (= (- ?x11 1) ?x75))))
-(let ((@x87 (monotonicity (monotonicity @x81 (= (|nat$| (- ?x11 1)) ?x82)) (= (= (|nat$| (- ?x11 1)) |y$|) $x85))))
-(let ((@x93 (monotonicity (monotonicity @x64 @x87 (= $x17 (= (not $x54) $x85))) (= $x44 (not (= (not $x54) $x85))))))
-(let ((@x98 (trans @x93 (rewrite (= (not (= (not $x54) $x85)) $x94)) (= $x44 $x94))))
-(let ((@x156 (mp (mp (mp (|not-or-elim| @x43 $x44) @x98 $x94) @x152 $x85) (|rewrite*| (= $x85 $x85)) $x85)))
-(let ((@x569 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x8 ?x335)) $x419)) (monotonicity (symm @x156 (= |y$| ?x82)) (= ?x8 ?x335)) $x419)))
-(let (($x631 (= (+ ?x8 (* (~ 1) ?x11)) (~ 1))))
-(let (($x629 (>= ?x8 (~ 1))))
-(let (($x577 (>= ?x335 0)))
-(let (($x579 (= ?x335 0)))
-(let ((@x159 (mp (mp (|not-or-elim| @x43 $x46) @x117 $x54) (|rewrite*| (= $x54 $x54)) $x54)))
-(let ((@x558 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not (>= ?x11 1)) (not $x54))) @x159 (not (>= ?x11 1)))))
-(let (($x651 (forall ((?v0 Int) )(!(let (($x36 (= (|of_nat$| (|nat$| ?v0)) 0)))
-(let (($x189 (>= ?v0 0)))
-(or $x189 $x36))) :pattern ( (|nat$| ?v0) )))
+(let (($x21 (or false (or $x17 $x19))))
+(let (($x22 (not $x21)))
+(let (($x74 (= $x12 $x68)))
+(let (($x89 (or $x74 $x12)))
+(let ((@x108 (monotonicity (rewrite (= $x12 (not $x102))) (= $x74 (= (not $x102) $x68)))))
+(let ((@x111 (monotonicity @x108 (rewrite (= $x12 (not $x102))) (= $x89 (or (= (not $x102) $x68) (not $x102))))))
+(let ((@x84 (monotonicity (monotonicity (rewrite (= $x13 $x12)) (= (not $x13) (not $x12))) (= $x19 (=> (not $x12) false)))))
+(let ((@x88 (trans @x84 (rewrite (= (=> (not $x12) false) $x12)) (= $x19 $x12))))
+(let ((@x67 (monotonicity (rewrite (= (- ?x11 1) ?x62)) (= (|nat$| (- ?x11 1)) ?x65))))
+(let ((@x73 (monotonicity (rewrite (= $x13 $x12)) (monotonicity @x67 (= (= (|nat$| (- ?x11 1)) |y$|) $x68)) (= $x17 (= $x12 $x68)))))
+(let ((@x91 (monotonicity (trans @x73 (rewrite (= (= $x12 $x68) $x74)) (= $x17 $x74)) @x88 (= (or $x17 $x19) $x89))))
+(let ((@x98 (trans (monotonicity @x91 (= $x21 (or false $x89))) (rewrite (= (or false $x89) $x89)) (= $x21 $x89))))
+(let ((@x116 (trans (monotonicity @x98 (= $x22 (not $x89))) (monotonicity @x111 (= (not $x89) $x112)) (= $x22 $x112))))
+(let ((@x120 (|not-or-elim| (mp (asserted $x22) @x116 $x112) $x102)))
+(let (($x171 (= $x102 $x68)))
+(let ((@x119 (|not-or-elim| (mp (asserted $x22) @x116 $x112) (not (= (not $x102) $x68)))))
+(let ((@x173 (mp @x119 (rewrite (= (not (= (not $x102) $x68)) $x171)) $x171)))
+(let ((@x219 (|unit-resolution| (|def-axiom| (or (not $x102) $x68 (not $x171))) @x173 (or (not $x102) $x68))))
+(let ((@x345 (monotonicity (symm (|unit-resolution| @x219 @x120 $x68) (= |y$| ?x65)) $x329)))
+(let ((?x241 (* (~ 1) ?x11)))
+(let ((?x242 (+ ?x8 ?x241)))
+(let (($x259 (<= ?x242 (~ 1))))
+(let (($x240 (= ?x242 (~ 1))))
+(let (($x233 (>= ?x8 (~ 1))))
+(let (($x328 (>= ?x281 0)))
+(let (($x311 (= ?x281 0)))
+(let (($x284 (>= ?x11 1)))
+(let (($x287 (not $x284)))
+(let (($x204 (forall ((?v0 Int) )(!(let ((?x30 (|nat$| ?v0)))
+(let ((?x31 (|of_nat$| ?x30)))
+(let (($x36 (= ?x31 0)))
+(let (($x131 (>= ?v0 0)))
+(or $x131 $x36))))) :pattern ( (|nat$| ?v0) )))
 ))
-(let (($x204 (forall ((?v0 Int) )(let (($x36 (= (|of_nat$| (|nat$| ?v0)) 0)))
-(let (($x189 (>= ?v0 0)))
-(or $x189 $x36))))
+(let (($x165 (forall ((?v0 Int) )(let ((?x30 (|nat$| ?v0)))
+(let ((?x31 (|of_nat$| ?x30)))
+(let (($x36 (= ?x31 0)))
+(let (($x131 (>= ?v0 0)))
+(or $x131 $x36))))))
 ))
-(let (($x36 (= (|of_nat$| (|nat$| ?0)) 0)))
-(let (($x189 (>= ?0 0)))
-(let (($x201 (or $x189 $x36)))
-(let (($x145 (forall ((?v0 Int) )(let (($x36 (= (|of_nat$| (|nat$| ?v0)) 0)))
-(let (($x29 (<= 0 ?v0)))
-(or $x29 $x36))))
+(let ((?x30 (|nat$| ?0)))
+(let ((?x31 (|of_nat$| ?x30)))
+(let (($x36 (= ?x31 0)))
+(let (($x131 (>= ?0 0)))
+(let (($x162 (or $x131 $x36)))
+(let (($x38 (forall ((?v0 Int) )(let ((?x30 (|nat$| ?v0)))
+(let ((?x31 (|of_nat$| ?x30)))
+(let (($x36 (= ?x31 0)))
+(let (($x35 (< ?v0 0)))
+(=> $x35 $x36))))))
 ))
-(let ((@x203 (monotonicity (rewrite (= (<= 0 ?0) $x189)) (= (or (<= 0 ?0) $x36) $x201))))
-(let (($x38 (forall ((?v0 Int) )(let (($x36 (= (|of_nat$| (|nat$| ?v0)) 0)))
-(=> (< ?v0 0) $x36)))
+(let (($x150 (forall ((?v0 Int) )(let ((?x30 (|nat$| ?v0)))
+(let ((?x31 (|of_nat$| ?x30)))
+(let (($x36 (= ?x31 0)))
+(let (($x35 (< ?v0 0)))
+(let (($x146 (not $x35)))
+(or $x146 $x36)))))))
 ))
-(let ((@x142 (rewrite (= (=> (not (<= 0 ?0)) $x36) (or (<= 0 ?0) $x36)))))
-(let ((@x135 (monotonicity (rewrite (= (<= 0 ?0) (<= 0 ?0))) (= (not (<= 0 ?0)) (not (<= 0 ?0))))))
-(let ((@x136 (trans (rewrite (= (< ?0 0) (not (<= 0 ?0)))) @x135 (= (< ?0 0) (not (<= 0 ?0))))))
-(let ((@x139 (monotonicity @x136 (= (=> (< ?0 0) $x36) (=> (not (<= 0 ?0)) $x36)))))
-(let ((@x144 (trans @x139 @x142 (= (=> (< ?0 0) $x36) (or (<= 0 ?0) $x36)))))
-(let ((@x168 (mp (mp (asserted $x38) (|quant-intro| @x144 (= $x38 $x145)) $x145) (|rewrite*| (= $x145 $x145)) $x145)))
-(let ((@x221 (|mp~| (mp @x168 (|quant-intro| @x203 (= $x145 $x204)) $x204) (|nnf-pos| (refl (|~| $x201 $x201)) (|~| $x204 $x204)) $x204)))
-(let (($x606 (>= ?x11 1)))
-(let (($x620 (not $x651)))
-(let (($x584 (or $x620 $x606 $x579)))
-(let ((@x583 (monotonicity (rewrite (= (>= ?x75 0) $x606)) (= (or (>= ?x75 0) $x579) (or $x606 $x579)))))
-(let ((@x415 (monotonicity @x583 (= (or $x620 (or (>= ?x75 0) $x579)) (or $x620 (or $x606 $x579))))))
-(let ((@x574 (trans @x415 (rewrite (= (or $x620 (or $x606 $x579)) $x584)) (= (or $x620 (or (>= ?x75 0) $x579)) $x584))))
-(let ((@x559 (|unit-resolution| (mp ((_ |quant-inst| (+ (~ 1) ?x11)) (or $x620 (or (>= ?x75 0) $x579))) @x574 $x584) (mp @x221 (|quant-intro| (refl (= $x201 $x201)) (= $x204 $x651)) $x651) @x558 $x579)))
-(let ((@x552 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1) (or $x629 (not $x577) (not $x419))) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x579) $x577)) @x559 $x577) @x569 $x629)))
-(let (($x624 (not $x629)))
-(let (($x635 (or $x624 $x631)))
-(let (($x645 (forall ((?v0 Int) )(!(let (($x32 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(or (not (>= ?v0 0)) $x32)) :pattern ( (|nat$| ?v0) )))
+(let ((@x157 (monotonicity (rewrite (= (< ?0 0) (not $x131))) (= (not (< ?0 0)) (not (not $x131))))))
+(let ((@x161 (trans @x157 (rewrite (= (not (not $x131)) $x131)) (= (not (< ?0 0)) $x131))))
+(let ((@x167 (|quant-intro| (monotonicity @x161 (= (or (not (< ?0 0)) $x36) $x162)) (= $x150 $x165))))
+(let ((@x149 (rewrite (= (=> (< ?0 0) $x36) (or (not (< ?0 0)) $x36)))))
+(let ((@x170 (mp (asserted $x38) (trans (|quant-intro| @x149 (= $x38 $x150)) @x167 (= $x38 $x165)) $x165)))
+(let ((@x209 (mp (|mp~| @x170 (|nnf-pos| (refl (|~| $x162 $x162)) (|~| $x165 $x165)) $x165) (|quant-intro| (refl (= $x162 $x162)) (= $x165 $x204)) $x204)))
+(let (($x266 (not $x204)))
+(let (($x316 (or $x266 $x284 $x311)))
+(let ((@x286 (rewrite (= (>= ?x62 0) $x284))))
+(let ((@x321 (monotonicity (monotonicity @x286 (= (or (>= ?x62 0) $x311) (or $x284 $x311))) (= (or $x266 (or (>= ?x62 0) $x311)) (or $x266 (or $x284 $x311))))))
+(let ((@x325 (trans @x321 (rewrite (= (or $x266 (or $x284 $x311)) $x316)) (= (or $x266 (or (>= ?x62 0) $x311)) $x316))))
+(let ((@x326 (mp ((_ |quant-inst| (+ (~ 1) ?x11)) (or $x266 (or (>= ?x62 0) $x311))) @x325 $x316)))
+(let ((@x353 (|unit-resolution| @x326 @x209 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x287 (not $x102))) @x120 $x287) $x311)))
+(let ((@x362 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1) (or $x233 (not $x328) (not $x332))) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x311) $x328)) @x353 $x328) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x329) $x332)) @x345 $x332) $x233)))
+(let (($x236 (not $x233)))
+(let (($x244 (or $x236 $x240)))
+(let (($x198 (forall ((?v0 Int) )(!(let ((?x30 (|nat$| ?v0)))
+(let ((?x31 (|of_nat$| ?x30)))
+(let (($x32 (= ?x31 ?v0)))
+(let (($x131 (>= ?v0 0)))
+(let (($x133 (not $x131)))
+(or $x133 $x32)))))) :pattern ( (|nat$| ?v0) )))
 ))
-(let (($x197 (forall ((?v0 Int) )(let (($x32 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(or (not (>= ?v0 0)) $x32)))
+(let (($x139 (forall ((?v0 Int) )(let ((?x30 (|nat$| ?v0)))
+(let ((?x31 (|of_nat$| ?x30)))
+(let (($x32 (= ?x31 ?v0)))
+(let (($x131 (>= ?v0 0)))
+(let (($x133 (not $x131)))
+(or $x133 $x32)))))))
 ))
-(let (($x32 (= (|of_nat$| (|nat$| ?0)) ?0)))
-(let (($x194 (or (not $x189) $x32)))
-(let (($x128 (forall ((?v0 Int) )(let (($x32 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
+(let ((@x200 (refl (= (or (not $x131) (= ?x31 ?0)) (or (not $x131) (= ?x31 ?0))))))
+(let ((@x181 (refl (|~| (or (not $x131) (= ?x31 ?0)) (or (not $x131) (= ?x31 ?0))))))
+(let (($x34 (forall ((?v0 Int) )(let ((?x30 (|nat$| ?v0)))
+(let ((?x31 (|of_nat$| ?x30)))
+(let (($x32 (= ?x31 ?v0)))
 (let (($x29 (<= 0 ?v0)))
-(let (($x123 (not $x29)))
-(or $x123 $x32)))))
+(=> $x29 $x32))))))
 ))
-(let ((@x193 (monotonicity (rewrite (= (<= 0 ?0) $x189)) (= (not (<= 0 ?0)) (not $x189)))))
-(let ((@x199 (|quant-intro| (monotonicity @x193 (= (or (not (<= 0 ?0)) $x32) $x194)) (= $x128 $x197))))
-(let (($x34 (forall ((?v0 Int) )(let (($x32 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(let (($x29 (<= 0 ?v0)))
-(=> $x29 $x32))))
+(let (($x127 (forall ((?v0 Int) )(let ((?x30 (|nat$| ?v0)))
+(let ((?x31 (|of_nat$| ?x30)))
+(let (($x32 (= ?x31 ?v0)))
+(or (not (<= 0 ?v0)) $x32)))))
 ))
-(let ((@x126 (rewrite (= (=> (<= 0 ?0) $x32) (or (not (<= 0 ?0)) $x32)))))
-(let ((@x122 (monotonicity (rewrite (= (<= 0 ?0) (<= 0 ?0))) (= (=> (<= 0 ?0) $x32) (=> (<= 0 ?0) $x32)))))
-(let ((@x127 (trans @x122 @x126 (= (=> (<= 0 ?0) $x32) (or (not (<= 0 ?0)) $x32)))))
-(let ((@x165 (mp (mp (asserted $x34) (|quant-intro| @x127 (= $x34 $x128)) $x128) (|rewrite*| (= $x128 $x128)) $x128)))
-(let ((@x216 (|mp~| (mp @x165 @x199 $x197) (|nnf-pos| (refl (|~| $x194 $x194)) (|~| $x197 $x197)) $x197)))
-(let (($x289 (not $x645)))
-(let (($x626 (or $x289 $x624 $x631)))
-(let (($x291 (or $x289 (or (not (>= (+ 1 ?x8) 0)) (= ?x11 (+ 1 ?x8))))))
-(let (($x625 (= (or (not (>= (+ 1 ?x8) 0)) (= ?x11 (+ 1 ?x8))) $x635)))
-(let ((@x298 (monotonicity (rewrite (= (>= (+ 1 ?x8) 0) $x629)) (= (not (>= (+ 1 ?x8) 0)) $x624))))
-(let ((@x273 (monotonicity (monotonicity @x298 (rewrite (= (= ?x11 (+ 1 ?x8)) $x631)) $x625) (= $x291 (or $x289 $x635)))))
-(let ((@x613 (mp ((_ |quant-inst| (+ 1 ?x8)) $x291) (trans @x273 (rewrite (= (or $x289 $x635) $x626)) (= $x291 $x626)) $x626)))
-(let ((@x553 (|unit-resolution| @x613 (mp @x216 (|quant-intro| (refl (= $x194 $x194)) (= $x197 $x645)) $x645) $x635)))
-(let ((@x541 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x631) (<= (+ ?x8 (* (~ 1) ?x11)) (~ 1)))) (|unit-resolution| @x553 @x552 $x631) (<= (+ ?x8 (* (~ 1) ?x11)) (~ 1)))))
-((_ |th-lemma| arith farkas 1 -1 -1 1) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x579) $x577)) @x559 $x577) @x159 @x541 @x569 false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
+(let (($x32 (= ?x31 ?0)))
+(let (($x133 (not $x131)))
+(let (($x136 (or $x133 $x32)))
+(let (($x124 (or (not (<= 0 ?0)) $x32)))
+(let ((@x135 (monotonicity (rewrite (= (<= 0 ?0) $x131)) (= (not (<= 0 ?0)) $x133))))
+(let ((@x129 (|quant-intro| (rewrite (= (=> (<= 0 ?0) $x32) $x124)) (= $x34 $x127))))
+(let ((@x143 (trans @x129 (|quant-intro| (monotonicity @x135 (= $x124 $x136)) (= $x127 $x139)) (= $x34 $x139))))
+(let ((@x184 (|mp~| (mp (asserted $x34) @x143 $x139) (|nnf-pos| @x181 (|~| $x139 $x139)) $x139)))
+(let ((@x203 (mp @x184 (|quant-intro| @x200 (= $x139 $x198)) $x198)))
+(let (($x247 (not $x198)))
+(let (($x248 (or $x247 $x236 $x240)))
+(let (($x231 (= ?x11 ?x9)))
+(let (($x227 (>= ?x9 0)))
+(let (($x228 (not $x227)))
+(let (($x232 (or $x228 $x231)))
+(let (($x249 (or $x247 $x232)))
+(let ((@x246 (monotonicity (monotonicity (rewrite (= $x227 $x233)) (= $x228 $x236)) (rewrite (= $x231 $x240)) (= $x232 $x244))))
+(let ((@x257 (trans (monotonicity @x246 (= $x249 (or $x247 $x244))) (rewrite (= (or $x247 $x244) $x248)) (= $x249 $x248))))
+(let ((@x258 (mp ((_ |quant-inst| (+ 1 ?x8)) $x249) @x257 $x248)))
+(let ((@x368 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x240) $x259)) (|unit-resolution| (|unit-resolution| @x258 @x203 $x244) @x362 $x240) $x259)))
+((_ |th-lemma| arith farkas 1 -1 -1 1) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x311) $x328)) @x353 $x328) @x120 @x368 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x329) $x332)) @x345 $x332) false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
 
-0c9ea539f37d7b052d3668e6cc284a6b6fb59ca4 60 0
+bda6be21dc699a816acc75c786757ad36dd913c8 78 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let ((?x44 (* (~ 1) |x$|)))
-(let (($x140 (>= |x$| 0)))
-(let ((?x143 (ite $x140 |x$| ?x44)))
-(let (($x279 (= ?x44 ?x143)))
-(let (($x193 (= |x$| ?x143)))
-(let ((@x585 (|unit-resolution| (|def-axiom| (or (not $x140) $x193)) (hypothesis $x140) $x193)))
-(let ((@x589 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x193) (<= (+ |x$| (* (~ 1) ?x143)) 0))) @x585 (<= (+ |x$| (* (~ 1) ?x143)) 0))))
-(let (($x286 (not (>= ?x143 0))))
-(let (($x617 (forall ((?v0 Int) )(!(let (($x23 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(or (not (>= ?v0 0)) $x23)) :pattern ( (|nat$| ?v0) )))
+(let ((?x51 (* (~ 1) |x$|)))
+(let (($x69 (>= |x$| 0)))
+(let ((?x76 (ite $x69 |x$| ?x51)))
+(let ((?x213 (* (~ 1) ?x76)))
+(let ((?x216 (+ ?x51 ?x213)))
+(let (($x226 (<= ?x216 0)))
+(let (($x182 (= ?x51 ?x76)))
+(let (($x70 (not $x69)))
+(let (($x181 (= |x$| ?x76)))
+(let ((@x222 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x181) (<= (+ |x$| ?x213) 0))) (|unit-resolution| (|def-axiom| (or $x70 $x181)) (hypothesis $x69) $x181) (<= (+ |x$| ?x213) 0))))
+(let (($x189 (>= ?x76 0)))
+(let (($x190 (not $x189)))
+(let (($x169 (forall ((?v0 Int) )(!(let ((?x21 (|nat$| ?v0)))
+(let ((?x22 (|of_nat$| ?x21)))
+(let (($x23 (= ?x22 ?v0)))
+(let (($x106 (>= ?v0 0)))
+(let (($x108 (not $x106)))
+(or $x108 $x23)))))) :pattern ( (|nat$| ?v0) )))
 ))
-(let (($x168 (forall ((?v0 Int) )(let (($x23 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(or (not (>= ?v0 0)) $x23)))
+(let (($x114 (forall ((?v0 Int) )(let ((?x21 (|nat$| ?v0)))
+(let ((?x22 (|of_nat$| ?x21)))
+(let (($x23 (= ?x22 ?v0)))
+(let (($x106 (>= ?v0 0)))
+(let (($x108 (not $x106)))
+(or $x108 $x23)))))))
 ))
-(let (($x23 (= (|of_nat$| (|nat$| ?0)) ?0)))
-(let (($x165 (or (not (>= ?0 0)) $x23)))
-(let (($x77 (forall ((?v0 Int) )(let (($x23 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(or (not (<= 0 ?v0)) $x23)))
-))
-(let ((@x164 (monotonicity (rewrite (= (<= 0 ?0) (>= ?0 0))) (= (not (<= 0 ?0)) (not (>= ?0 0))))))
-(let ((@x170 (|quant-intro| (monotonicity @x164 (= (or (not (<= 0 ?0)) $x23) $x165)) (= $x77 $x168))))
-(let (($x25 (forall ((?v0 Int) )(let (($x23 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
+(let ((?x21 (|nat$| ?0)))
+(let ((?x22 (|of_nat$| ?x21)))
+(let (($x23 (= ?x22 ?0)))
+(let (($x106 (>= ?0 0)))
+(let (($x108 (not $x106)))
+(let (($x111 (or $x108 $x23)))
+(let (($x25 (forall ((?v0 Int) )(let ((?x21 (|nat$| ?v0)))
+(let ((?x22 (|of_nat$| ?x21)))
+(let (($x23 (= ?x22 ?v0)))
 (let (($x20 (<= 0 ?v0)))
-(=> $x20 $x23))))
+(=> $x20 $x23))))))
 ))
-(let ((@x75 (rewrite (= (=> (<= 0 ?0) $x23) (or (not (<= 0 ?0)) $x23)))))
-(let ((@x71 (monotonicity (rewrite (= (<= 0 ?0) (<= 0 ?0))) (= (=> (<= 0 ?0) $x23) (=> (<= 0 ?0) $x23)))))
-(let ((@x76 (trans @x71 @x75 (= (=> (<= 0 ?0) $x23) (or (not (<= 0 ?0)) $x23)))))
-(let ((@x106 (mp (mp (asserted $x25) (|quant-intro| @x76 (= $x25 $x77)) $x77) (|rewrite*| (= $x77 $x77)) $x77)))
-(let ((@x187 (|mp~| (mp @x106 @x170 $x168) (|nnf-pos| (refl (|~| $x165 $x165)) (|~| $x168 $x168)) $x168)))
-(let (($x34 (<= 0 |x$|)))
-(let ((?x50 (ite $x34 |x$| ?x44)))
-(let ((?x55 (|nat$| ?x50)))
-(let ((?x58 (|of_nat$| ?x55)))
-(let (($x61 (= ?x58 ?x50)))
-(let (($x64 (not $x61)))
-(let ((@x148 (monotonicity (monotonicity (rewrite (= $x34 $x140)) (= ?x50 ?x143)) (= ?x55 (|nat$| ?x143)))))
-(let ((@x154 (monotonicity (monotonicity @x148 (= ?x58 (|of_nat$| (|nat$| ?x143)))) (monotonicity (rewrite (= $x34 $x140)) (= ?x50 ?x143)) (= $x61 (= (|of_nat$| (|nat$| ?x143)) ?x143)))))
-(let ((@x113 (monotonicity (monotonicity (rewrite (= $x34 $x34)) (= ?x50 ?x50)) (= ?x55 ?x55))))
-(let ((@x117 (monotonicity (monotonicity @x113 (= ?x58 ?x58)) (monotonicity (rewrite (= $x34 $x34)) (= ?x50 ?x50)) (= $x61 $x61))))
-(let ((?x9 (ite (< |x$| 0) (- |x$|) |x$|)))
+(let (($x102 (forall ((?v0 Int) )(let ((?x21 (|nat$| ?v0)))
+(let ((?x22 (|of_nat$| ?x21)))
+(let (($x23 (= ?x22 ?v0)))
+(or (not (<= 0 ?v0)) $x23)))))
+))
+(let ((@x110 (monotonicity (rewrite (= (<= 0 ?0) $x106)) (= (not (<= 0 ?0)) $x108))))
+(let ((@x116 (|quant-intro| (monotonicity @x110 (= (or (not (<= 0 ?0)) $x23) $x111)) (= $x102 $x114))))
+(let ((@x101 (rewrite (= (=> (<= 0 ?0) $x23) (or (not (<= 0 ?0)) $x23)))))
+(let ((@x119 (mp (asserted $x25) (trans (|quant-intro| @x101 (= $x25 $x102)) @x116 (= $x25 $x114)) $x114)))
+(let ((@x174 (mp (|mp~| @x119 (|nnf-pos| (refl (|~| $x111 $x111)) (|~| $x114 $x114)) $x114) (|quant-intro| (refl (= $x111 $x111)) (= $x114 $x169)) $x169)))
+(let ((?x81 (|nat$| ?x76)))
+(let ((?x84 (|of_nat$| ?x81)))
+(let (($x87 (= ?x84 ?x76)))
+(let (($x90 (not $x87)))
+(let (($x7 (< |x$| 0)))
+(let ((?x9 (ite $x7 (- |x$|) |x$|)))
 (let (($x13 (not (= (|of_nat$| (|nat$| ?x9)) ?x9))))
-(let ((@x42 (trans (rewrite (= (< |x$| 0) (not $x34))) (monotonicity (rewrite (= $x34 $x34)) (= (not $x34) (not $x34))) (= (< |x$| 0) (not $x34)))))
-(let ((@x49 (monotonicity @x42 (rewrite (= (- |x$|) ?x44)) (= ?x9 (ite (not $x34) ?x44 |x$|)))))
-(let ((@x54 (trans @x49 (rewrite (= (ite (not $x34) ?x44 |x$|) ?x50)) (= ?x9 ?x50))))
-(let ((@x60 (monotonicity (monotonicity @x54 (= (|nat$| ?x9) ?x55)) (= (|of_nat$| (|nat$| ?x9)) ?x58))))
-(let ((@x66 (monotonicity (monotonicity @x60 @x54 (= (= (|of_nat$| (|nat$| ?x9)) ?x9) $x61)) (= $x13 $x64))))
-(let ((@x119 (mp (mp (mp (asserted $x13) @x66 $x64) (|rewrite*| (= $x64 $x64)) $x64) (monotonicity @x117 (= $x64 $x64)) $x64)))
-(let ((@x158 (mp (mp @x119 (monotonicity @x117 (= $x64 $x64)) $x64) (monotonicity @x154 (= $x64 (not (= (|of_nat$| (|nat$| ?x143)) ?x143)))) (not (= (|of_nat$| (|nat$| ?x143)) ?x143)))))
-(let (($x604 (= (or (not $x617) (or $x286 (= (|of_nat$| (|nat$| ?x143)) ?x143))) (or (not $x617) $x286 (= (|of_nat$| (|nat$| ?x143)) ?x143)))))
-(let ((@x606 (mp ((_ |quant-inst| (ite $x140 |x$| ?x44)) (or (not $x617) (or $x286 (= (|of_nat$| (|nat$| ?x143)) ?x143)))) (rewrite $x604) (or (not $x617) $x286 (= (|of_nat$| (|nat$| ?x143)) ?x143)))))
-(let ((@x590 (|unit-resolution| @x606 @x158 (mp @x187 (|quant-intro| (refl (= $x165 $x165)) (= $x168 $x617)) $x617) $x286)))
-(let ((@x233 (|unit-resolution| (|def-axiom| (or $x140 $x279)) (lemma ((_ |th-lemma| arith farkas -1 1 1) (hypothesis $x140) @x590 @x589 false) (not $x140)) $x279)))
-(let ((@x581 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x279) (<= (+ ?x44 (* (~ 1) ?x143)) 0))) @x233 (<= (+ ?x44 (* (~ 1) ?x143)) 0))))
-(let ((@x301 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (<= ?x143 0) (>= ?x143 0))) @x590 (<= ?x143 0))))
-((_ |th-lemma| arith farkas 1 1 1) @x301 (lemma ((_ |th-lemma| arith farkas -1 1 1) (hypothesis $x140) @x590 @x589 false) (not $x140)) @x581 false)))))))))))))))))))))))))))))))))))))))))))))))))
+(let (($x91 (= (not (= (|of_nat$| (|nat$| (ite $x7 ?x51 |x$|))) (ite $x7 ?x51 |x$|))) $x90)))
+(let ((?x54 (ite $x7 ?x51 |x$|)))
+(let ((?x57 (|nat$| ?x54)))
+(let ((?x60 (|of_nat$| ?x57)))
+(let (($x63 (= ?x60 ?x54)))
+(let ((@x80 (trans (monotonicity (rewrite (= $x7 $x70)) (= ?x54 (ite $x70 ?x51 |x$|))) (rewrite (= (ite $x70 ?x51 |x$|) ?x76)) (= ?x54 ?x76))))
+(let ((@x89 (monotonicity (monotonicity (monotonicity @x80 (= ?x57 ?x81)) (= ?x60 ?x84)) @x80 (= $x63 $x87))))
+(let ((@x59 (monotonicity (monotonicity (rewrite (= (- |x$|) ?x51)) (= ?x9 ?x54)) (= (|nat$| ?x9) ?x57))))
+(let ((@x65 (monotonicity (monotonicity @x59 (= (|of_nat$| (|nat$| ?x9)) ?x60)) (monotonicity (rewrite (= (- |x$|) ?x51)) (= ?x9 ?x54)) (= (= (|of_nat$| (|nat$| ?x9)) ?x9) $x63))))
+(let ((@x94 (trans (monotonicity @x65 (= $x13 (not $x63))) (monotonicity @x89 $x91) (= $x13 $x90))))
+(let ((@x95 (mp (asserted $x13) @x94 $x90)))
+(let (($x198 (or (not $x169) $x190 $x87)))
+(let ((@x203 (mp ((_ |quant-inst| (ite $x69 |x$| ?x51)) (or (not $x169) (or $x190 $x87))) (rewrite (= (or (not $x169) (or $x190 $x87)) $x198)) $x198)))
+(let ((@x224 ((_ |th-lemma| arith farkas -1 1 1) (hypothesis $x69) (|unit-resolution| @x203 @x95 @x174 $x190) @x222 false)))
+(let ((@x225 (lemma @x224 $x70)))
+(let ((@x232 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x182) $x226)) (|unit-resolution| (|def-axiom| (or $x69 $x182)) @x225 $x182) $x226)))
+(let (($x205 (<= ?x76 0)))
+(let ((@x235 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x205 $x189)) (|unit-resolution| @x203 @x95 @x174 $x190) $x205)))
+((_ |th-lemma| arith farkas 1 1 1) @x235 @x225 @x232 false)))))))))))))))))))))))))))))))))))))))))))))))))))))))
 
-2f8af7e6fa968818bbe306cb947f5460272d1297 255 0
+777f9032b35b7e1c0dce62f13109424c73d5d094 312 0
 unsat
 ((set-logic AUFLIA)
 (declare-fun ?v1!0 (|Nat$|) |Nat$|)
 (proof
 (let ((?x23 (|of_nat$| |m$|)))
 (let ((?x24 (* 4 ?x23)))
-(let (($x601 (= (+ ?x24 (* (~ 1) (|of_nat$| (|nat$| (+ 1 ?x24))))) (~ 1))))
-(let (($x614 (>= ?x23 0)))
-(let (($x705 (forall ((?v1 |Nat$|) )(!(let ((?x12 (|nat$| 1)))
+(let ((?x110 (+ 1 ?x24)))
+(let ((?x113 (|nat$| ?x110)))
+(let ((?x344 (|of_nat$| ?x113)))
+(let ((?x491 (* (~ 1) ?x344)))
+(let ((?x492 (+ ?x24 ?x491)))
+(let (($x509 (>= ?x492 (~ 1))))
+(let (($x489 (= ?x492 (~ 1))))
+(let (($x481 (>= ?x23 0)))
+(let (($x345 (<= ?x344 1)))
+(let (($x373 (not $x345)))
+(let (($x351 (forall ((?v1 |Nat$|) )(!(let ((?x23 (|of_nat$| |m$|)))
+(let ((?x24 (* 4 ?x23)))
+(let ((?x110 (+ 1 ?x24)))
+(let ((?x113 (|nat$| ?x110)))
+(let (($x348 (= ?v1 ?x113)))
+(let ((?x12 (|nat$| 1)))
 (let (($x13 (= ?v1 ?x12)))
-(or (not (|dvd$| ?v1 (|nat$| (+ 1 (* 4 (|of_nat$| |m$|)))))) $x13 (= ?v1 (|nat$| (+ 1 (* 4 (|of_nat$| |m$|)))))))) :pattern ( (|dvd$| ?v1 (|nat$| (+ 1 (* 4 (|of_nat$| |m$|))))) )))
+(let (($x346 (|dvd$| ?v1 ?x113)))
+(let (($x347 (not $x346)))
+(or $x347 $x13 $x348)))))))))) :pattern ( (|dvd$| ?v1 (|nat$| (+ 1 (* 4 (|of_nat$| |m$|))))) )))
 ))
-(let ((?x72 (+ 1 ?x24)))
-(let ((?x75 (|nat$| ?x72)))
-(let ((?x299 (|of_nat$| ?x75)))
-(let (($x384 (<= ?x299 1)))
-(let (($x373 (not (or $x384 (not $x705)))))
-(let (($x78 (|prime_nat$| ?x75)))
-(let (($x86 (not $x78)))
-(let (($x374 (or $x86 $x373)))
-(let (($x703 (or (not (|dvd$| (?v1!0 ?x75) ?x75)) (= (?v1!0 ?x75) (|nat$| 1)) (= (?v1!0 ?x75) ?x75))))
-(let (($x707 (not $x374)))
-(let (($x742 (forall ((?v0 |Nat$|) )(!(let (($x223 (or (not (|dvd$| (?v1!0 ?v0) ?v0)) (= (?v1!0 ?v0) (|nat$| 1)) (= (?v1!0 ?v0) ?v0))))
-(let (($x224 (not $x223)))
+(let (($x352 (not $x351)))
+(let (($x353 (or $x345 $x352)))
+(let (($x354 (not $x353)))
+(let (($x116 (|prime_nat$| ?x113)))
+(let (($x122 (not $x116)))
+(let (($x355 (or $x122 $x354)))
+(let ((?x357 (?v1!0 ?x113)))
+(let (($x361 (= ?x357 ?x113)))
+(let ((?x12 (|nat$| 1)))
+(let (($x360 (= ?x357 ?x12)))
+(let (($x358 (|dvd$| ?x357 ?x113)))
+(let (($x359 (not $x358)))
+(let (($x362 (or $x359 $x360 $x361)))
+(let (($x363 (not $x362)))
+(let (($x364 (or $x116 $x345 $x363)))
+(let (($x365 (not $x364)))
+(let (($x356 (not $x355)))
+(let (($x366 (or $x356 $x365)))
+(let (($x367 (not $x366)))
+(let (($x321 (forall ((?v0 |Nat$|) )(!(let (($x217 (or (not (|dvd$| (?v1!0 ?v0) ?v0)) (= (?v1!0 ?v0) (|nat$| 1)) (= (?v1!0 ?v0) ?v0))))
+(let (($x218 (not $x217)))
 (let ((?x8 (|of_nat$| ?v0)))
-(let (($x51 (<= ?x8 1)))
+(let (($x87 (<= ?x8 1)))
 (let (($x6 (|prime_nat$| ?v0)))
-(let (($x251 (or $x6 $x51 $x224)))
-(let (($x714 (forall ((?v1 |Nat$|) )(!(let ((?x12 (|nat$| 1)))
+(let (($x245 (or $x6 $x87 $x218)))
+(let (($x293 (forall ((?v1 |Nat$|) )(!(let ((?x12 (|nat$| 1)))
 (let (($x13 (= ?v1 ?x12)))
 (or (not (|dvd$| ?v1 ?v0)) $x13 (= ?v1 ?v0)))) :pattern ( (|dvd$| ?v1 ?v0) )))
 ))
-(let (($x204 (not $x6)))
-(not (or (not (or $x204 (not (or $x51 (not $x714))))) (not $x251))))))))))) :pattern ( (|prime_nat$| ?v0) ) :pattern ( (|of_nat$| ?v0) )))
+(let (($x198 (not $x6)))
+(not (or (not (or $x198 (not (or $x87 (not $x293))))) (not $x245))))))))))) :pattern ( (|prime_nat$| ?v0) ) :pattern ( (|of_nat$| ?v0) )))
 ))
-(let (($x294 (forall ((?v0 |Nat$|) )(let (($x223 (or (not (|dvd$| (?v1!0 ?v0) ?v0)) (= (?v1!0 ?v0) (|nat$| 1)) (= (?v1!0 ?v0) ?v0))))
-(let (($x224 (not $x223)))
+(let (($x288 (forall ((?v0 |Nat$|) )(let (($x217 (or (not (|dvd$| (?v1!0 ?v0) ?v0)) (= (?v1!0 ?v0) (|nat$| 1)) (= (?v1!0 ?v0) ?v0))))
+(let (($x218 (not $x217)))
 (let ((?x8 (|of_nat$| ?v0)))
-(let (($x51 (<= ?x8 1)))
+(let (($x87 (<= ?x8 1)))
 (let (($x6 (|prime_nat$| ?v0)))
-(let (($x251 (or $x6 $x51 $x224)))
-(let (($x59 (forall ((?v1 |Nat$|) )(let ((?x12 (|nat$| 1)))
+(let (($x245 (or $x6 $x87 $x218)))
+(let (($x94 (forall ((?v1 |Nat$|) )(let ((?x12 (|nat$| 1)))
 (let (($x13 (= ?v1 ?x12)))
 (or (not (|dvd$| ?v1 ?v0)) $x13 (= ?v1 ?v0)))))
 ))
-(let (($x225 (not $x59)))
-(let (($x279 (not (or $x51 $x225))))
-(let (($x204 (not $x6)))
-(let (($x280 (or $x204 $x279)))
-(not (or (not $x280) (not $x251)))))))))))))))
+(let (($x219 (not $x94)))
+(let (($x271 (not (or $x87 $x219))))
+(let (($x198 (not $x6)))
+(let (($x274 (or $x198 $x271)))
+(not (or (not $x274) (not $x245)))))))))))))))
 ))
-(let (($x223 (or (not (|dvd$| (?v1!0 ?0) ?0)) (= (?v1!0 ?0) (|nat$| 1)) (= (?v1!0 ?0) ?0))))
-(let (($x224 (not $x223)))
+(let (($x217 (or (not (|dvd$| (?v1!0 ?0) ?0)) (= (?v1!0 ?0) ?x12) (= (?v1!0 ?0) ?0))))
+(let (($x218 (not $x217)))
 (let ((?x8 (|of_nat$| ?0)))
-(let (($x51 (<= ?x8 1)))
+(let (($x87 (<= ?x8 1)))
 (let (($x6 (|prime_nat$| ?0)))
-(let (($x251 (or $x6 $x51 $x224)))
-(let (($x714 (forall ((?v1 |Nat$|) )(!(let ((?x12 (|nat$| 1)))
+(let (($x245 (or $x6 $x87 $x218)))
+(let (($x293 (forall ((?v1 |Nat$|) )(!(let ((?x12 (|nat$| 1)))
 (let (($x13 (= ?v1 ?x12)))
 (or (not (|dvd$| ?v1 ?0)) $x13 (= ?v1 ?0)))) :pattern ( (|dvd$| ?v1 ?0) )))
 ))
-(let (($x204 (not $x6)))
-(let (($x59 (forall ((?v1 |Nat$|) )(let ((?x12 (|nat$| 1)))
+(let (($x198 (not $x6)))
+(let (($x94 (forall ((?v1 |Nat$|) )(let ((?x12 (|nat$| 1)))
 (let (($x13 (= ?v1 ?x12)))
 (or (not (|dvd$| ?v1 ?0)) $x13 (= ?v1 ?0)))))
 ))
-(let (($x225 (not $x59)))
-(let (($x279 (not (or $x51 $x225))))
-(let (($x280 (or $x204 $x279)))
-(let (($x289 (not (or (not $x280) (not $x251)))))
-(let (($x738 (= $x289 (not (or (not (or $x204 (not (or $x51 (not $x714))))) (not $x251))))))
-(let (($x735 (= (or (not $x280) (not $x251)) (or (not (or $x204 (not (or $x51 (not $x714))))) (not $x251)))))
-(let ((?x12 (|nat$| 1)))
+(let (($x219 (not $x94)))
+(let (($x271 (not (or $x87 $x219))))
+(let (($x274 (or $x198 $x271)))
+(let (($x283 (not (or (not $x274) (not $x245)))))
+(let (($x317 (= $x283 (not (or (not (or $x198 (not (or $x87 (not $x293))))) (not $x245))))))
+(let (($x314 (= (or (not $x274) (not $x245)) (or (not (or $x198 (not (or $x87 (not $x293))))) (not $x245)))))
 (let (($x13 (= ?0 ?x12)))
-(let (($x56 (or (not (|dvd$| ?0 ?1)) $x13 (= ?0 ?1))))
-(let ((@x721 (monotonicity (|quant-intro| (refl (= $x56 $x56)) (= $x59 $x714)) (= $x225 (not $x714)))))
-(let ((@x727 (monotonicity (monotonicity @x721 (= (or $x51 $x225) (or $x51 (not $x714)))) (= $x279 (not (or $x51 (not $x714)))))))
-(let ((@x733 (monotonicity (monotonicity @x727 (= $x280 (or $x204 (not (or $x51 (not $x714)))))) (= (not $x280) (not (or $x204 (not (or $x51 (not $x714)))))))))
-(let ((@x744 (|quant-intro| (monotonicity (monotonicity @x733 $x735) $x738) (= $x294 $x742))))
-(let (($x259 (forall ((?v0 |Nat$|) )(let (($x223 (or (not (|dvd$| (?v1!0 ?v0) ?v0)) (= (?v1!0 ?v0) (|nat$| 1)) (= (?v1!0 ?v0) ?v0))))
-(let (($x224 (not $x223)))
+(let (($x91 (or (not (|dvd$| ?0 ?1)) $x13 (= ?0 ?1))))
+(let ((@x300 (monotonicity (|quant-intro| (refl (= $x91 $x91)) (= $x94 $x293)) (= $x219 (not $x293)))))
+(let ((@x306 (monotonicity (monotonicity @x300 (= (or $x87 $x219) (or $x87 (not $x293)))) (= $x271 (not (or $x87 (not $x293)))))))
+(let ((@x312 (monotonicity (monotonicity @x306 (= $x274 (or $x198 (not (or $x87 (not $x293)))))) (= (not $x274) (not (or $x198 (not (or $x87 (not $x293)))))))))
+(let ((@x323 (|quant-intro| (monotonicity (monotonicity @x312 $x314) $x317) (= $x288 $x321))))
+(let (($x253 (forall ((?v0 |Nat$|) )(let (($x217 (or (not (|dvd$| (?v1!0 ?v0) ?v0)) (= (?v1!0 ?v0) (|nat$| 1)) (= (?v1!0 ?v0) ?v0))))
+(let (($x218 (not $x217)))
 (let ((?x8 (|of_nat$| ?v0)))
-(let (($x51 (<= ?x8 1)))
+(let (($x87 (<= ?x8 1)))
 (let (($x6 (|prime_nat$| ?v0)))
-(let (($x251 (or $x6 $x51 $x224)))
-(let (($x59 (forall ((?v1 |Nat$|) )(let ((?x12 (|nat$| 1)))
+(let (($x245 (or $x6 $x87 $x218)))
+(let (($x94 (forall ((?v1 |Nat$|) )(let ((?x12 (|nat$| 1)))
 (let (($x13 (= ?v1 ?x12)))
 (or (not (|dvd$| ?v1 ?v0)) $x13 (= ?v1 ?v0)))))
 ))
-(let (($x52 (not $x51)))
-(let (($x62 (and $x52 $x59)))
-(let (($x204 (not $x6)))
-(let (($x233 (or $x204 $x62)))
-(and $x233 $x251)))))))))))))
+(let (($x88 (not $x87)))
+(let (($x97 (and $x88 $x94)))
+(let (($x198 (not $x6)))
+(let (($x227 (or $x198 $x97)))
+(and $x227 $x245)))))))))))))
 ))
-(let ((@x282 (monotonicity (rewrite (= (and (not $x51) $x59) $x279)) (= (or $x204 (and (not $x51) $x59)) $x280))))
-(let ((@x285 (monotonicity @x282 (= (and (or $x204 (and (not $x51) $x59)) $x251) (and $x280 $x251)))))
-(let ((@x293 (trans @x285 (rewrite (= (and $x280 $x251) $x289)) (= (and (or $x204 (and (not $x51) $x59)) $x251) $x289))))
-(let (($x237 (forall ((?v0 |Nat$|) )(let (($x223 (or (not (|dvd$| (?v1!0 ?v0) ?v0)) (= (?v1!0 ?v0) (|nat$| 1)) (= (?v1!0 ?v0) ?v0))))
-(let (($x224 (not $x223)))
+(let ((@x276 (monotonicity (rewrite (= (and (not $x87) $x94) $x271)) (= (or $x198 (and (not $x87) $x94)) $x274))))
+(let ((@x279 (monotonicity @x276 (= (and (or $x198 (and (not $x87) $x94)) $x245) (and $x274 $x245)))))
+(let ((@x287 (trans @x279 (rewrite (= (and $x274 $x245) $x283)) (= (and (or $x198 (and (not $x87) $x94)) $x245) $x283))))
+(let (($x231 (forall ((?v0 |Nat$|) )(let (($x217 (or (not (|dvd$| (?v1!0 ?v0) ?v0)) (= (?v1!0 ?v0) (|nat$| 1)) (= (?v1!0 ?v0) ?v0))))
+(let (($x218 (not $x217)))
 (let ((?x8 (|of_nat$| ?v0)))
-(let (($x51 (<= ?x8 1)))
-(let (($x52 (not $x51)))
-(let (($x215 (not $x52)))
-(let (($x228 (or $x215 $x224)))
+(let (($x87 (<= ?x8 1)))
+(let (($x88 (not $x87)))
+(let (($x209 (not $x88)))
+(let (($x222 (or $x209 $x218)))
 (let (($x6 (|prime_nat$| ?v0)))
-(let (($x232 (or $x6 $x228)))
-(let (($x59 (forall ((?v1 |Nat$|) )(let ((?x12 (|nat$| 1)))
+(let (($x226 (or $x6 $x222)))
+(let (($x94 (forall ((?v1 |Nat$|) )(let ((?x12 (|nat$| 1)))
 (let (($x13 (= ?v1 ?x12)))
 (or (not (|dvd$| ?v1 ?v0)) $x13 (= ?v1 ?v0)))))
 ))
-(let (($x62 (and $x52 $x59)))
-(let (($x204 (not $x6)))
-(let (($x233 (or $x204 $x62)))
-(and $x233 $x232)))))))))))))))
+(let (($x97 (and $x88 $x94)))
+(let (($x198 (not $x6)))
+(let (($x227 (or $x198 $x97)))
+(and $x227 $x226)))))))))))))))
 ))
-(let (($x52 (not $x51)))
-(let (($x62 (and $x52 $x59)))
-(let (($x233 (or $x204 $x62)))
-(let (($x256 (and $x233 $x251)))
-(let (($x215 (not $x52)))
-(let (($x228 (or $x215 $x224)))
-(let (($x232 (or $x6 $x228)))
-(let (($x234 (and $x233 $x232)))
-(let ((@x250 (monotonicity (monotonicity (rewrite (= $x215 $x51)) (= $x228 (or $x51 $x224))) (= $x232 (or $x6 (or $x51 $x224))))))
-(let ((@x255 (trans @x250 (rewrite (= (or $x6 (or $x51 $x224)) $x251)) (= $x232 $x251))))
-(let (($x171 (forall ((?v0 |Nat$|) )(let (($x59 (forall ((?v1 |Nat$|) )(let ((?x12 (|nat$| 1)))
+(let (($x88 (not $x87)))
+(let (($x97 (and $x88 $x94)))
+(let (($x227 (or $x198 $x97)))
+(let (($x250 (and $x227 $x245)))
+(let (($x209 (not $x88)))
+(let (($x222 (or $x209 $x218)))
+(let (($x226 (or $x6 $x222)))
+(let (($x228 (and $x227 $x226)))
+(let ((@x244 (monotonicity (monotonicity (rewrite (= $x209 $x87)) (= $x222 (or $x87 $x218))) (= $x226 (or $x6 (or $x87 $x218))))))
+(let ((@x249 (trans @x244 (rewrite (= (or $x6 (or $x87 $x218)) $x245)) (= $x226 $x245))))
+(let (($x103 (forall ((?v0 |Nat$|) )(let (($x94 (forall ((?v1 |Nat$|) )(let ((?x12 (|nat$| 1)))
 (let (($x13 (= ?v1 ?x12)))
 (or (not (|dvd$| ?v1 ?v0)) $x13 (= ?v1 ?v0)))))
 ))
 (let ((?x8 (|of_nat$| ?v0)))
-(let (($x51 (<= ?x8 1)))
-(let (($x52 (not $x51)))
-(let (($x62 (and $x52 $x59)))
+(let (($x87 (<= ?x8 1)))
+(let (($x88 (not $x87)))
+(let (($x97 (and $x88 $x94)))
 (let (($x6 (|prime_nat$| ?v0)))
-(= $x6 $x62))))))))
+(= $x6 $x97))))))))
 ))
-(let ((@x231 (|nnf-neg| (refl (|~| $x215 $x215)) (sk (|~| $x225 $x224)) (|~| (not $x62) $x228))))
-(let ((@x214 (monotonicity (refl (|~| $x52 $x52)) (|nnf-pos| (refl (|~| $x56 $x56)) (|~| $x59 $x59)) (|~| $x62 $x62))))
-(let ((@x236 (|nnf-pos| (refl (|~| $x6 $x6)) (refl (|~| $x204 $x204)) @x214 @x231 (|~| (= $x6 $x62) $x234))))
-(let (($x68 (forall ((?v0 |Nat$|) )(let (($x59 (forall ((?v1 |Nat$|) )(let ((?x12 (|nat$| 1)))
-(let (($x13 (= ?v1 ?x12)))
-(or (not (|dvd$| ?v1 ?v0)) $x13 (= ?v1 ?v0)))))
-))
-(let ((?x8 (|of_nat$| ?v0)))
-(let (($x51 (<= ?x8 1)))
-(let (($x52 (not $x51)))
-(let (($x62 (and $x52 $x59)))
-(let (($x6 (|prime_nat$| ?v0)))
-(= $x6 $x62))))))))
-))
-(let ((@x173 (|quant-intro| (rewrite (= (= $x6 $x62) (= $x6 $x62))) (= $x68 $x171))))
+(let ((@x225 (|nnf-neg| (refl (|~| $x209 $x209)) (sk (|~| $x219 $x218)) (|~| (not $x97) $x222))))
+(let ((@x208 (monotonicity (refl (|~| $x88 $x88)) (|nnf-pos| (refl (|~| $x91 $x91)) (|~| $x94 $x94)) (|~| $x97 $x97))))
+(let ((@x230 (|nnf-pos| (refl (|~| $x6 $x6)) (refl (|~| $x198 $x198)) @x208 @x225 (|~| (= $x6 $x97) $x228))))
 (let (($x20 (forall ((?v0 |Nat$|) )(let (($x17 (forall ((?v1 |Nat$|) )(let (($x11 (|dvd$| ?v1 ?v0)))
 (=> $x11 (or (= ?v1 (|nat$| 1)) (= ?v1 ?v0)))))
 ))
+(let ((?x8 (|of_nat$| ?v0)))
+(let (($x9 (< 1 ?x8)))
 (let (($x6 (|prime_nat$| ?v0)))
-(= $x6 (and (< 1 (|of_nat$| ?v0)) $x17)))))
+(= $x6 (and $x9 $x17)))))))
+))
+(let (($x84 (forall ((?v0 |Nat$|) )(let (($x70 (forall ((?v1 |Nat$|) )(or (not (|dvd$| ?v1 ?v0)) (or (= ?v1 (|nat$| 1)) (= ?v1 ?v0))))
 ))
-(let (($x65 (= $x6 $x62)))
+(let ((?x8 (|of_nat$| ?v0)))
+(let (($x9 (< 1 ?x8)))
+(let (($x73 (and $x9 $x70)))
+(let (($x6 (|prime_nat$| ?v0)))
+(= $x6 $x73)))))))
+))
+(let (($x100 (= $x6 $x97)))
+(let (($x70 (forall ((?v1 |Nat$|) )(or (not (|dvd$| ?v1 ?0)) (or (= ?v1 (|nat$| 1)) (= ?v1 ?0))))
+))
+(let (($x9 (< 1 ?x8)))
+(let (($x73 (and $x9 $x70)))
+(let (($x79 (= $x6 $x73)))
+(let ((@x93 (rewrite (= (or (not (|dvd$| ?0 ?1)) (or $x13 (= ?0 ?1))) $x91))))
+(let ((@x99 (monotonicity (rewrite (= $x9 $x88)) (|quant-intro| @x93 (= $x70 $x94)) (= $x73 $x97))))
 (let (($x17 (forall ((?v1 |Nat$|) )(let (($x11 (|dvd$| ?v1 ?0)))
 (=> $x11 (or (= ?v1 (|nat$| 1)) (= ?v1 ?0)))))
 ))
-(let ((@x61 (|quant-intro| (rewrite (= (=> (|dvd$| ?0 ?1) (or $x13 (= ?0 ?1))) $x56)) (= $x17 $x59))))
-(let ((@x64 (monotonicity (rewrite (= (< 1 ?x8) $x52)) @x61 (= (and (< 1 ?x8) $x17) $x62))))
-(let ((@x70 (|quant-intro| (monotonicity @x64 (= (= $x6 (and (< 1 ?x8) $x17)) $x65)) (= $x20 $x68))))
-(let ((@x176 (mp (mp (mp (asserted $x20) @x70 $x68) (|rewrite*| (= $x68 $x68)) $x68) @x173 $x171)))
-(let ((@x241 (mp (|mp~| @x176 (|nnf-pos| @x236 (|~| $x171 $x237)) $x237) (|quant-intro| (monotonicity @x255 (= $x234 $x256)) (= $x237 $x259)) $x259)))
-(let ((@x691 ((_ |quant-inst| (|nat$| ?x72)) (or (not $x742) (not (or $x707 (not (or $x78 $x384 (not $x703)))))))))
-(let ((@x572 (|unit-resolution| @x691 (mp (mp @x241 (|quant-intro| @x293 (= $x259 $x294)) $x294) @x744 $x742) (not (or $x707 (not (or $x78 $x384 (not $x703))))))))
-(let ((@x573 (|unit-resolution| (|def-axiom| (or (or $x707 (not (or $x78 $x384 (not $x703)))) $x374)) @x572 $x374)))
+(let (($x19 (= $x6 (and $x9 $x17))))
+(let (($x67 (or (not (|dvd$| ?0 ?1)) (or $x13 (= ?0 ?1)))))
+(let ((@x72 (|quant-intro| (rewrite (= (=> (|dvd$| ?0 ?1) (or $x13 (= ?0 ?1))) $x67)) (= $x17 $x70))))
+(let ((@x78 (monotonicity (monotonicity @x72 (= (and $x9 $x17) $x73)) (= $x19 (= $x6 $x73)))))
+(let ((@x86 (|quant-intro| (trans @x78 (rewrite (= (= $x6 $x73) $x79)) (= $x19 $x79)) (= $x20 $x84))))
+(let ((@x107 (trans @x86 (|quant-intro| (monotonicity @x99 (= $x79 $x100)) (= $x84 $x103)) (= $x20 $x103))))
+(let ((@x234 (|mp~| (mp (asserted $x20) @x107 $x103) (|nnf-pos| @x230 (|~| $x103 $x231)) $x231)))
+(let ((@x235 (mp @x234 (|quant-intro| (monotonicity @x249 (= $x228 $x250)) (= $x231 $x253)) $x253)))
+(let ((@x324 (mp (mp @x235 (|quant-intro| @x287 (= $x253 $x288)) $x288) @x323 $x321)))
+(let (($x371 (or (not $x321) $x367)))
+(let ((@x372 ((_ |quant-inst| (|nat$| ?x110)) $x371)))
+(let ((@x530 (|unit-resolution| (|def-axiom| (or $x366 $x355)) (|unit-resolution| @x372 @x324 $x367) $x355)))
+(let (($x137 (not (or $x122 (>= ?x23 1)))))
 (let (($x28 (<= 1 ?x23)))
 (let (($x29 (=> (|prime_nat$| (|nat$| (+ ?x24 1))) $x28)))
 (let (($x30 (not $x29)))
-(let ((@x77 (monotonicity (rewrite (= (+ ?x24 1) ?x72)) (= (|nat$| (+ ?x24 1)) ?x75))))
-(let ((@x85 (monotonicity (monotonicity @x77 (= (|prime_nat$| (|nat$| (+ ?x24 1))) $x78)) (rewrite (= $x28 $x28)) (= $x29 (=> $x78 $x28)))))
-(let ((@x91 (trans @x85 (rewrite (= (=> $x78 $x28) (or $x86 $x28))) (= $x29 (or $x86 $x28)))))
-(let ((@x95 (mp (asserted $x30) (monotonicity @x91 (= $x30 (not (or $x86 $x28)))) (not (or $x86 $x28)))))
-(let ((@x575 (|unit-resolution| (|def-axiom| (or $x707 $x86 $x373)) (mp (|not-or-elim| @x95 $x78) (|rewrite*| (= $x78 $x78)) $x78) (or $x707 $x373))))
-(let ((@x577 (|unit-resolution| (|def-axiom| (or (or $x384 (not $x705)) (not $x384))) (|unit-resolution| @x575 @x573 $x373) (not $x384))))
-(let ((@x534 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not (<= ?x299 0)) $x384)) @x577 (not (<= ?x299 0)))))
-(let ((@x565 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x299 0)) (<= ?x299 0))) @x534 (not (= ?x299 0)))))
-(let (($x579 (= ?x299 0)))
-(let (($x581 (or $x614 $x579)))
-(let (($x760 (forall ((?v0 Int) )(!(let (($x43 (= (|of_nat$| (|nat$| ?v0)) 0)))
-(let (($x178 (>= ?v0 0)))
-(or $x178 $x43))) :pattern ( (|nat$| ?v0) )))
+(let ((@x136 (monotonicity (rewrite (= $x28 (>= ?x23 1))) (= (or $x122 $x28) (or $x122 (>= ?x23 1))))))
+(let ((@x115 (monotonicity (rewrite (= (+ ?x24 1) ?x110)) (= (|nat$| (+ ?x24 1)) ?x113))))
+(let ((@x121 (monotonicity (monotonicity @x115 (= (|prime_nat$| (|nat$| (+ ?x24 1))) $x116)) (= $x29 (=> $x116 $x28)))))
+(let ((@x127 (trans @x121 (rewrite (= (=> $x116 $x28) (or $x122 $x28))) (= $x29 (or $x122 $x28)))))
+(let ((@x141 (trans (monotonicity @x127 (= $x30 (not (or $x122 $x28)))) (monotonicity @x136 (= (not (or $x122 $x28)) $x137)) (= $x30 $x137))))
+(let ((@x143 (|not-or-elim| (mp (asserted $x30) @x141 $x137) $x116)))
+(let ((@x533 (|unit-resolution| (|unit-resolution| (|def-axiom| (or $x356 $x122 $x354)) @x143 (or $x356 $x354)) @x530 $x354)))
+(let ((@x538 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not (<= ?x344 0)) $x345)) (|unit-resolution| (|def-axiom| (or $x353 $x373)) @x533 $x373) (not (<= ?x344 0)))))
+(let ((@x542 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x344 0)) (<= ?x344 0))) @x538 (not (= ?x344 0)))))
+(let (($x510 (= ?x344 0)))
+(let (($x512 (or $x481 $x510)))
+(let (($x338 (forall ((?v0 Int) )(!(let ((?x37 (|nat$| ?v0)))
+(let ((?x38 (|of_nat$| ?x37)))
+(let (($x43 (= ?x38 0)))
+(let (($x157 (>= ?v0 0)))
+(or $x157 $x43))))) :pattern ( (|nat$| ?v0) )))
 ))
-(let (($x192 (forall ((?v0 Int) )(let (($x43 (= (|of_nat$| (|nat$| ?v0)) 0)))
-(let (($x178 (>= ?v0 0)))
-(or $x178 $x43))))
+(let (($x190 (forall ((?v0 Int) )(let ((?x37 (|nat$| ?v0)))
+(let ((?x38 (|of_nat$| ?x37)))
+(let (($x43 (= ?x38 0)))
+(let (($x157 (>= ?v0 0)))
+(or $x157 $x43))))))
 ))
-(let (($x43 (= (|of_nat$| (|nat$| ?0)) 0)))
-(let (($x178 (>= ?0 0)))
-(let (($x189 (or $x178 $x43)))
-(let (($x125 (forall ((?v0 Int) )(let (($x43 (= (|of_nat$| (|nat$| ?v0)) 0)))
-(let (($x36 (<= 0 ?v0)))
-(or $x36 $x43))))
+(let ((?x37 (|nat$| ?0)))
+(let ((?x38 (|of_nat$| ?x37)))
+(let (($x43 (= ?x38 0)))
+(let (($x157 (>= ?0 0)))
+(let (($x187 (or $x157 $x43)))
+(let (($x45 (forall ((?v0 Int) )(let ((?x37 (|nat$| ?v0)))
+(let ((?x38 (|of_nat$| ?x37)))
+(let (($x43 (= ?x38 0)))
+(let (($x42 (< ?v0 0)))
+(=> $x42 $x43))))))
 ))
-(let ((@x191 (monotonicity (rewrite (= (<= 0 ?0) $x178)) (= (or (<= 0 ?0) $x43) $x189))))
-(let (($x45 (forall ((?v0 Int) )(let (($x43 (= (|of_nat$| (|nat$| ?v0)) 0)))
-(=> (< ?v0 0) $x43)))
+(let (($x175 (forall ((?v0 Int) )(let ((?x37 (|nat$| ?v0)))
+(let ((?x38 (|of_nat$| ?x37)))
+(let (($x43 (= ?x38 0)))
+(let (($x42 (< ?v0 0)))
+(let (($x171 (not $x42)))
+(or $x171 $x43)))))))
 ))
-(let ((@x122 (rewrite (= (=> (not (<= 0 ?0)) $x43) (or (<= 0 ?0) $x43)))))
-(let ((@x115 (monotonicity (rewrite (= (<= 0 ?0) (<= 0 ?0))) (= (not (<= 0 ?0)) (not (<= 0 ?0))))))
-(let ((@x116 (trans (rewrite (= (< ?0 0) (not (<= 0 ?0)))) @x115 (= (< ?0 0) (not (<= 0 ?0))))))
-(let ((@x119 (monotonicity @x116 (= (=> (< ?0 0) $x43) (=> (not (<= 0 ?0)) $x43)))))
-(let ((@x124 (trans @x119 @x122 (= (=> (< ?0 0) $x43) (or (<= 0 ?0) $x43)))))
-(let ((@x143 (mp (mp (asserted $x45) (|quant-intro| @x124 (= $x45 $x125)) $x125) (|rewrite*| (= $x125 $x125)) $x125)))
-(let ((@x275 (|mp~| (mp @x143 (|quant-intro| @x191 (= $x125 $x192)) $x192) (|nnf-pos| (refl (|~| $x189 $x189)) (|~| $x192 $x192)) $x192)))
-(let (($x584 (not $x760)))
-(let (($x585 (or $x584 $x614 $x579)))
-(let ((@x583 (monotonicity (rewrite (= (>= ?x72 0) $x614)) (= (or (>= ?x72 0) $x579) $x581))))
-(let ((@x559 (monotonicity @x583 (= (or $x584 (or (>= ?x72 0) $x579)) (or $x584 $x581)))))
-(let ((@x568 (trans @x559 (rewrite (= (or $x584 $x581) $x585)) (= (or $x584 (or (>= ?x72 0) $x579)) $x585))))
-(let ((@x533 (|unit-resolution| (mp ((_ |quant-inst| (+ 1 ?x24)) (or $x584 (or (>= ?x72 0) $x579))) @x568 $x585) (mp @x275 (|quant-intro| (refl (= $x189 $x189)) (= $x192 $x760)) $x760) $x581)))
-(let (($x617 (not $x614)))
-(let (($x604 (or $x617 $x601)))
-(let (($x754 (forall ((?v0 Int) )(!(let (($x39 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(or (not (>= ?v0 0)) $x39)) :pattern ( (|nat$| ?v0) )))
+(let ((@x182 (monotonicity (rewrite (= (< ?0 0) (not $x157))) (= (not (< ?0 0)) (not (not $x157))))))
+(let ((@x186 (trans @x182 (rewrite (= (not (not $x157)) $x157)) (= (not (< ?0 0)) $x157))))
+(let ((@x192 (|quant-intro| (monotonicity @x186 (= (or (not (< ?0 0)) $x43) $x187)) (= $x175 $x190))))
+(let ((@x174 (rewrite (= (=> (< ?0 0) $x43) (or (not (< ?0 0)) $x43)))))
+(let ((@x195 (mp (asserted $x45) (trans (|quant-intro| @x174 (= $x45 $x175)) @x192 (= $x45 $x190)) $x190)))
+(let ((@x343 (mp (|mp~| @x195 (|nnf-pos| (refl (|~| $x187 $x187)) (|~| $x190 $x190)) $x190) (|quant-intro| (refl (= $x187 $x187)) (= $x190 $x338)) $x338)))
+(let (($x515 (not $x338)))
+(let (($x516 (or $x515 $x481 $x510)))
+(let ((@x483 (rewrite (= (>= ?x110 0) $x481))))
+(let ((@x514 (monotonicity @x483 (= (or (>= ?x110 0) $x510) $x512))))
+(let ((@x521 (monotonicity @x514 (= (or $x515 (or (>= ?x110 0) $x510)) (or $x515 $x512)))))
+(let ((@x525 (trans @x521 (rewrite (= (or $x515 $x512) $x516)) (= (or $x515 (or (>= ?x110 0) $x510)) $x516))))
+(let ((@x526 (mp ((_ |quant-inst| (+ 1 ?x24)) (or $x515 (or (>= ?x110 0) $x510))) @x525 $x516)))
+(let (($x484 (not $x481)))
+(let (($x493 (or $x484 $x489)))
+(let (($x332 (forall ((?v0 Int) )(!(let ((?x37 (|nat$| ?v0)))
+(let ((?x38 (|of_nat$| ?x37)))
+(let (($x39 (= ?x38 ?v0)))
+(let (($x157 (>= ?v0 0)))
+(let (($x158 (not $x157)))
+(or $x158 $x39)))))) :pattern ( (|nat$| ?v0) )))
 ))
-(let (($x185 (forall ((?v0 Int) )(let (($x39 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(or (not (>= ?v0 0)) $x39)))
+(let (($x164 (forall ((?v0 Int) )(let ((?x37 (|nat$| ?v0)))
+(let ((?x38 (|of_nat$| ?x37)))
+(let (($x39 (= ?x38 ?v0)))
+(let (($x157 (>= ?v0 0)))
+(let (($x158 (not $x157)))
+(or $x158 $x39)))))))
 ))
-(let (($x39 (= (|of_nat$| (|nat$| ?0)) ?0)))
-(let (($x182 (or (not $x178) $x39)))
-(let (($x108 (forall ((?v0 Int) )(let (($x39 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
+(let ((@x334 (refl (= (or (not $x157) (= ?x38 ?0)) (or (not $x157) (= ?x38 ?0))))))
+(let ((@x261 (refl (|~| (or (not $x157) (= ?x38 ?0)) (or (not $x157) (= ?x38 ?0))))))
+(let (($x41 (forall ((?v0 Int) )(let ((?x37 (|nat$| ?v0)))
+(let ((?x38 (|of_nat$| ?x37)))
+(let (($x39 (= ?x38 ?v0)))
 (let (($x36 (<= 0 ?v0)))
-(let (($x103 (not $x36)))
-(or $x103 $x39)))))
+(=> $x36 $x39))))))
 ))
-(let ((@x181 (monotonicity (rewrite (= (<= 0 ?0) $x178)) (= (not (<= 0 ?0)) (not $x178)))))
-(let ((@x187 (|quant-intro| (monotonicity @x181 (= (or (not (<= 0 ?0)) $x39) $x182)) (= $x108 $x185))))
-(let (($x41 (forall ((?v0 Int) )(let (($x39 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(let (($x36 (<= 0 ?v0)))
-(=> $x36 $x39))))
+(let (($x152 (forall ((?v0 Int) )(let ((?x37 (|nat$| ?v0)))
+(let ((?x38 (|of_nat$| ?x37)))
+(let (($x39 (= ?x38 ?v0)))
+(or (not (<= 0 ?v0)) $x39)))))
 ))
-(let ((@x106 (rewrite (= (=> (<= 0 ?0) $x39) (or (not (<= 0 ?0)) $x39)))))
-(let ((@x102 (monotonicity (rewrite (= (<= 0 ?0) (<= 0 ?0))) (= (=> (<= 0 ?0) $x39) (=> (<= 0 ?0) $x39)))))
-(let ((@x107 (trans @x102 @x106 (= (=> (<= 0 ?0) $x39) (or (not (<= 0 ?0)) $x39)))))
-(let ((@x140 (mp (mp (asserted $x41) (|quant-intro| @x107 (= $x41 $x108)) $x108) (|rewrite*| (= $x108 $x108)) $x108)))
-(let ((@x270 (|mp~| (mp @x140 @x187 $x185) (|nnf-pos| (refl (|~| $x182 $x182)) (|~| $x185 $x185)) $x185)))
-(let (($x607 (not $x754)))
-(let (($x608 (or $x607 $x617 $x601)))
-(let (($x609 (or $x607 (or (not (>= ?x72 0)) (= ?x299 ?x72)))))
-(let ((@x598 (monotonicity (rewrite (= (>= ?x72 0) $x614)) (= (not (>= ?x72 0)) $x617))))
-(let ((@x606 (monotonicity @x598 (rewrite (= (= ?x299 ?x72) $x601)) (= (or (not (>= ?x72 0)) (= ?x299 ?x72)) $x604))))
-(let ((@x594 (trans (monotonicity @x606 (= $x609 (or $x607 $x604))) (rewrite (= (or $x607 $x604) $x608)) (= $x609 $x608))))
-(let ((@x498 (|unit-resolution| (mp ((_ |quant-inst| (+ 1 ?x24)) $x609) @x594 $x608) (mp @x270 (|quant-intro| (refl (= $x182 $x182)) (= $x185 $x754)) $x754) $x604)))
-(let ((@x542 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x601) (>= (+ ?x24 (* (~ 1) ?x299)) (~ 1)))) (|unit-resolution| @x498 (|unit-resolution| @x533 @x565 $x614) $x601) (>= (+ ?x24 (* (~ 1) ?x299)) (~ 1)))))
-(let ((@x201 (monotonicity (rewrite (= $x28 (>= ?x23 1))) (= (not $x28) (not (>= ?x23 1))))))
-(let (($x97 (not $x28)))
-(let ((@x152 (mp (mp (|not-or-elim| @x95 $x97) (|rewrite*| (= $x97 $x97)) $x97) (monotonicity (rewrite (= $x28 $x28)) (= $x97 $x97)) $x97)))
-(let ((@x153 (mp @x152 (monotonicity (rewrite (= $x28 $x28)) (= $x97 $x97)) $x97)))
-((_ |th-lemma| arith farkas -4 1 1) (mp @x153 @x201 (not (>= ?x23 1))) @x577 @x542 false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
+(let (($x39 (= ?x38 ?0)))
+(let (($x158 (not $x157)))
+(let (($x161 (or $x158 $x39)))
+(let (($x149 (or (not (<= 0 ?0)) $x39)))
+(let ((@x160 (monotonicity (rewrite (= (<= 0 ?0) $x157)) (= (not (<= 0 ?0)) $x158))))
+(let ((@x154 (|quant-intro| (rewrite (= (=> (<= 0 ?0) $x39) $x149)) (= $x41 $x152))))
+(let ((@x168 (trans @x154 (|quant-intro| (monotonicity @x160 (= $x149 $x161)) (= $x152 $x164)) (= $x41 $x164))))
+(let ((@x264 (|mp~| (mp (asserted $x41) @x168 $x164) (|nnf-pos| @x261 (|~| $x164 $x164)) $x164)))
+(let ((@x337 (mp @x264 (|quant-intro| @x334 (= $x164 $x332)) $x332)))
+(let (($x496 (not $x332)))
+(let (($x497 (or $x496 $x484 $x489)))
+(let (($x479 (= ?x344 ?x110)))
+(let (($x474 (>= ?x110 0)))
+(let (($x475 (not $x474)))
+(let (($x480 (or $x475 $x479)))
+(let (($x498 (or $x496 $x480)))
+(let ((@x495 (monotonicity (monotonicity @x483 (= $x475 $x484)) (rewrite (= $x479 $x489)) (= $x480 $x493))))
+(let ((@x506 (trans (monotonicity @x495 (= $x498 (or $x496 $x493))) (rewrite (= (or $x496 $x493) $x497)) (= $x498 $x497))))
+(let ((@x507 (mp ((_ |quant-inst| (+ 1 ?x24)) $x498) @x506 $x497)))
+(let ((@x546 (|unit-resolution| (|unit-resolution| @x507 @x337 $x493) (|unit-resolution| (|unit-resolution| @x526 @x343 $x512) @x542 $x481) $x489)))
+(let ((@x145 (|not-or-elim| (mp (asserted $x30) @x141 $x137) (not (>= ?x23 1)))))
+((_ |th-lemma| arith farkas -4 1 1) @x145 (|unit-resolution| (|def-axiom| (or $x353 $x373)) @x533 $x373) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x489) $x509)) @x546 $x509) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
 
-382f4199d494d0df860c17de3f08dc5bef5af830 20 0
+c7efedca31e5e8360d3c81014f43c447bc784df3 23 0
 unsat
 ((set-logic AUFLIA)
 (proof
 (let (($x17 (= |x$| |a$|)))
-(let ((?x14 (|fst$| (|pair$| |x$| |y$|))))
+(let ((?x13 (|pair$| |x$| |y$|)))
+(let ((?x14 (|fst$| ?x13)))
 (let (($x16 (= ?x14 |a$|)))
-(let ((@x28 (monotonicity (rewrite (= (=> $x16 $x17) (or (not $x16) $x17))) (= (not (=> $x16 $x17)) (not (or (not $x16) $x17))))))
-(let ((@x30 (|not-or-elim| (mp (asserted (not (=> $x16 $x17))) @x28 (not (or (not $x16) $x17))) $x16)))
-(let (($x484 (forall ((?v0 |A$|) (?v1 |B$|) )(!(= (|fst$| (|pair$| ?v0 ?v1)) ?v0) :pattern ( (|pair$| ?v0 ?v1) )))
+(let ((@x48 (monotonicity (rewrite (= (=> $x16 $x17) (or (not $x16) $x17))) (= (not (=> $x16 $x17)) (not (or (not $x16) $x17))))))
+(let ((@x49 (|not-or-elim| (mp (asserted (not (=> $x16 $x17))) @x48 (not (or (not $x16) $x17))) $x16)))
+(let (($x65 (= ?x14 |x$|)))
+(let (($x59 (forall ((?v0 |A$|) (?v1 |B$|) )(!(= (|fst$| (|pair$| ?v0 ?v1)) ?v0) :pattern ( (|pair$| ?v0 ?v1) )))
 ))
 (let (($x10 (forall ((?v0 |A$|) (?v1 |B$|) )(= (|fst$| (|pair$| ?v0 ?v1)) ?v0))
 ))
 (let (($x9 (= (|fst$| (|pair$| ?1 ?0)) ?1)))
-(let ((@x61 (|mp~| (mp (asserted $x10) (|rewrite*| (= $x10 $x10)) $x10) (|nnf-pos| (refl (|~| $x9 $x9)) (|~| $x10 $x10)) $x10)))
-(let ((@x153 (|unit-resolution| ((_ |quant-inst| |x$| |y$|) (or (not $x484) (= ?x14 |x$|))) (mp @x61 (|quant-intro| (refl (= $x9 $x9)) (= $x10 $x484)) $x484) (= ?x14 |x$|))))
-(let ((@x156 (trans (symm @x153 (= |x$| ?x14)) (mp @x30 (|rewrite*| (= $x16 $x16)) $x16) $x17)))
-(let (($x31 (not $x17)))
-(let ((@x32 (|not-or-elim| (mp (asserted (not (=> $x16 $x17))) @x28 (not (or (not $x16) $x17))) $x31)))
-(|unit-resolution| (mp @x32 (|rewrite*| (= $x31 $x31)) $x31) @x156 false))))))))))))))))
+(let ((@x57 (|mp~| (asserted $x10) (|nnf-pos| (refl (|~| $x9 $x9)) (|~| $x10 $x10)) $x10)))
+(let ((@x64 (mp @x57 (|quant-intro| (refl (= $x9 $x9)) (= $x10 $x59)) $x59)))
+(let (($x69 (or (not $x59) $x65)))
+(let ((@x70 ((_ |quant-inst| |x$| |y$|) $x69)))
+(let ((@x72 (trans (symm (|unit-resolution| @x70 @x64 $x65) (= |x$| ?x14)) @x49 $x17)))
+(let ((@x52 (|not-or-elim| (mp (asserted (not (=> $x16 $x17))) @x48 (not (or (not $x16) $x17))) (not $x17))))
+(|unit-resolution| @x52 @x72 false)))))))))))))))))))
 
-2e6ad6073b328dff58f57dea99b605ad0bcd9bbc 32 0
+aea156a69bb23683148bfccfaa255f874937bce0 42 0
 unsat
 ((set-logic AUFLIA)
 (proof
 (let ((?x33 (|snd$a| |p2$|)))
 (let ((?x32 (|fst$a| |p1$|)))
 (let (($x34 (= ?x32 ?x33)))
-(let (($x30 (= |p2$| (|pair$| |y$| |x$|))))
-(let (($x27 (= |p1$| (|pair$a| |x$| |y$|))))
+(let ((?x29 (|pair$| |y$| |x$|)))
+(let (($x30 (= |p2$| ?x29)))
+(let ((?x26 (|pair$a| |x$| |y$|)))
+(let (($x27 (= |p1$| ?x26)))
 (let (($x31 (and $x27 $x30)))
-(let ((@x48 (monotonicity (rewrite (= (=> $x31 $x34) (or (not $x31) $x34))) (= (not (=> $x31 $x34)) (not (or (not $x31) $x34))))))
-(let ((@x50 (|not-or-elim| (mp (asserted (not (=> $x31 $x34))) @x48 (not (or (not $x31) $x34))) $x31)))
-(let ((@x531 (monotonicity (mp (|and-elim| @x50 $x30) (|rewrite*| (= $x30 $x30)) $x30) (= ?x33 (|snd$a| (|pair$| |y$| |x$|))))))
-(let (($x552 (forall ((?v0 |B$|) (?v1 |A$|) )(!(= (|snd$a| (|pair$| ?v0 ?v1)) ?v1) :pattern ( (|pair$| ?v0 ?v1) )))
+(let ((@x68 (monotonicity (rewrite (= (=> $x31 $x34) (or (not $x31) $x34))) (= (not (=> $x31 $x34)) (not (or (not $x31) $x34))))))
+(let ((@x69 (|not-or-elim| (mp (asserted (not (=> $x31 $x34))) @x68 (not (or (not $x31) $x34))) $x31)))
+(let ((@x72 (|and-elim| @x69 $x30)))
+(let ((@x150 (symm (monotonicity @x72 (= ?x33 (|snd$a| ?x29))) (= (|snd$a| ?x29) ?x33))))
+(let ((?x123 (|snd$a| ?x29)))
+(let (($x124 (= ?x123 |x$|)))
+(let (($x115 (forall ((?v0 |B$|) (?v1 |A$|) )(!(= (|snd$a| (|pair$| ?v0 ?v1)) ?v1) :pattern ( (|pair$| ?v0 ?v1) )))
 ))
 (let (($x22 (forall ((?v0 |B$|) (?v1 |A$|) )(= (|snd$a| (|pair$| ?v0 ?v1)) ?v1))
 ))
 (let (($x21 (= (|snd$a| (|pair$| ?1 ?0)) ?0)))
-(let ((@x114 (|mp~| (mp (asserted $x22) (|rewrite*| (= $x22 $x22)) $x22) (|nnf-pos| (refl (|~| $x21 $x21)) (|~| $x22 $x22)) $x22)))
-(let ((@x520 (|unit-resolution| ((_ |quant-inst| |y$| |x$|) (or (not $x552) (= (|snd$a| (|pair$| |y$| |x$|)) |x$|))) (mp @x114 (|quant-intro| (refl (= $x21 $x21)) (= $x22 $x552)) $x552) (= (|snd$a| (|pair$| |y$| |x$|)) |x$|))))
-(let (($x540 (forall ((?v0 |A$|) (?v1 |B$|) )(!(= (|fst$a| (|pair$a| ?v0 ?v1)) ?v0) :pattern ( (|pair$a| ?v0 ?v1) )))
+(let ((@x94 (|mp~| (asserted $x22) (|nnf-pos| (refl (|~| $x21 $x21)) (|~| $x22 $x22)) $x22)))
+(let ((@x120 (mp @x94 (|quant-intro| (refl (= $x21 $x21)) (= $x22 $x115)) $x115)))
+(let (($x131 (or (not $x115) $x124)))
+(let ((@x132 ((_ |quant-inst| |y$| |x$|) $x131)))
+(let ((?x128 (|fst$a| ?x26)))
+(let (($x129 (= ?x128 |x$|)))
+(let (($x103 (forall ((?v0 |A$|) (?v1 |B$|) )(!(= (|fst$a| (|pair$a| ?v0 ?v1)) ?v0) :pattern ( (|pair$a| ?v0 ?v1) )))
 ))
 (let (($x16 (forall ((?v0 |A$|) (?v1 |B$|) )(= (|fst$a| (|pair$a| ?v0 ?v1)) ?v0))
 ))
 (let (($x15 (= (|fst$a| (|pair$a| ?1 ?0)) ?1)))
-(let ((@x108 (|mp~| (mp (asserted $x16) (|rewrite*| (= $x16 $x16)) $x16) (|nnf-pos| (refl (|~| $x15 $x15)) (|~| $x16 $x16)) $x16)))
-(let ((@x192 (|unit-resolution| ((_ |quant-inst| |x$| |y$|) (or (not $x540) (= (|fst$a| (|pair$a| |x$| |y$|)) |x$|))) (mp @x108 (|quant-intro| (refl (= $x15 $x15)) (= $x16 $x540)) $x540) (= (|fst$a| (|pair$a| |x$| |y$|)) |x$|))))
-(let ((@x529 (monotonicity (mp (|and-elim| @x50 $x27) (|rewrite*| (= $x27 $x27)) $x27) (= ?x32 (|fst$a| (|pair$a| |x$| |y$|))))))
-(let ((@x507 (trans (trans @x529 @x192 (= ?x32 |x$|)) (symm @x520 (= |x$| (|snd$a| (|pair$| |y$| |x$|)))) (= ?x32 (|snd$a| (|pair$| |y$| |x$|))))))
-(let (($x53 (not $x34)))
-(let ((@x54 (|not-or-elim| (mp (asserted (not (=> $x31 $x34))) @x48 (not (or (not $x31) $x34))) $x53)))
-(|unit-resolution| (mp @x54 (|rewrite*| (= $x53 $x53)) $x53) (trans @x507 (symm @x531 (= (|snd$a| (|pair$| |y$| |x$|)) ?x33)) $x34) false))))))))))))))))))))))))))
+(let ((@x84 (|mp~| (asserted $x16) (|nnf-pos| (refl (|~| $x15 $x15)) (|~| $x16 $x16)) $x16)))
+(let ((@x108 (mp @x84 (|quant-intro| (refl (= $x15 $x15)) (= $x16 $x103)) $x103)))
+(let (($x136 (or (not $x103) $x129)))
+(let ((@x137 ((_ |quant-inst| |x$| |y$|) $x136)))
+(let ((@x152 (trans (monotonicity (|and-elim| @x69 $x27) (= ?x32 ?x128)) (|unit-resolution| @x137 @x108 $x129) (= ?x32 |x$|))))
+(let ((@x154 (trans @x152 (symm (|unit-resolution| @x132 @x120 $x124) (= |x$| ?x123)) (= ?x32 ?x123))))
+(let ((@x74 (|not-or-elim| (mp (asserted (not (=> $x31 $x34))) @x68 (not (or (not $x31) $x34))) (not $x34))))
+(|unit-resolution| @x74 (trans @x154 @x150 $x34) false))))))))))))))))))))))))))))))))))))
 
-aeb8771903a6c70ea67dddc8b5f3cfb927335a01 42 0
+9e587b4eedc0dc25b019cb54b54b4a4e643bf93e 49 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let ((?x41 (|fun_app$b| (|fun_upd$| (|fun_app$a| (|fun_app$b| (|fun_upd$| |f$|) |i1$|) |v1$|)) |i2$|)))
-(let ((?x44 (|fun_app$| (|fun_app$a| ?x41 |v2$|) |i$|)))
-(let (($x46 (= ?x44 (|fun_app$| |f$| |i$|))))
-(let ((?x39 (|fun_app$a| (|fun_app$b| (|fun_upd$| |f$|) |i1$|) |v1$|)))
-(let ((?x209 (|fun_app$| ?x39 |i$|)))
-(let (($x217 (= ?x209 (|fun_app$| |f$| |i$|))))
+(let ((?x45 (|fun_app$| |f$| |i$|)))
+(let ((?x36 (|fun_upd$| |f$|)))
+(let ((?x37 (|fun_app$b| ?x36 |i1$|)))
+(let ((?x39 (|fun_app$a| ?x37 |v1$|)))
+(let ((?x40 (|fun_upd$| ?x39)))
+(let ((?x41 (|fun_app$b| ?x40 |i2$|)))
+(let ((?x43 (|fun_app$a| ?x41 |v2$|)))
+(let ((?x44 (|fun_app$| ?x43 |i$|)))
+(let (($x46 (= ?x44 ?x45)))
 (let (($x29 (= |i$| |i1$|)))
-(let (($x496 (ite $x29 (= ?x209 |v1$|) $x217)))
-(let (($x543 (forall ((?v0 |A_b_fun$|) (?v1 |A$|) (?v2 |B$|) (?v3 |A$|) )(!(let ((?x21 (|fun_app$| (|fun_app$a| (|fun_app$b| (|fun_upd$| ?v0) ?v1) ?v2) ?v3)))
-(ite (= ?v3 ?v1) (= ?x21 ?v2) (= ?x21 (|fun_app$| ?v0 ?v3)))) :pattern ( (|fun_app$| (|fun_app$a| (|fun_app$b| (|fun_upd$| ?v0) ?v1) ?v2) ?v3) )))
-))
-(let (($x114 (forall ((?v0 |A_b_fun$|) (?v1 |A$|) (?v2 |B$|) (?v3 |A$|) )(let ((?x21 (|fun_app$| (|fun_app$a| (|fun_app$b| (|fun_upd$| ?v0) ?v1) ?v2) ?v3)))
-(ite (= ?v3 ?v1) (= ?x21 ?v2) (= ?x21 (|fun_app$| ?v0 ?v3)))))
-))
-(let ((?x21 (|fun_app$| (|fun_app$a| (|fun_app$b| (|fun_upd$| ?3) ?2) ?1) ?0)))
-(let (($x111 (ite (= ?0 ?2) (= ?x21 ?1) (= ?x21 (|fun_app$| ?3 ?0)))))
-(let (($x26 (forall ((?v0 |A_b_fun$|) (?v1 |A$|) (?v2 |B$|) (?v3 |A$|) )(let ((?x21 (|fun_app$| (|fun_app$a| (|fun_app$b| (|fun_upd$| ?v0) ?v1) ?v2) ?v3)))
-(= ?x21 (ite (= ?v3 ?v1) ?v2 (|fun_app$| ?v0 ?v3)))))
-))
-(let ((@x113 (rewrite (= (= ?x21 (ite (= ?0 ?2) ?1 (|fun_app$| ?3 ?0))) $x111))))
-(let (($x25 (= ?x21 (ite (= ?0 ?2) ?1 (|fun_app$| ?3 ?0)))))
-(let ((@x108 (|mp~| (mp (asserted $x26) (|rewrite*| (= $x26 $x26)) $x26) (|nnf-pos| (refl (|~| $x25 $x25)) (|~| $x26 $x26)) $x26)))
-(let ((@x548 (mp (mp @x108 (|quant-intro| @x113 (= $x26 $x114)) $x114) (|quant-intro| (refl (= $x111 $x111)) (= $x114 $x543)) $x543)))
+(let ((?x178 (ite $x29 |v1$| ?x45)))
+(let (($x185 (= ?x45 ?x178)))
 (let (($x30 (not $x29)))
 (let (($x32 (= |i$| |i2$|)))
 (let (($x33 (not $x32)))
 (let (($x34 (and $x30 $x33)))
-(let ((@x58 (monotonicity (rewrite (= (=> $x34 $x46) (or (not $x34) $x46))) (= (not (=> $x34 $x46)) (not (or (not $x34) $x46))))))
-(let ((@x60 (|not-or-elim| (mp (asserted (not (=> $x34 $x46))) @x58 (not (or (not $x34) $x46))) $x34)))
-(let ((@x333 (|unit-resolution| (|def-axiom| (or (not $x496) $x29 $x217)) (mp (|and-elim| @x60 $x30) (|rewrite*| (= $x30 $x30)) $x30) (or (not $x496) $x217))))
-(let ((@x334 (|unit-resolution| @x333 (|unit-resolution| ((_ |quant-inst| |f$| |i1$| |v1$| |i$|) (or (not $x543) $x496)) @x548 $x496) $x217)))
-(let (($x212 (= ?x44 ?x209)))
-(let (($x191 (ite $x32 (= ?x44 |v2$|) $x212)))
-(let ((@x478 (|unit-resolution| (|def-axiom| (or (not $x191) $x32 $x212)) (mp (|and-elim| @x60 $x33) (|rewrite*| (= $x33 $x33)) $x33) (or (not $x191) $x212))))
-(let ((@x479 (|unit-resolution| @x478 (|unit-resolution| ((_ |quant-inst| (|fun_app$a| (|fun_app$b| (|fun_upd$| |f$|) |i1$|) |v1$|) |i2$| |v2$| |i$|) (or (not $x543) $x191)) @x548 $x191) $x212)))
-(let (($x63 (not $x46)))
-(let ((@x64 (|not-or-elim| (mp (asserted (not (=> $x34 $x46))) @x58 (not (or (not $x34) $x46))) $x63)))
-(|unit-resolution| (mp @x64 (|rewrite*| (= $x63 $x63)) $x63) (trans @x479 @x334 $x46) false))))))))))))))))))))))))))))))))))
+(let ((@x78 (monotonicity (rewrite (= (=> $x34 $x46) (or (not $x34) $x46))) (= (not (=> $x34 $x46)) (not (or (not $x34) $x46))))))
+(let ((@x79 (|not-or-elim| (mp (asserted (not (=> $x34 $x46))) @x78 (not (or (not $x34) $x46))) $x34)))
+(let ((@x80 (|and-elim| @x79 $x30)))
+(let ((@x197 (symm (|unit-resolution| (|def-axiom| (or $x29 $x185)) @x80 $x185) (= ?x178 ?x45))))
+(let ((?x116 (|fun_app$| ?x39 |i$|)))
+(let (($x179 (= ?x116 ?x178)))
+(let (($x103 (forall ((?v0 |A_b_fun$|) (?v1 |A$|) (?v2 |B$|) (?v3 |A$|) )(!(let ((?x21 (|fun_app$| (|fun_app$a| (|fun_app$b| (|fun_upd$| ?v0) ?v1) ?v2) ?v3)))
+(= ?x21 (ite (= ?v3 ?v1) ?v2 (|fun_app$| ?v0 ?v3)))) :pattern ( (|fun_app$| (|fun_app$a| (|fun_app$b| (|fun_upd$| ?v0) ?v1) ?v2) ?v3) )))
+))
+(let (($x26 (forall ((?v0 |A_b_fun$|) (?v1 |A$|) (?v2 |B$|) (?v3 |A$|) )(let ((?x21 (|fun_app$| (|fun_app$a| (|fun_app$b| (|fun_upd$| ?v0) ?v1) ?v2) ?v3)))
+(= ?x21 (ite (= ?v3 ?v1) ?v2 (|fun_app$| ?v0 ?v3)))))
+))
+(let ((?x21 (|fun_app$| (|fun_app$a| (|fun_app$b| (|fun_upd$| ?3) ?2) ?1) ?0)))
+(let (($x25 (= ?x21 (ite (= ?0 ?2) ?1 (|fun_app$| ?3 ?0)))))
+(let ((@x94 (|mp~| (asserted $x26) (|nnf-pos| (refl (|~| $x25 $x25)) (|~| $x26 $x26)) $x26)))
+(let ((@x108 (mp @x94 (|quant-intro| (refl (= $x25 $x25)) (= $x26 $x103)) $x103)))
+(let (($x123 (not $x103)))
+(let (($x182 (or $x123 $x179)))
+(let ((@x183 ((_ |quant-inst| |f$| |i1$| |v1$| |i$|) $x182)))
+(let ((?x117 (ite $x32 |v2$| ?x116)))
+(let (($x127 (= ?x116 ?x117)))
+(let ((@x82 (|and-elim| @x79 $x33)))
+(let ((@x195 (symm (|unit-resolution| (|def-axiom| (or $x32 $x127)) @x82 $x127) (= ?x117 ?x116))))
+(let (($x120 (= ?x44 ?x117)))
+(let (($x124 (or $x123 $x120)))
+(let ((@x125 ((_ |quant-inst| (|fun_app$a| ?x37 |v1$|) |i2$| |v2$| |i$|) $x124)))
+(let ((@x201 (trans (trans (|unit-resolution| @x125 @x108 $x120) @x195 (= ?x44 ?x116)) (|unit-resolution| @x183 @x108 $x179) (= ?x44 ?x178))))
+(let ((@x84 (|not-or-elim| (mp (asserted (not (=> $x34 $x46))) @x78 (not (or (not $x34) $x46))) (not $x46))))
+(|unit-resolution| @x84 (trans @x201 @x197 $x46) false)))))))))))))))))))))))))))))))))))))))))))
 
-c4b4af33aa30da357345c646af342edc4d415cfd 19 0
+b3ae8e1fe1d7b019d0bef97ff09cdb8e0a1cd7dd 25 0
 unsat
 ((set-logic AUFLIA)
 (proof
+(let (($x7 (|f$| |g$| |x$|)))
+(let (($x71 (not $x7)))
+(let (($x63 (not (or (= $x7 (|fun_app$| |g$| |x$|)) $x7 (|fun_app$| |g$| |x$|)))))
+(let (($x10 (= $x7 (and (|fun_app$| |g$| |x$|) true))))
+(let (($x15 (not (or $x10 (or (= $x7 true) (= (|fun_app$| |g$| |x$|) true))))))
 (let (($x8 (|fun_app$| |g$| |x$|)))
-(let (($x7 (|f$| |g$| |x$|)))
-(let (($x33 (not $x7)))
-(let (($x34 (= $x33 $x8)))
-(let ((@x49 (monotonicity (rewrite (= (= $x8 true) $x8)) (= (not (= $x8 true)) (not $x8)))))
-(let (($x10 (= $x7 (and $x8 true))))
-(let (($x15 (not (or $x10 (or (= $x7 true) (= $x8 true))))))
-(let ((@x20 (|not-or-elim| (asserted $x15) (not (or (= $x7 true) (= $x8 true))))))
-(let ((@x56 (|iff-false| (mp (|not-or-elim| @x20 (not (= $x8 true))) @x49 (not $x8)) (= $x8 false))))
-(let ((@x43 (monotonicity (rewrite (= (= $x7 true) $x7)) (= (not (= $x7 true)) $x33))))
-(let ((@x52 (|iff-true| (mp (|not-or-elim| @x20 (not (= $x7 true))) @x43 $x33) (= $x33 true))))
-(let ((@x61 (trans (monotonicity @x52 @x56 (= $x34 (= true false))) (rewrite (= (= true false) false)) (= $x34 false))))
-(let ((@x29 (monotonicity (rewrite (= (and $x8 true) $x8)) (= $x10 (= $x7 $x8)))))
-(let ((@x38 (trans (monotonicity @x29 (= (not $x10) (not (= $x7 $x8)))) (rewrite (= (not (= $x7 $x8)) $x34)) (= (not $x10) $x34))))
-(mp (mp (|not-or-elim| (asserted $x15) (not $x10)) @x38 $x34) @x61 false)))))))))))))))))
+(let (($x51 (or $x7 $x8)))
+(let (($x42 (= $x7 $x8)))
+(let (($x54 (or $x42 $x51)))
+(let ((@x65 (monotonicity (rewrite (= $x54 (or $x42 $x7 $x8))) (= (not $x54) $x63))))
+(let ((@x53 (monotonicity (rewrite (= (= $x7 true) $x7)) (rewrite (= (= $x8 true) $x8)) (= (or (= $x7 true) (= $x8 true)) $x51))))
+(let ((@x41 (monotonicity (rewrite (= (and $x8 true) $x8)) (= $x10 (= $x7 $x8)))))
+(let ((@x56 (monotonicity (trans @x41 (rewrite (= (= $x7 $x8) $x42)) (= $x10 $x42)) @x53 (= (or $x10 (or (= $x7 true) (= $x8 true))) $x54))))
+(let ((@x67 (trans (monotonicity @x56 (= $x15 (not $x54))) @x65 (= $x15 $x63))))
+(let ((@x68 (mp (asserted $x15) @x67 $x63)))
+(let ((@x72 (|not-or-elim| @x68 $x71)))
+(let (($x73 (not $x8)))
+(let ((@x74 (|not-or-elim| @x68 $x73)))
+(let (($x75 (= $x71 $x8)))
+(let ((@x77 (mp (|not-or-elim| @x68 (not $x42)) (rewrite (= (not $x42) $x75)) $x75)))
+(|unit-resolution| (|unit-resolution| (|def-axiom| (or $x7 $x8 (not $x75))) @x77 $x51) @x74 @x72 false)))))))))))))))))))))))
 
-fb8b7f74f922a8d00662632480052b1430519f93 12 0
+d9e693c8b48e2988c493bb1e4e83656e750403bf 14 0
 unsat
 ((set-logic AUFLIA)
 (proof
 (let (($x7 (exists ((?v0 |A$|) )(|g$| ?v0))
 ))
-(let (($x10 (=> (|f$| (ite $x7 true false)) true)))
+(let (($x8 (ite $x7 true false)))
+(let (($x9 (|f$| $x8)))
+(let (($x10 (=> $x9 true)))
 (let (($x11 (not $x10)))
-(let ((@x17 (monotonicity (rewrite (= (ite $x7 true false) $x7)) (= (|f$| (ite $x7 true false)) (|f$| $x7)))))
-(let ((@x24 (trans (monotonicity @x17 (= $x10 (=> (|f$| $x7) true))) (rewrite (= (=> (|f$| $x7) true) true)) (= $x10 true))))
-(let ((@x31 (trans (monotonicity @x24 (= $x11 (not true))) (rewrite (= (not true) false)) (= $x11 false))))
-(mp (asserted $x11) @x31 false)))))))))
+(let ((@x40 (monotonicity (monotonicity (rewrite (= $x8 $x7)) (= $x9 (|f$| $x7))) (= $x10 (=> (|f$| $x7) true)))))
+(let ((@x44 (trans @x40 (rewrite (= (=> (|f$| $x7) true) true)) (= $x10 true))))
+(let ((@x51 (trans (monotonicity @x44 (= $x11 (not true))) (rewrite (= (not true) false)) (= $x11 false))))
+(mp (asserted $x11) @x51 false)))))))))))
 
-d62e2b1dea713f6de1a49810c6dcc90c07962d7b 12 0
+389aa7c628b5a2215f1c34b1b3aea4f4becc378c 14 0
 unsat
 ((set-logic AUFLIA)
 (proof
 (let (($x7 (forall ((?v0 |A$|) )(|g$| ?v0))
 ))
-(let (($x10 (=> (|f$| (ite $x7 true false)) true)))
+(let (($x8 (ite $x7 true false)))
+(let (($x9 (|f$| $x8)))
+(let (($x10 (=> $x9 true)))
 (let (($x11 (not $x10)))
-(let ((@x17 (monotonicity (rewrite (= (ite $x7 true false) $x7)) (= (|f$| (ite $x7 true false)) (|f$| $x7)))))
-(let ((@x24 (trans (monotonicity @x17 (= $x10 (=> (|f$| $x7) true))) (rewrite (= (=> (|f$| $x7) true) true)) (= $x10 true))))
-(let ((@x31 (trans (monotonicity @x24 (= $x11 (not true))) (rewrite (= (not true) false)) (= $x11 false))))
-(mp (asserted $x11) @x31 false)))))))))
+(let ((@x40 (monotonicity (monotonicity (rewrite (= $x8 $x7)) (= $x9 (|f$| $x7))) (= $x10 (=> (|f$| $x7) true)))))
+(let ((@x44 (trans @x40 (rewrite (= (=> (|f$| $x7) true) true)) (= $x10 true))))
+(let ((@x51 (trans (monotonicity @x44 (= $x11 (not true))) (rewrite (= (not true) false)) (= $x11 false))))
+(mp (asserted $x11) @x51 false)))))))))))
 
-95d5c3c67c271c191a1aa0777fcf993d700adecd 43 0
+53b477f55537542d72fa148413e684cc3ff42e5b 46 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let (($x19 (|fun_app$| (|fun_app$a| |le$| 3) 42)))
-(let (($x33 (not $x19)))
+(let ((?x17 (|fun_app$a| |le$| 3)))
+(let (($x19 (|fun_app$| ?x17 42)))
+(let (($x73 (not $x19)))
 (let (($x15 (= |le$| |uu$|)))
-(let ((@x30 (monotonicity (rewrite (= (=> $x15 $x19) (or (not $x15) $x19))) (= (not (=> $x15 $x19)) (not (or (not $x15) $x19))))))
-(let ((@x32 (|not-or-elim| (mp (asserted (not (=> $x15 $x19))) @x30 (not (or (not $x15) $x19))) $x15)))
-(let ((@x487 (monotonicity (symm (mp @x32 (|rewrite*| (= $x15 $x15)) $x15) (= |uu$| |le$|)) (= (|fun_app$a| |uu$| 3) (|fun_app$a| |le$| 3)))))
-(let ((@x489 (symm (monotonicity @x487 (= (|fun_app$| (|fun_app$a| |uu$| 3) 42) $x19)) (= $x19 (|fun_app$| (|fun_app$a| |uu$| 3) 42)))))
-(let ((@x477 (monotonicity @x489 (= $x33 (not (|fun_app$| (|fun_app$a| |uu$| 3) 42))))))
-(let ((@x34 (|not-or-elim| (mp (asserted (not (=> $x15 $x19))) @x30 (not (or (not $x15) $x19))) $x33)))
-(let ((@x195 (mp (mp @x34 (|rewrite*| (= $x33 $x33)) $x33) @x477 (not (|fun_app$| (|fun_app$a| |uu$| 3) 42)))))
-(let (($x174 (|fun_app$| (|fun_app$a| |uu$| 3) 42)))
-(let (($x78 (forall ((?v0 Int) (?v1 Int) )(!(let (($x9 (|fun_app$| (|fun_app$a| |uu$| ?v0) ?v1)))
-(= $x9 (<= (+ ?v0 (* (~ 1) ?v1)) 0))) :pattern ( (|fun_app$| (|fun_app$a| |uu$| ?v0) ?v1) )))
+(let ((@x71 (monotonicity (rewrite (= (=> $x15 $x19) (or (not $x15) $x19))) (= (not (=> $x15 $x19)) (not (or (not $x15) $x19))))))
+(let ((@x72 (|not-or-elim| (mp (asserted (not (=> $x15 $x19))) @x71 (not (or (not $x15) $x19))) $x15)))
+(let ((@x126 (monotonicity (symm @x72 (= |uu$| |le$|)) (= (|fun_app$a| |uu$| 3) ?x17))))
+(let ((@x130 (symm (monotonicity @x126 (= (|fun_app$| (|fun_app$a| |uu$| 3) 42) $x19)) (= $x19 (|fun_app$| (|fun_app$a| |uu$| 3) 42)))))
+(let ((@x133 (monotonicity @x130 (= $x73 (not (|fun_app$| (|fun_app$a| |uu$| 3) 42))))))
+(let ((@x75 (|not-or-elim| (mp (asserted (not (=> $x15 $x19))) @x71 (not (or (not $x15) $x19))) $x73)))
+(let ((?x81 (|fun_app$a| |uu$| 3)))
+(let (($x82 (|fun_app$| ?x81 42)))
+(let (($x58 (forall ((?v0 Int) (?v1 Int) )(!(let (($x52 (<= (+ ?v0 (* (~ 1) ?v1)) 0)))
+(let (($x9 (|fun_app$| (|fun_app$a| |uu$| ?v0) ?v1)))
+(= $x9 $x52))) :pattern ( (|fun_app$| (|fun_app$a| |uu$| ?v0) ?v1) )))
 ))
+(let (($x52 (<= (+ ?1 (* (~ 1) ?0)) 0)))
 (let (($x9 (|fun_app$| (|fun_app$a| |uu$| ?1) ?0)))
-(let (($x75 (= $x9 (<= (+ ?1 (* (~ 1) ?0)) 0))))
+(let (($x55 (= $x9 $x52)))
 (let (($x13 (forall ((?v0 Int) (?v1 Int) )(!(let (($x10 (<= ?v0 ?v1)))
 (let (($x9 (|fun_app$| (|fun_app$a| |uu$| ?v0) ?v1)))
 (= $x9 $x10))) :pattern ( (|fun_app$| (|fun_app$a| |uu$| ?v0) ?v1) )))
 ))
-(let (($x66 (forall ((?v0 Int) (?v1 Int) )(!(let (($x10 (<= ?v0 ?v1)))
+(let (($x46 (forall ((?v0 Int) (?v1 Int) )(!(let (($x10 (<= ?v0 ?v1)))
 (let (($x9 (|fun_app$| (|fun_app$a| |uu$| ?v0) ?v1)))
 (= $x9 $x10))) :pattern ( (|fun_app$| (|fun_app$a| |uu$| ?v0) ?v1) )))
 ))
-(let ((@x77 (monotonicity (rewrite (= (<= ?1 ?0) (<= (+ ?1 (* (~ 1) ?0)) 0))) (= (= $x9 (<= ?1 ?0)) $x75))))
-(let ((@x68 (|quant-intro| (rewrite (= (= $x9 (<= ?1 ?0)) (= $x9 (<= ?1 ?0)))) (= $x13 $x66))))
-(let ((@x83 (mp (mp (asserted $x13) (|rewrite*| (= $x13 $x13)) $x13) (trans @x68 (|quant-intro| @x77 (= $x66 $x78)) (= $x13 $x78)) $x78)))
-(let (($x140 (or (not $x78) $x174)))
-(let (($x143 (= (or (not $x78) (= $x174 (<= (+ 3 (* (~ 1) 42)) 0))) $x140)))
-(let ((?x176 (+ 3 (* (~ 1) 42))))
-(let (($x166 (<= ?x176 0)))
-(let (($x177 (= $x174 $x166)))
-(let ((@x495 (monotonicity (rewrite (= (* (~ 1) 42) (~ 42))) (= ?x176 (+ 3 (~ 42))))))
-(let ((@x498 (monotonicity (trans @x495 (rewrite (= (+ 3 (~ 42)) (~ 39))) (= ?x176 (~ 39))) (= $x166 (<= (~ 39) 0)))))
-(let ((@x502 (trans @x498 (rewrite (= (<= (~ 39) 0) true)) (= $x166 true))))
-(let ((@x137 (trans (monotonicity @x502 (= $x177 (= $x174 true))) (rewrite (= (= $x174 true) $x174)) (= $x177 $x174))))
-(let ((@x483 (mp ((_ |quant-inst| 3 42) (or (not $x78) $x177)) (trans (monotonicity @x137 $x143) (rewrite (= $x140 $x140)) $x143) $x140)))
-(let ((@x484 (|unit-resolution| @x483 (|mp~| @x83 (|nnf-pos| (refl (|~| $x75 $x75)) (|~| $x78 $x78)) $x78) $x174)))
-(|unit-resolution| @x484 @x195 false)))))))))))))))))))))))))))))))))
+(let ((@x57 (monotonicity (rewrite (= (<= ?1 ?0) $x52)) (= (= $x9 (<= ?1 ?0)) $x55))))
+(let ((@x48 (|quant-intro| (rewrite (= (= $x9 (<= ?1 ?0)) (= $x9 (<= ?1 ?0)))) (= $x13 $x46))))
+(let ((@x63 (mp (asserted $x13) (trans @x48 (|quant-intro| @x57 (= $x46 $x58)) (= $x13 $x58)) $x58)))
+(let ((@x80 (|mp~| @x63 (|nnf-pos| (refl (|~| $x55 $x55)) (|~| $x58 $x58)) $x58)))
+(let (($x113 (or (not $x58) $x82)))
+(let (($x116 (= (or (not $x58) (= $x82 (<= (+ 3 (* (~ 1) 42)) 0))) $x113)))
+(let ((?x83 (* (~ 1) 42)))
+(let ((?x84 (+ 3 ?x83)))
+(let (($x85 (<= ?x84 0)))
+(let (($x86 (= $x82 $x85)))
+(let ((@x97 (trans (monotonicity (rewrite (= ?x83 (~ 42))) (= ?x84 (+ 3 (~ 42)))) (rewrite (= (+ 3 (~ 42)) (~ 39))) (= ?x84 (~ 39)))))
+(let ((@x104 (trans (monotonicity @x97 (= $x85 (<= (~ 39) 0))) (rewrite (= (<= (~ 39) 0) true)) (= $x85 true))))
+(let ((@x111 (trans (monotonicity @x104 (= $x86 (= $x82 true))) (rewrite (= (= $x82 true) $x82)) (= $x86 $x82))))
+(let ((@x121 (mp ((_ |quant-inst| 3 42) (or (not $x58) $x86)) (trans (monotonicity @x111 $x116) (rewrite (= $x113 $x113)) $x116) $x113)))
+(|unit-resolution| (|unit-resolution| @x121 @x80 $x82) (mp @x75 @x133 (not $x82)) false)))))))))))))))))))))))))))))))))))
 
-7fbbdb30adaccd1cbc0fc92d3a2f74bf98a088ab 143 0
+737e9aeb0ce08125531c37a003d0a11fe8c1aa00 189 0
 unsat
 ((set-logic AUFLIA)
 (proof
@@ -3683,150 +3778,200 @@
 (let ((?x32 (|nat$| 1)))
 (let ((?x39 (|cons$| ?x32 ?x38)))
 (let ((?x33 (|cons$| ?x32 |nil$|)))
-(let ((?x285 (|map$| |uu$| ?x33)))
 (let ((?x31 (|nat$| 0)))
-(let ((?x284 (|fun_app$| |uu$| ?x31)))
-(let ((?x286 (|cons$| ?x284 ?x285)))
-(let (($x619 (forall ((?v0 |Nat_nat_fun$|) (?v1 |Nat$|) (?v2 |Nat_list$|) )(!(= (|map$| ?v0 (|cons$| ?v1 ?v2)) (|cons$| (|fun_app$| ?v0 ?v1) (|map$| ?v0 ?v2))) :pattern ( (|map$| ?v0 (|cons$| ?v1 ?v2)) ) :pattern ( (|cons$| (|fun_app$| ?v0 ?v1) (|map$| ?v0 ?v2)) )))
+(let ((?x34 (|cons$| ?x31 ?x33)))
+(let ((?x35 (|map$| |uu$| ?x34)))
+(let (($x40 (= ?x35 ?x39)))
+(let ((?x208 (|map$| |uu$| ?x33)))
+(let ((?x326 (|map$| |uu$| |nil$|)))
+(let ((?x325 (|fun_app$| |uu$| ?x32)))
+(let ((?x327 (|cons$| ?x325 ?x326)))
+(let (($x328 (= ?x208 ?x327)))
+(let (($x181 (forall ((?v0 |Nat_nat_fun$|) (?v1 |Nat$|) (?v2 |Nat_list$|) )(!(let ((?x27 (|cons$| (|fun_app$| ?v0 ?v1) (|map$| ?v0 ?v2))))
+(let ((?x24 (|map$| ?v0 (|cons$| ?v1 ?v2))))
+(= ?x24 ?x27))) :pattern ( (|map$| ?v0 (|cons$| ?v1 ?v2)) ) :pattern ( (|cons$| (|fun_app$| ?v0 ?v1) (|map$| ?v0 ?v2)) )))
 ))
-(let (($x29 (forall ((?v0 |Nat_nat_fun$|) (?v1 |Nat$|) (?v2 |Nat_list$|) )(= (|map$| ?v0 (|cons$| ?v1 ?v2)) (|cons$| (|fun_app$| ?v0 ?v1) (|map$| ?v0 ?v2))))
+(let (($x29 (forall ((?v0 |Nat_nat_fun$|) (?v1 |Nat$|) (?v2 |Nat_list$|) )(let ((?x27 (|cons$| (|fun_app$| ?v0 ?v1) (|map$| ?v0 ?v2))))
+(let ((?x24 (|map$| ?v0 (|cons$| ?v1 ?v2))))
+(= ?x24 ?x27))))
 ))
-(let (($x28 (= (|map$| ?2 (|cons$| ?1 ?0)) (|cons$| (|fun_app$| ?2 ?1) (|map$| ?2 ?0)))))
-(let ((@x179 (|mp~| (mp (asserted $x29) (|rewrite*| (= $x29 $x29)) $x29) (|nnf-pos| (refl (|~| $x28 $x28)) (|~| $x29 $x29)) $x29)))
-(let (($x545 (or (not $x619) (= ?x285 (|cons$| (|fun_app$| |uu$| ?x32) (|map$| |uu$| |nil$|))))))
-(let ((@x378 (|unit-resolution| ((_ |quant-inst| |uu$| (|nat$| 1) |nil$|) $x545) (mp @x179 (|quant-intro| (refl (= $x28 $x28)) (= $x29 $x619)) $x619) (= ?x285 (|cons$| (|fun_app$| |uu$| ?x32) (|map$| |uu$| |nil$|))))))
-(let ((@x335 (symm @x378 (= (|cons$| (|fun_app$| |uu$| ?x32) (|map$| |uu$| |nil$|)) ?x285))))
-(let (($x611 (forall ((?v0 |Nat_nat_fun$|) )(!(= (|map$| ?v0 |nil$|) |nil$|) :pattern ( (|map$| ?v0 |nil$|) )))
+(let ((?x27 (|cons$| (|fun_app$| ?2 ?1) (|map$| ?2 ?0))))
+(let ((?x24 (|map$| ?2 (|cons$| ?1 ?0))))
+(let (($x28 (= ?x24 ?x27)))
+(let ((@x156 (|mp~| (asserted $x29) (|nnf-pos| (refl (|~| $x28 $x28)) (|~| $x29 $x29)) $x29)))
+(let ((@x186 (mp @x156 (|quant-intro| (refl (= $x28 $x28)) (= $x29 $x181)) $x181)))
+(let (($x213 (not $x181)))
+(let (($x331 (or $x213 $x328)))
+(let ((@x332 ((_ |quant-inst| |uu$| (|nat$| 1) |nil$|) $x331)))
+(let (($x339 (= ?x326 |nil$|)))
+(let (($x173 (forall ((?v0 |Nat_nat_fun$|) )(!(= (|map$| ?v0 |nil$|) |nil$|) :pattern ( (|map$| ?v0 |nil$|) )))
 ))
 (let (($x19 (forall ((?v0 |Nat_nat_fun$|) )(= (|map$| ?v0 |nil$|) |nil$|))
 ))
-(let ((@x613 (refl (= (= (|map$| ?0 |nil$|) |nil$|) (= (|map$| ?0 |nil$|) |nil$|)))))
-(let ((@x173 (refl (|~| (= (|map$| ?0 |nil$|) |nil$|) (= (|map$| ?0 |nil$|) |nil$|)))))
-(let ((@x168 (|mp~| (mp (asserted $x19) (|rewrite*| (= $x19 $x19)) $x19) (|nnf-pos| @x173 (|~| $x19 $x19)) $x19)))
-(let ((@x379 (|unit-resolution| ((_ |quant-inst| |uu$|) (or (not $x611) (= (|map$| |uu$| |nil$|) |nil$|))) (mp @x168 (|quant-intro| @x613 (= $x19 $x611)) $x611) (= (|map$| |uu$| |nil$|) |nil$|))))
-(let (($x72 (forall ((?v0 |Nat$|) )(!(let ((?x7 (|fun_app$| |uu$| ?v0)))
+(let ((@x175 (refl (= (= (|map$| ?0 |nil$|) |nil$|) (= (|map$| ?0 |nil$|) |nil$|)))))
+(let ((@x148 (refl (|~| (= (|map$| ?0 |nil$|) |nil$|) (= (|map$| ?0 |nil$|) |nil$|)))))
+(let ((@x178 (mp (|mp~| (asserted $x19) (|nnf-pos| @x148 (|~| $x19 $x19)) $x19) (|quant-intro| @x175 (= $x19 $x173)) $x173)))
+(let (($x343 (or (not $x173) $x339)))
+(let ((@x344 ((_ |quant-inst| |uu$|) $x343)))
+(let ((?x255 (|of_nat$| ?x32)))
+(let ((?x340 (+ 1 ?x255)))
+(let ((?x341 (|nat$| ?x340)))
+(let (($x345 (= ?x325 ?x341)))
+(let (($x85 (forall ((?v0 |Nat$|) )(!(let ((?x7 (|fun_app$| |uu$| ?v0)))
 (= ?x7 (|nat$| (+ 1 (|of_nat$| ?v0))))) :pattern ( (|fun_app$| |uu$| ?v0) )))
 ))
 (let ((?x7 (|fun_app$| |uu$| ?0)))
-(let (($x69 (= ?x7 (|nat$| (+ 1 (|of_nat$| ?0))))))
+(let (($x82 (= ?x7 (|nat$| (+ 1 (|of_nat$| ?0))))))
 (let (($x14 (forall ((?v0 |Nat$|) )(!(let ((?x7 (|fun_app$| |uu$| ?v0)))
 (= ?x7 (|nat$| (+ (|of_nat$| ?v0) 1)))) :pattern ( (|fun_app$| |uu$| ?v0) )))
 ))
-(let ((@x68 (monotonicity (rewrite (= (+ (|of_nat$| ?0) 1) (+ 1 (|of_nat$| ?0)))) (= (|nat$| (+ (|of_nat$| ?0) 1)) (|nat$| (+ 1 (|of_nat$| ?0)))))))
-(let ((@x71 (monotonicity @x68 (= (= ?x7 (|nat$| (+ (|of_nat$| ?0) 1))) $x69))))
-(let ((@x108 (mp (mp (asserted $x14) (|quant-intro| @x71 (= $x14 $x72)) $x72) (|rewrite*| (= $x72 $x72)) $x72)))
-(let (($x515 (or (not $x72) (= (|fun_app$| |uu$| ?x32) (|nat$| (+ 1 (|of_nat$| ?x32)))))))
-(let ((@x225 (|unit-resolution| ((_ |quant-inst| (|nat$| 1)) $x515) (|mp~| @x108 (|nnf-pos| (refl (|~| $x69 $x69)) (|~| $x72 $x72)) $x72) (= (|fun_app$| |uu$| ?x32) (|nat$| (+ 1 (|of_nat$| ?x32)))))))
-(let ((?x302 (|of_nat$| ?x32)))
-(let ((?x537 (+ 1 ?x302)))
-(let ((?x538 (|nat$| ?x537)))
-(let (($x626 (forall ((?v0 |Nat$|) )(!(= (|nat$| (|of_nat$| ?v0)) ?v0) :pattern ( (|of_nat$| ?v0) )))
+(let ((@x81 (monotonicity (rewrite (= (+ (|of_nat$| ?0) 1) (+ 1 (|of_nat$| ?0)))) (= (|nat$| (+ (|of_nat$| ?0) 1)) (|nat$| (+ 1 (|of_nat$| ?0)))))))
+(let ((@x84 (monotonicity @x81 (= (= ?x7 (|nat$| (+ (|of_nat$| ?0) 1))) $x82))))
+(let ((@x146 (|mp~| (mp (asserted $x14) (|quant-intro| @x84 (= $x14 $x85)) $x85) (|nnf-pos| (refl (|~| $x82 $x82)) (|~| $x85 $x85)) $x85)))
+(let (($x348 (or (not $x85) $x345)))
+(let ((@x349 ((_ |quant-inst| (|nat$| 1)) $x348)))
+(let ((?x404 (|of_nat$| ?x341)))
+(let ((?x454 (|nat$| ?x404)))
+(let (($x455 (= ?x454 ?x341)))
+(let (($x188 (forall ((?v0 |Nat$|) )(!(= (|nat$| (|of_nat$| ?v0)) ?v0) :pattern ( (|of_nat$| ?v0) )))
 ))
 (let (($x44 (forall ((?v0 |Nat$|) )(= (|nat$| (|of_nat$| ?v0)) ?v0))
 ))
-(let ((@x631 (trans (rewrite (= $x44 $x626)) (rewrite (= $x626 $x626)) (= $x44 $x626))))
-(let ((@x180 (refl (|~| (= (|nat$| (|of_nat$| ?0)) ?0) (= (|nat$| (|of_nat$| ?0)) ?0)))))
-(let ((@x184 (|mp~| (mp (asserted $x44) (|rewrite*| (= $x44 $x44)) $x44) (|nnf-pos| @x180 (|~| $x44 $x44)) $x44)))
-(let ((@x384 (|unit-resolution| ((_ |quant-inst| (|nat$| ?x537)) (or (not $x626) (= (|nat$| (|of_nat$| ?x538)) ?x538))) (mp @x184 @x631 $x626) (= (|nat$| (|of_nat$| ?x538)) ?x538))))
-(let ((?x431 (+ ?x302 (* (~ 1) (|of_nat$| ?x538)))))
-(let (($x399 (= ?x431 (~ 1))))
-(let (($x469 (>= ?x302 (~ 1))))
-(let (($x463 (>= ?x302 1)))
-(let (($x303 (= ?x302 1)))
-(let (($x634 (forall ((?v0 Int) )(!(let (($x49 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(or (not (>= ?v0 0)) $x49)) :pattern ( (|nat$| ?v0) )))
+(let ((@x190 (refl (= (= (|nat$| (|of_nat$| ?0)) ?0) (= (|nat$| (|of_nat$| ?0)) ?0)))))
+(let ((@x160 (refl (|~| (= (|nat$| (|of_nat$| ?0)) ?0) (= (|nat$| (|of_nat$| ?0)) ?0)))))
+(let ((@x193 (mp (|mp~| (asserted $x44) (|nnf-pos| @x160 (|~| $x44 $x44)) $x44) (|quant-intro| @x190 (= $x44 $x188)) $x188)))
+(let (($x461 (or (not $x188) $x455)))
+(let ((@x462 ((_ |quant-inst| (|nat$| ?x340)) $x461)))
+(let ((?x415 (* (~ 1) ?x404)))
+(let ((?x416 (+ ?x255 ?x415)))
+(let (($x432 (<= ?x416 (~ 1))))
+(let (($x414 (= ?x416 (~ 1))))
+(let (($x407 (>= ?x255 (~ 1))))
+(let (($x401 (>= ?x255 1)))
+(let (($x256 (= ?x255 1)))
+(let (($x195 (forall ((?v0 Int) )(!(let (($x49 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
+(let (($x103 (>= ?v0 0)))
+(let (($x104 (not $x103)))
+(or $x104 $x49)))) :pattern ( (|nat$| ?v0) )))
 ))
-(let (($x155 (forall ((?v0 Int) )(let (($x49 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(or (not (>= ?v0 0)) $x49)))
+(let (($x110 (forall ((?v0 Int) )(let (($x49 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
+(let (($x103 (>= ?v0 0)))
+(let (($x104 (not $x103)))
+(or $x104 $x49)))))
 ))
 (let (($x49 (= (|of_nat$| (|nat$| ?0)) ?0)))
-(let (($x152 (or (not (>= ?0 0)) $x49)))
-(let (($x85 (forall ((?v0 Int) )(let (($x49 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(or (not (<= 0 ?v0)) $x49)))
-))
-(let ((@x151 (monotonicity (rewrite (= (<= 0 ?0) (>= ?0 0))) (= (not (<= 0 ?0)) (not (>= ?0 0))))))
-(let ((@x157 (|quant-intro| (monotonicity @x151 (= (or (not (<= 0 ?0)) $x49) $x152)) (= $x85 $x155))))
+(let (($x103 (>= ?0 0)))
+(let (($x104 (not $x103)))
+(let (($x107 (or $x104 $x49)))
 (let (($x51 (forall ((?v0 Int) )(let (($x49 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
 (let (($x46 (<= 0 ?v0)))
 (=> $x46 $x49))))
 ))
-(let ((@x83 (rewrite (= (=> (<= 0 ?0) $x49) (or (not (<= 0 ?0)) $x49)))))
-(let ((@x79 (monotonicity (rewrite (= (<= 0 ?0) (<= 0 ?0))) (= (=> (<= 0 ?0) $x49) (=> (<= 0 ?0) $x49)))))
-(let ((@x84 (trans @x79 @x83 (= (=> (<= 0 ?0) $x49) (or (not (<= 0 ?0)) $x49)))))
-(let ((@x123 (mp (mp (asserted $x51) (|quant-intro| @x84 (= $x51 $x85)) $x85) (|rewrite*| (= $x85 $x85)) $x85)))
-(let ((@x189 (|mp~| (mp @x123 @x157 $x155) (|nnf-pos| (refl (|~| $x152 $x152)) (|~| $x155 $x155)) $x155)))
-(let ((@x639 (mp @x189 (|quant-intro| (refl (= $x152 $x152)) (= $x155 $x634)) $x634)))
-(let (($x248 (not $x634)))
-(let (($x292 (or $x248 $x303)))
-(let ((@x578 (monotonicity (rewrite (= (>= 1 0) true)) (= (not (>= 1 0)) (not true)))))
-(let ((@x310 (trans @x578 (rewrite (= (not true) false)) (= (not (>= 1 0)) false))))
-(let ((@x581 (monotonicity @x310 (= (or (not (>= 1 0)) $x303) (or false $x303)))))
-(let ((@x291 (trans @x581 (rewrite (= (or false $x303) $x303)) (= (or (not (>= 1 0)) $x303) $x303))))
-(let ((@x573 (monotonicity @x291 (= (or $x248 (or (not (>= 1 0)) $x303)) $x292))))
-(let ((@x576 (trans @x573 (rewrite (= $x292 $x292)) (= (or $x248 (or (not (>= 1 0)) $x303)) $x292))))
-(let ((@x562 (mp ((_ |quant-inst| 1) (or $x248 (or (not (>= 1 0)) $x303))) @x576 $x292)))
-(let ((@x372 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x303) $x463)) (|unit-resolution| @x562 @x639 $x303) $x463)))
-(let (($x472 (not $x469)))
-(let (($x430 (or $x248 $x472 $x399)))
-(let (($x432 (or $x248 (or (not (>= ?x537 0)) (= (|of_nat$| ?x538) ?x537)))))
-(let (($x461 (= (or (not (>= ?x537 0)) (= (|of_nat$| ?x538) ?x537)) (or $x472 $x399))))
-(let ((@x474 (monotonicity (rewrite (= (>= ?x537 0) $x469)) (= (not (>= ?x537 0)) $x472))))
-(let ((@x436 (monotonicity (monotonicity @x474 (rewrite (= (= (|of_nat$| ?x538) ?x537) $x399)) $x461) (= $x432 (or $x248 (or $x472 $x399))))))
-(let ((@x441 (trans @x436 (rewrite (= (or $x248 (or $x472 $x399)) $x430)) (= $x432 $x430))))
-(let ((@x364 (|unit-resolution| (mp ((_ |quant-inst| (+ 1 ?x302)) $x432) @x441 $x430) @x639 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x463) $x469)) @x372 $x469) $x399)))
-(let ((@x370 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x399) (<= ?x431 (~ 1)))) @x364 (<= ?x431 (~ 1)))))
-(let ((@x351 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x399) (>= ?x431 (~ 1)))) @x364 (>= ?x431 (~ 1)))))
-(let ((@x356 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x303) (<= ?x302 1))) (|unit-resolution| @x562 @x639 $x303) (<= ?x302 1))))
-(let ((@x363 (symm ((_ |th-lemma| arith eq-propagate -1 -1 1 1) @x372 @x356 @x351 @x370 (= (|of_nat$| ?x538) 2)) (= 2 (|of_nat$| ?x538)))))
-(let ((@x348 (trans (monotonicity @x363 (= ?x37 (|nat$| (|of_nat$| ?x538)))) @x384 (= ?x37 ?x538))))
-(let ((@x350 (trans @x348 (symm @x225 (= ?x538 (|fun_app$| |uu$| ?x32))) (= ?x37 (|fun_app$| |uu$| ?x32)))))
-(let ((@x333 (monotonicity @x350 (symm @x379 (= |nil$| (|map$| |uu$| |nil$|))) (= ?x38 (|cons$| (|fun_app$| |uu$| ?x32) (|map$| |uu$| |nil$|))))))
-(let ((@x338 (|unit-resolution| ((_ |quant-inst| (|nat$| 0)) (or (not $x72) (= ?x284 (|nat$| (+ 1 (|of_nat$| ?x31)))))) (|mp~| @x108 (|nnf-pos| (refl (|~| $x69 $x69)) (|~| $x72 $x72)) $x72) (= ?x284 (|nat$| (+ 1 (|of_nat$| ?x31)))))))
-(let ((?x598 (|of_nat$| ?x31)))
-(let ((?x543 (+ 1 ?x598)))
-(let ((?x544 (|nat$| ?x543)))
-(let ((@x339 (|unit-resolution| ((_ |quant-inst| (|nat$| ?x543)) (or (not $x626) (= (|nat$| (|of_nat$| ?x544)) ?x544))) (mp @x184 @x631 $x626) (= (|nat$| (|of_nat$| ?x544)) ?x544))))
-(let ((?x517 (|of_nat$| ?x544)))
-(let ((?x512 (+ ?x517 (* (~ 1) ?x598))))
-(let (($x513 (= ?x512 1)))
-(let (($x520 (>= ?x598 (~ 1))))
-(let (($x523 (>= ?x598 0)))
-(let (($x270 (= ?x598 0)))
-(let (($x249 (or $x248 $x270)))
-(let ((@x608 (monotonicity (rewrite (= (>= 0 0) true)) (= (not (>= 0 0)) (not true)))))
-(let ((@x262 (trans @x608 (rewrite (= (not true) false)) (= (not (>= 0 0)) false))))
-(let ((@x601 (monotonicity @x262 (= (or (not (>= 0 0)) $x270) (or false $x270)))))
-(let ((@x247 (trans @x601 (rewrite (= (or false $x270) $x270)) (= (or (not (>= 0 0)) $x270) $x270))))
-(let ((@x589 (monotonicity @x247 (= (or $x248 (or (not (>= 0 0)) $x270)) $x249))))
-(let ((@x592 (trans @x589 (rewrite (= $x249 $x249)) (= (or $x248 (or (not (>= 0 0)) $x270)) $x249))))
-(let ((@x229 (mp ((_ |quant-inst| 0) (or $x248 (or (not (>= 0 0)) $x270))) @x592 $x249)))
-(let ((@x344 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x270) $x523)) (|unit-resolution| @x229 @x639 $x270) $x523)))
-(let (($x508 (not $x520)))
-(let (($x498 (or $x248 $x508 $x513)))
-(let (($x499 (or $x248 (or (not (>= ?x543 0)) (= ?x517 ?x543)))))
-(let ((@x510 (monotonicity (rewrite (= (>= ?x543 0) $x520)) (= (not (>= ?x543 0)) $x508))))
-(let ((@x497 (monotonicity @x510 (rewrite (= (= ?x517 ?x543) $x513)) (= (or (not (>= ?x543 0)) (= ?x517 ?x543)) (or $x508 $x513)))))
-(let ((@x507 (trans (monotonicity @x497 (= $x499 (or $x248 (or $x508 $x513)))) (rewrite (= (or $x248 (or $x508 $x513)) $x498)) (= $x499 $x498))))
-(let ((@x325 (|unit-resolution| (mp ((_ |quant-inst| (+ 1 ?x598)) $x499) @x507 $x498) @x639 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x523) $x520)) @x344 $x520) $x513)))
-(let ((@x329 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x513) (<= ?x512 1))) @x325 (<= ?x512 1))))
-(let ((@x316 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x513) (>= ?x512 1))) @x325 (>= ?x512 1))))
-(let ((@x319 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x270) (<= ?x598 0))) (|unit-resolution| @x229 @x639 $x270) (<= ?x598 0))))
-(let ((@x311 (monotonicity (symm ((_ |th-lemma| arith eq-propagate -1 -1 -1 -1) @x344 @x319 @x316 @x329 (= ?x517 1)) (= 1 ?x517)) (= ?x32 (|nat$| ?x517)))))
-(let ((@x294 (trans (trans @x311 @x339 (= ?x32 ?x544)) (symm @x338 (= ?x544 ?x284)) (= ?x32 ?x284))))
-(let ((@x300 (symm (monotonicity @x294 (trans @x333 @x335 (= ?x38 ?x285)) (= ?x39 ?x286)) (= ?x286 ?x39))))
-(let ((@x295 (|unit-resolution| ((_ |quant-inst| |uu$| (|nat$| 0) (|cons$| ?x32 |nil$|)) (or (not $x619) (= (|map$| |uu$| (|cons$| ?x31 ?x33)) ?x286))) (mp @x179 (|quant-intro| (refl (= $x28 $x28)) (= $x29 $x619)) $x619) (= (|map$| |uu$| (|cons$| ?x31 ?x33)) ?x286))))
-(let (($x41 (not (= (|map$| |uu$| (|cons$| ?x31 ?x33)) ?x39))))
-(|unit-resolution| (mp (asserted $x41) (|rewrite*| (= $x41 $x41)) $x41) (trans @x295 @x300 (= (|map$| |uu$| (|cons$| ?x31 ?x33)) ?x39)) false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
+(let (($x98 (forall ((?v0 Int) )(let (($x49 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
+(or (not (<= 0 ?v0)) $x49)))
+))
+(let ((@x106 (monotonicity (rewrite (= (<= 0 ?0) $x103)) (= (not (<= 0 ?0)) $x104))))
+(let ((@x112 (|quant-intro| (monotonicity @x106 (= (or (not (<= 0 ?0)) $x49) $x107)) (= $x98 $x110))))
+(let ((@x97 (rewrite (= (=> (<= 0 ?0) $x49) (or (not (<= 0 ?0)) $x49)))))
+(let ((@x115 (mp (asserted $x51) (trans (|quant-intro| @x97 (= $x51 $x98)) @x112 (= $x51 $x110)) $x110)))
+(let ((@x200 (mp (|mp~| @x115 (|nnf-pos| (refl (|~| $x107 $x107)) (|~| $x110 $x110)) $x110) (|quant-intro| (refl (= $x107 $x107)) (= $x110 $x195)) $x195)))
+(let (($x235 (not $x195)))
+(let (($x271 (or $x235 $x256)))
+(let ((@x225 (rewrite (= (not true) false))))
+(let ((@x259 (rewrite (= (>= 1 0) true))))
+(let ((@x263 (trans (monotonicity @x259 (= (not (>= 1 0)) (not true))) @x225 (= (not (>= 1 0)) false))))
+(let ((@x266 (monotonicity @x263 (= (or (not (>= 1 0)) $x256) (or false $x256)))))
+(let ((@x270 (trans @x266 (rewrite (= (or false $x256) $x256)) (= (or (not (>= 1 0)) $x256) $x256))))
+(let ((@x275 (monotonicity @x270 (= (or $x235 (or (not (>= 1 0)) $x256)) $x271))))
+(let ((@x278 (trans @x275 (rewrite (= $x271 $x271)) (= (or $x235 (or (not (>= 1 0)) $x256)) $x271))))
+(let ((@x279 (mp ((_ |quant-inst| 1) (or $x235 (or (not (>= 1 0)) $x256))) @x278 $x271)))
+(let ((@x477 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x256) $x401)) (|unit-resolution| @x279 @x200 $x256) $x401)))
+(let (($x410 (not $x407)))
+(let (($x421 (or $x235 $x410 $x414)))
+(let (($x405 (= ?x404 ?x340)))
+(let (($x402 (>= ?x340 0)))
+(let (($x403 (not $x402)))
+(let (($x406 (or $x403 $x405)))
+(let (($x422 (or $x235 $x406)))
+(let ((@x420 (monotonicity (monotonicity (rewrite (= $x402 $x407)) (= $x403 $x410)) (rewrite (= $x405 $x414)) (= $x406 (or $x410 $x414)))))
+(let ((@x430 (trans (monotonicity @x420 (= $x422 (or $x235 (or $x410 $x414)))) (rewrite (= (or $x235 (or $x410 $x414)) $x421)) (= $x422 $x421))))
+(let ((@x431 (mp ((_ |quant-inst| (+ 1 ?x255)) $x422) @x430 $x421)))
+(let ((@x482 (|unit-resolution| @x431 @x200 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x401) $x407)) @x477 $x407) $x414)))
+(let (($x433 (>= ?x416 (~ 1))))
+(let (($x400 (<= ?x255 1)))
+(let ((@x492 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x256) $x400)) (|unit-resolution| @x279 @x200 $x256) $x400)))
+(let ((@x494 ((_ |th-lemma| arith eq-propagate -1 -1 1 1) @x477 @x492 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x414) $x433)) @x482 $x433) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x414) $x432)) @x482 $x432) (= ?x404 2))))
+(let ((@x502 (trans (monotonicity (symm @x494 (= 2 ?x404)) (= ?x37 ?x454)) (|unit-resolution| @x462 @x193 $x455) (= ?x37 ?x341))))
+(let ((@x504 (trans @x502 (symm (|unit-resolution| @x349 @x146 $x345) (= ?x341 ?x325)) (= ?x37 ?x325))))
+(let ((@x506 (monotonicity @x504 (symm (|unit-resolution| @x344 @x178 $x339) (= |nil$| ?x326)) (= ?x38 ?x327))))
+(let ((@x510 (trans @x506 (symm (|unit-resolution| @x332 @x186 $x328) (= ?x327 ?x208)) (= ?x38 ?x208))))
+(let ((?x216 (|of_nat$| ?x31)))
+(let ((?x329 (+ 1 ?x216)))
+(let ((?x330 (|nat$| ?x329)))
+(let ((?x207 (|fun_app$| |uu$| ?x31)))
+(let (($x333 (= ?x207 ?x330)))
+(let (($x337 (or (not $x85) $x333)))
+(let ((@x338 ((_ |quant-inst| (|nat$| 0)) $x337)))
+(let ((?x350 (|of_nat$| ?x330)))
+(let ((?x452 (|nat$| ?x350)))
+(let (($x453 (= ?x452 ?x330)))
+(let (($x457 (or (not $x188) $x453)))
+(let ((@x458 ((_ |quant-inst| (|nat$| ?x329)) $x457)))
+(let ((?x362 (* (~ 1) ?x350)))
+(let ((?x363 (+ ?x216 ?x362)))
+(let (($x379 (<= ?x363 (~ 1))))
+(let (($x361 (= ?x363 (~ 1))))
+(let (($x354 (>= ?x216 (~ 1))))
+(let (($x335 (>= ?x216 0)))
+(let (($x217 (= ?x216 0)))
+(let (($x236 (or $x235 $x217)))
+(let ((@x220 (rewrite (= (>= 0 0) true))))
+(let ((@x227 (trans (monotonicity @x220 (= (not (>= 0 0)) (not true))) @x225 (= (not (>= 0 0)) false))))
+(let ((@x230 (monotonicity @x227 (= (or (not (>= 0 0)) $x217) (or false $x217)))))
+(let ((@x234 (trans @x230 (rewrite (= (or false $x217) $x217)) (= (or (not (>= 0 0)) $x217) $x217))))
+(let ((@x240 (monotonicity @x234 (= (or $x235 (or (not (>= 0 0)) $x217)) $x236))))
+(let ((@x243 (trans @x240 (rewrite (= $x236 $x236)) (= (or $x235 (or (not (>= 0 0)) $x217)) $x236))))
+(let ((@x244 (mp ((_ |quant-inst| 0) (or $x235 (or (not (>= 0 0)) $x217))) @x243 $x236)))
+(let ((@x517 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x217) $x335)) (|unit-resolution| @x244 @x200 $x217) $x335)))
+(let (($x357 (not $x354)))
+(let (($x368 (or $x235 $x357 $x361)))
+(let (($x351 (= ?x350 ?x329)))
+(let (($x346 (>= ?x329 0)))
+(let (($x347 (not $x346)))
+(let (($x352 (or $x347 $x351)))
+(let (($x369 (or $x235 $x352)))
+(let ((@x367 (monotonicity (monotonicity (rewrite (= $x346 $x354)) (= $x347 $x357)) (rewrite (= $x351 $x361)) (= $x352 (or $x357 $x361)))))
+(let ((@x377 (trans (monotonicity @x367 (= $x369 (or $x235 (or $x357 $x361)))) (rewrite (= (or $x235 (or $x357 $x361)) $x368)) (= $x369 $x368))))
+(let ((@x378 (mp ((_ |quant-inst| (+ 1 ?x216)) $x369) @x377 $x368)))
+(let ((@x522 (|unit-resolution| @x378 @x200 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x335) $x354)) @x517 $x354) $x361)))
+(let (($x380 (>= ?x363 (~ 1))))
+(let (($x334 (<= ?x216 0)))
+(let ((@x532 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x217) $x334)) (|unit-resolution| @x244 @x200 $x217) $x334)))
+(let ((@x534 ((_ |th-lemma| arith eq-propagate -1 -1 1 1) @x517 @x532 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x361) $x380)) @x522 $x380) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x361) $x379)) @x522 $x379) (= ?x350 1))))
+(let ((@x542 (trans (monotonicity (symm @x534 (= 1 ?x350)) (= ?x32 ?x452)) (|unit-resolution| @x458 @x193 $x453) (= ?x32 ?x330))))
+(let ((@x544 (trans @x542 (symm (|unit-resolution| @x338 @x146 $x333) (= ?x330 ?x207)) (= ?x32 ?x207))))
+(let ((@x549 (symm (monotonicity @x544 @x510 (= ?x39 (|cons$| ?x207 ?x208))) (= (|cons$| ?x207 ?x208) ?x39))))
+(let ((?x209 (|cons$| ?x207 ?x208)))
+(let (($x210 (= ?x35 ?x209)))
+(let (($x214 (or $x213 $x210)))
+(let ((@x215 ((_ |quant-inst| |uu$| (|nat$| 0) (|cons$| ?x32 |nil$|)) $x214)))
+(let (($x41 (not $x40)))
+(let ((@x91 (asserted $x41)))
+(|unit-resolution| @x91 (trans (|unit-resolution| @x215 @x186 $x210) @x549 $x40) false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
 
-c2aa9b07a380b6b94c7b3a0cba48d13d4241c907 7 0
+516b38db52977db0759f7a2fb4ee2c61d2623ab0 11 0
 unsat
 ((set-logic AUFLIA)
 (proof
 (let (($x7 (forall ((?v0 |A$|) )(|p$| ?v0))
 ))
-(|unit-resolution| (|not-or-elim| (asserted (not (or $x7 (not $x7)))) (not $x7)) (|not-or-elim| (asserted (not (or $x7 (not $x7)))) $x7) false))))
+(let (($x8 (not $x7)))
+(let (($x9 (or $x7 $x8)))
+(let (($x10 (not $x9)))
+(let ((@x40 (trans (monotonicity (rewrite (= $x9 true)) (= $x10 (not true))) (rewrite (= (not true) false)) (= $x10 false))))
+(mp (asserted $x10) @x40 false))))))))
 
-e807e5ca142c0da5a6842f0271c430bac373ca49 147 0
+120a595aca724e41775e5a997277b8d456a7e9fe 183 0
 unsat
 ((set-logic AUFLIA)
 (proof
@@ -3837,488 +3982,563 @@
 (let ((?x20 (* 4 ?x19)))
 (let ((?x21 (|nat$| ?x20)))
 (let ((?x22 (|dec_10$| ?x21)))
-(let ((?x496 (|dec_10$| ?x24)))
-(let (($x456 (= ?x496 ?x24)))
-(let ((?x522 (|of_nat$| ?x24)))
-(let (($x495 (>= ?x522 10)))
-(let (($x484 (ite $x495 (= ?x496 (|dec_10$| (|nat$| (+ (~ 10) ?x522)))) $x456)))
-(let (($x637 (forall ((?v0 |Nat$|) )(!(let ((?x7 (|of_nat$| ?v0)))
-(let (($x160 (>= ?x7 10)))
-(ite $x160 (= (|dec_10$| ?v0) (|dec_10$| (|nat$| (+ (~ 10) ?x7)))) (= (|dec_10$| ?v0) ?v0)))) :pattern ( (|of_nat$| ?v0) ) :pattern ( (|dec_10$| ?v0) )))
+(let (($x25 (= ?x22 ?x24)))
+(let ((?x348 (|of_nat$| ?x24)))
+(let ((?x393 (+ (~ 10) ?x348)))
+(let ((?x394 (|nat$| ?x393)))
+(let ((?x395 (|dec_10$| ?x394)))
+(let (($x390 (>= ?x348 10)))
+(let ((?x396 (ite $x390 ?x395 ?x24)))
+(let (($x403 (= ?x24 ?x396)))
+(let (($x404 (not $x390)))
+(let (($x398 (<= ?x348 6)))
+(let (($x349 (= ?x348 6)))
+(let (($x188 (forall ((?v0 Int) )(!(let ((?x33 (|nat$| ?v0)))
+(let ((?x34 (|of_nat$| ?x33)))
+(let (($x35 (= ?x34 ?v0)))
+(let (($x114 (>= ?v0 0)))
+(let (($x115 (not $x114)))
+(or $x115 $x35)))))) :pattern ( (|nat$| ?v0) )))
+))
+(let (($x121 (forall ((?v0 Int) )(let ((?x33 (|nat$| ?v0)))
+(let ((?x34 (|of_nat$| ?x33)))
+(let (($x35 (= ?x34 ?v0)))
+(let (($x114 (>= ?v0 0)))
+(let (($x115 (not $x114)))
+(or $x115 $x35)))))))
+))
+(let ((?x33 (|nat$| ?0)))
+(let ((?x34 (|of_nat$| ?x33)))
+(let (($x35 (= ?x34 ?0)))
+(let (($x114 (>= ?0 0)))
+(let (($x115 (not $x114)))
+(let (($x118 (or $x115 $x35)))
+(let (($x37 (forall ((?v0 Int) )(let ((?x33 (|nat$| ?v0)))
+(let ((?x34 (|of_nat$| ?x33)))
+(let (($x35 (= ?x34 ?v0)))
+(let (($x32 (<= 0 ?v0)))
+(=> $x32 $x35))))))
+))
+(let (($x109 (forall ((?v0 Int) )(let ((?x33 (|nat$| ?v0)))
+(let ((?x34 (|of_nat$| ?x33)))
+(let (($x35 (= ?x34 ?v0)))
+(or (not (<= 0 ?v0)) $x35)))))
 ))
-(let (($x216 (forall ((?v0 |Nat$|) )(let ((?x7 (|of_nat$| ?v0)))
-(let (($x160 (>= ?x7 10)))
-(ite $x160 (= (|dec_10$| ?v0) (|dec_10$| (|nat$| (+ (~ 10) ?x7)))) (= (|dec_10$| ?v0) ?v0)))))
+(let ((@x117 (monotonicity (rewrite (= (<= 0 ?0) $x114)) (= (not (<= 0 ?0)) $x115))))
+(let ((@x123 (|quant-intro| (monotonicity @x117 (= (or (not (<= 0 ?0)) $x35) $x118)) (= $x109 $x121))))
+(let ((@x108 (rewrite (= (=> (<= 0 ?0) $x35) (or (not (<= 0 ?0)) $x35)))))
+(let ((@x126 (mp (asserted $x37) (trans (|quant-intro| @x108 (= $x37 $x109)) @x123 (= $x37 $x121)) $x121)))
+(let ((@x193 (mp (|mp~| @x126 (|nnf-pos| (refl (|~| $x118 $x118)) (|~| $x121 $x121)) $x121) (|quant-intro| (refl (= $x118 $x118)) (= $x121 $x188)) $x188)))
+(let (($x274 (not $x188)))
+(let (($x364 (or $x274 $x349)))
+(let ((@x352 (rewrite (= (>= 6 0) true))))
+(let ((@x356 (trans (monotonicity @x352 (= (not (>= 6 0)) (not true))) (rewrite (= (not true) false)) (= (not (>= 6 0)) false))))
+(let ((@x359 (monotonicity @x356 (= (or (not (>= 6 0)) $x349) (or false $x349)))))
+(let ((@x363 (trans @x359 (rewrite (= (or false $x349) $x349)) (= (or (not (>= 6 0)) $x349) $x349))))
+(let ((@x368 (monotonicity @x363 (= (or $x274 (or (not (>= 6 0)) $x349)) $x364))))
+(let ((@x371 (trans @x368 (rewrite (= $x364 $x364)) (= (or $x274 (or (not (>= 6 0)) $x349)) $x364))))
+(let ((@x372 (mp ((_ |quant-inst| 6) (or $x274 (or (not (>= 6 0)) $x349))) @x371 $x364)))
+(let ((@x422 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x349) $x398)) (|unit-resolution| @x372 @x193 $x349) $x398)))
+(let ((@x427 (|unit-resolution| (|def-axiom| (or $x390 $x403)) (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x398) $x404)) @x422 $x404) $x403)))
+(let ((?x389 (|dec_10$| ?x24)))
+(let (($x397 (= ?x389 ?x396)))
+(let (($x175 (forall ((?v0 |Nat$|) )(!(let ((?x69 (|dec_10$| (|nat$| (+ (~ 10) (|of_nat$| ?v0))))))
+(let ((?x88 (ite (>= (|of_nat$| ?v0) 10) ?x69 ?v0)))
+(let ((?x6 (|dec_10$| ?v0)))
+(= ?x6 ?x88)))) :pattern ( (|dec_10$| ?v0) ) :pattern ( (|of_nat$| ?v0) )))
+))
+(let (($x96 (forall ((?v0 |Nat$|) )(let ((?x69 (|dec_10$| (|nat$| (+ (~ 10) (|of_nat$| ?v0))))))
+(let ((?x88 (ite (>= (|of_nat$| ?v0) 10) ?x69 ?v0)))
+(let ((?x6 (|dec_10$| ?v0)))
+(= ?x6 ?x88)))))
+))
+(let ((?x69 (|dec_10$| (|nat$| (+ (~ 10) (|of_nat$| ?0))))))
+(let ((?x88 (ite (>= (|of_nat$| ?0) 10) ?x69 ?0)))
+(let ((?x6 (|dec_10$| ?0)))
+(let (($x93 (= ?x6 ?x88)))
+(let (($x15 (forall ((?v0 |Nat$|) )(let ((?x7 (|of_nat$| ?v0)))
+(let (($x9 (< ?x7 10)))
+(let ((?x6 (|dec_10$| ?v0)))
+(= ?x6 (ite $x9 ?v0 (|dec_10$| (|nat$| (- ?x7 10)))))))))
+))
+(let (($x78 (forall ((?v0 |Nat$|) )(let ((?x69 (|dec_10$| (|nat$| (+ (~ 10) (|of_nat$| ?v0))))))
+(let ((?x7 (|of_nat$| ?v0)))
+(let (($x9 (< ?x7 10)))
+(let ((?x72 (ite $x9 ?v0 ?x69)))
+(let ((?x6 (|dec_10$| ?v0)))
+(= ?x6 ?x72)))))))
 ))
 (let ((?x7 (|of_nat$| ?0)))
-(let (($x160 (>= ?x7 10)))
-(let (($x213 (ite $x160 (= (|dec_10$| ?0) (|dec_10$| (|nat$| (+ (~ 10) ?x7)))) (= (|dec_10$| ?0) ?0))))
-(let (($x168 (forall ((?v0 |Nat$|) )(let ((?x77 (|dec_10$| (|nat$| (+ (~ 10) (|of_nat$| ?v0))))))
-(let ((?x7 (|of_nat$| ?v0)))
-(let (($x160 (>= ?x7 10)))
-(let ((?x6 (|dec_10$| ?v0)))
-(= ?x6 (ite $x160 ?x77 ?v0)))))))
-))
-(let ((?x6 (|dec_10$| ?0)))
-(let (($x165 (= ?x6 (ite $x160 (|dec_10$| (|nat$| (+ (~ 10) ?x7))) ?0))))
-(let (($x91 (forall ((?v0 |Nat$|) )(let ((?x77 (|dec_10$| (|nat$| (+ (~ 10) (|of_nat$| ?v0))))))
-(let ((?x7 (|of_nat$| ?v0)))
-(let (($x47 (<= 10 ?x7)))
-(let ((?x83 (ite $x47 ?x77 ?v0)))
-(let ((?x6 (|dec_10$| ?v0)))
-(= ?x6 ?x83)))))))
-))
-(let ((?x77 (|dec_10$| (|nat$| (+ (~ 10) ?x7)))))
-(let (($x47 (<= 10 ?x7)))
-(let ((?x83 (ite $x47 ?x77 ?0)))
-(let (($x88 (= ?x6 ?x83)))
-(let ((@x167 (monotonicity (monotonicity (rewrite (= $x47 $x160)) (= ?x83 (ite $x160 ?x77 ?0))) (= $x88 $x165))))
-(let (($x15 (forall ((?v0 |Nat$|) )(let ((?x13 (ite (< (|of_nat$| ?v0) 10) ?v0 (|dec_10$| (|nat$| (- (|of_nat$| ?v0) 10))))))
-(let ((?x6 (|dec_10$| ?v0)))
-(= ?x6 ?x13))))
-))
-(let (($x89 (= (= ?x6 (ite (< ?x7 10) ?0 (|dec_10$| (|nat$| (- ?x7 10))))) $x88)))
-(let ((?x13 (ite (< ?x7 10) ?0 (|dec_10$| (|nat$| (- ?x7 10))))))
-(let ((@x66 (monotonicity (rewrite (= (* (~ 1) 10) (~ 10))) (= (+ ?x7 (* (~ 1) 10)) (+ ?x7 (~ 10))))))
-(let ((@x71 (trans @x66 (rewrite (= (+ ?x7 (~ 10)) (+ (~ 10) ?x7))) (= (+ ?x7 (* (~ 1) 10)) (+ (~ 10) ?x7)))))
-(let ((@x73 (trans (rewrite (= (- ?x7 10) (+ ?x7 (* (~ 1) 10)))) @x71 (= (- ?x7 10) (+ (~ 10) ?x7)))))
-(let ((@x79 (monotonicity (monotonicity @x73 (= (|nat$| (- ?x7 10)) (|nat$| (+ (~ 10) ?x7)))) (= (|dec_10$| (|nat$| (- ?x7 10))) ?x77))))
-(let ((@x55 (trans (rewrite (= (< ?x7 10) (not $x47))) (monotonicity (rewrite (= $x47 $x47)) (= (not $x47) (not $x47))) (= (< ?x7 10) (not $x47)))))
-(let ((@x87 (trans (monotonicity @x55 @x79 (= ?x13 (ite (not $x47) ?0 ?x77))) (rewrite (= (ite (not $x47) ?0 ?x77) ?x83)) (= ?x13 ?x83))))
-(let ((@x94 (mp (asserted $x15) (|quant-intro| (monotonicity @x87 $x89) (= $x15 $x91)) $x91)))
-(let ((@x171 (mp (mp @x94 (|rewrite*| (= $x91 $x91)) $x91) (|quant-intro| @x167 (= $x91 $x168)) $x168)))
-(let ((@x219 (mp (|mp~| @x171 (|nnf-pos| (refl (|~| $x165 $x165)) (|~| $x168 $x168)) $x168) (|quant-intro| (rewrite (= $x165 $x213)) (= $x168 $x216)) $x216)))
-(let ((@x642 (mp @x219 (|quant-intro| (refl (= $x213 $x213)) (= $x216 $x637)) $x637)))
-(let (($x485 (<= ?x522 6)))
-(let (($x523 (= ?x522 6)))
-(let (($x651 (forall ((?v0 Int) )(!(let (($x35 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(or (not (>= ?v0 0)) $x35)) :pattern ( (|nat$| ?v0) )))
-))
-(let (($x181 (forall ((?v0 Int) )(let (($x35 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(or (not (>= ?v0 0)) $x35)))
-))
-(let (($x35 (= (|of_nat$| (|nat$| ?0)) ?0)))
-(let (($x178 (or (not (>= ?0 0)) $x35)))
-(let (($x104 (forall ((?v0 Int) )(let (($x35 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(or (not (<= 0 ?v0)) $x35)))
-))
-(let ((@x177 (monotonicity (rewrite (= (<= 0 ?0) (>= ?0 0))) (= (not (<= 0 ?0)) (not (>= ?0 0))))))
-(let ((@x183 (|quant-intro| (monotonicity @x177 (= (or (not (<= 0 ?0)) $x35) $x178)) (= $x104 $x181))))
-(let (($x37 (forall ((?v0 Int) )(let (($x35 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
-(let (($x32 (<= 0 ?v0)))
-(=> $x32 $x35))))
-))
-(let ((@x102 (rewrite (= (=> (<= 0 ?0) $x35) (or (not (<= 0 ?0)) $x35)))))
-(let ((@x98 (monotonicity (rewrite (= (<= 0 ?0) (<= 0 ?0))) (= (=> (<= 0 ?0) $x35) (=> (<= 0 ?0) $x35)))))
-(let ((@x103 (trans @x98 @x102 (= (=> (<= 0 ?0) $x35) (or (not (<= 0 ?0)) $x35)))))
-(let ((@x136 (mp (mp (asserted $x37) (|quant-intro| @x103 (= $x37 $x104)) $x104) (|rewrite*| (= $x104 $x104)) $x104)))
-(let ((@x205 (|mp~| (mp @x136 @x183 $x181) (|nnf-pos| (refl (|~| $x178 $x178)) (|~| $x181 $x181)) $x181)))
-(let ((@x656 (mp @x205 (|quant-intro| (refl (= $x178 $x178)) (= $x181 $x651)) $x651)))
-(let (($x579 (not $x651)))
-(let (($x515 (or $x579 $x523)))
-(let ((@x528 (monotonicity (rewrite (= (>= 6 0) true)) (= (not (>= 6 0)) (not true)))))
-(let ((@x530 (trans @x528 (rewrite (= (not true) false)) (= (not (>= 6 0)) false))))
-(let ((@x510 (monotonicity @x530 (= (or (not (>= 6 0)) $x523) (or false $x523)))))
-(let ((@x514 (trans @x510 (rewrite (= (or false $x523) $x523)) (= (or (not (>= 6 0)) $x523) $x523))))
-(let ((@x500 (monotonicity @x514 (= (or $x579 (or (not (>= 6 0)) $x523)) $x515))))
-(let ((@x503 (trans @x500 (rewrite (= $x515 $x515)) (= (or $x579 (or (not (>= 6 0)) $x523)) $x515))))
-(let ((@x504 (mp ((_ |quant-inst| 6) (or $x579 (or (not (>= 6 0)) $x523))) @x503 $x515)))
-(let ((@x450 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x523) $x485)) (|unit-resolution| @x504 @x656 $x523) $x485)))
-(let ((@x419 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x485) (not $x495))) @x450 (not $x495))))
-(let ((@x421 (|unit-resolution| (|def-axiom| (or (not $x484) $x495 $x456)) @x419 (|unit-resolution| ((_ |quant-inst| (|nat$| 6)) (or (not $x637) $x484)) @x642 $x484) $x456)))
-(let (($x273 (= ?x18 ?x17)))
-(let ((?x624 (|of_nat$| ?x17)))
-(let (($x287 (>= ?x624 10)))
-(let (($x274 (ite $x287 (= ?x18 (|dec_10$| (|nat$| (+ (~ 10) ?x624)))) $x273)))
-(let (($x415 (<= ?x624 4)))
-(let (($x598 (= ?x624 4)))
-(let (($x580 (or $x579 $x598)))
-(let ((@x589 (monotonicity (rewrite (= (>= 4 0) true)) (= (not (>= 4 0)) (not true)))))
-(let ((@x593 (trans @x589 (rewrite (= (not true) false)) (= (not (>= 4 0)) false))))
-(let ((@x433 (monotonicity @x593 (= (or (not (>= 4 0)) $x598) (or false $x598)))))
-(let ((@x578 (trans @x433 (rewrite (= (or false $x598) $x598)) (= (or (not (>= 4 0)) $x598) $x598))))
-(let ((@x584 (monotonicity @x578 (= (or $x579 (or (not (>= 4 0)) $x598)) $x580))))
-(let ((@x412 (trans @x584 (rewrite (= $x580 $x580)) (= (or $x579 (or (not (>= 4 0)) $x598)) $x580))))
-(let ((@x414 (mp ((_ |quant-inst| 4) (or $x579 (or (not (>= 4 0)) $x598))) @x412 $x580)))
-(let ((@x428 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x598) $x415)) (|unit-resolution| @x414 @x656 $x598) $x415)))
-(let ((@x432 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x415) (not $x287))) @x428 (not $x287))))
-(let ((@x402 (|unit-resolution| (|def-axiom| (or (not $x274) $x287 $x273)) @x432 (|unit-resolution| ((_ |quant-inst| (|nat$| 4)) (or (not $x637) $x274)) @x642 $x274) $x273)))
-(let ((@x408 ((_ |th-lemma| arith triangle-eq) (or (not (= ?x19 ?x624)) (<= (+ ?x19 (* (~ 1) ?x624)) 0)))))
-(let ((@x251 (|unit-resolution| @x408 (monotonicity @x402 (= ?x19 ?x624)) (<= (+ ?x19 (* (~ 1) ?x624)) 0))))
-(let (($x492 (>= (+ ?x19 (* (~ 1) ?x624)) 0)))
-(let ((@x411 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x19 ?x624)) $x492)) (monotonicity @x402 (= ?x19 ?x624)) $x492)))
-(let (($x571 (>= ?x624 4)))
-(let ((@x397 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x598) $x571)) (|unit-resolution| @x414 @x656 $x598) $x571)))
-(let ((?x475 (+ ?x20 (* (~ 1) (|of_nat$| ?x21)))))
-(let (($x552 (<= ?x475 0)))
-(let (($x473 (= ?x475 0)))
-(let (($x567 (>= ?x19 0)))
-(let ((@x389 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1) (or $x567 (not $x571) (not $x492))) @x397 @x411 $x567)))
-(let (($x469 (not $x567)))
-(let (($x568 (or $x469 $x473)))
-(let (($x557 (or $x579 $x469 $x473)))
-(let (($x558 (or $x579 (or (not (>= ?x20 0)) (= (|of_nat$| ?x21) ?x20)))))
-(let ((@x463 (monotonicity (rewrite (= (>= ?x20 0) $x567)) (= (not (>= ?x20 0)) $x469))))
-(let ((@x570 (monotonicity @x463 (rewrite (= (= (|of_nat$| ?x21) ?x20) $x473)) (= (or (not (>= ?x20 0)) (= (|of_nat$| ?x21) ?x20)) $x568))))
-(let ((@x563 (trans (monotonicity @x570 (= $x558 (or $x579 $x568))) (rewrite (= (or $x579 $x568) $x557)) (= $x558 $x557))))
-(let ((@x393 (|unit-resolution| (|unit-resolution| (mp ((_ |quant-inst| (* 4 ?x19)) $x558) @x563 $x557) @x656 $x568) @x389 $x473)))
-(let ((@x380 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x473) (>= ?x475 0))) @x393 (>= ?x475 0))))
-(let ((@x382 ((_ |th-lemma| arith eq-propagate 1 1 -4 -4 -4 -4) @x380 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x473) $x552)) @x393 $x552) @x397 @x428 @x411 @x251 (= (+ (~ 10) (|of_nat$| ?x21)) 6))))
-(let ((@x374 (monotonicity (monotonicity @x382 (= (|nat$| (+ (~ 10) (|of_nat$| ?x21))) ?x24)) (= (|dec_10$| (|nat$| (+ (~ 10) (|of_nat$| ?x21)))) ?x496))))
-(let (($x328 (= ?x22 (|dec_10$| (|nat$| (+ (~ 10) (|of_nat$| ?x21)))))))
-(let ((?x275 (|of_nat$| ?x21)))
-(let (($x611 (>= ?x275 10)))
-(let (($x330 (ite $x611 $x328 (= ?x22 ?x21))))
-(let ((@x371 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 4 4) (or $x611 (not $x552) (not $x571) (not $x492))) @x397 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x473) $x552)) @x393 $x552) @x411 $x611)))
-(let ((@x372 (|unit-resolution| (|def-axiom| (or (not $x330) (not $x611) $x328)) @x371 (|unit-resolution| ((_ |quant-inst| (|nat$| ?x20)) (or (not $x637) $x330)) @x642 $x330) $x328)))
-(let (($x26 (not (= ?x22 ?x24))))
-(|unit-resolution| (mp (asserted $x26) (|rewrite*| (= $x26 $x26)) $x26) (trans (trans @x372 @x374 (= ?x22 ?x496)) @x421 (= ?x22 ?x24)) false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
+(let (($x9 (< ?x7 10)))
+(let ((?x72 (ite $x9 ?0 ?x69)))
+(let ((@x87 (monotonicity (rewrite (= $x9 (not (>= ?x7 10)))) (= ?x72 (ite (not (>= ?x7 10)) ?0 ?x69)))))
+(let ((@x92 (trans @x87 (rewrite (= (ite (not (>= ?x7 10)) ?0 ?x69) ?x88)) (= ?x72 ?x88))))
+(let ((@x98 (|quant-intro| (monotonicity @x92 (= (= ?x6 ?x72) $x93)) (= $x78 $x96))))
+(let (($x75 (= ?x6 ?x72)))
+(let ((@x68 (monotonicity (rewrite (= (- ?x7 10) (+ (~ 10) ?x7))) (= (|nat$| (- ?x7 10)) (|nat$| (+ (~ 10) ?x7))))))
+(let ((@x74 (monotonicity (monotonicity @x68 (= (|dec_10$| (|nat$| (- ?x7 10))) ?x69)) (= (ite $x9 ?0 (|dec_10$| (|nat$| (- ?x7 10)))) ?x72))))
+(let ((@x77 (monotonicity @x74 (= (= ?x6 (ite $x9 ?0 (|dec_10$| (|nat$| (- ?x7 10))))) $x75))))
+(let ((@x101 (mp (asserted $x15) (trans (|quant-intro| @x77 (= $x15 $x78)) @x98 (= $x15 $x96)) $x96)))
+(let ((@x180 (mp (|mp~| @x101 (|nnf-pos| (refl (|~| $x93 $x93)) (|~| $x96 $x96)) $x96) (|quant-intro| (refl (= $x93 $x93)) (= $x96 $x175)) $x175)))
+(let (($x209 (not $x175)))
+(let (($x400 (or $x209 $x397)))
+(let ((@x401 ((_ |quant-inst| (|nat$| 6)) $x400)))
+(let ((?x200 (|of_nat$| ?x17)))
+(let ((?x383 (* (~ 1) ?x200)))
+(let ((?x384 (+ ?x19 ?x383)))
+(let (($x385 (<= ?x384 0)))
+(let (($x382 (= ?x19 ?x200)))
+(let ((?x202 (+ (~ 10) ?x200)))
+(let ((?x203 (|nat$| ?x202)))
+(let ((?x204 (|dec_10$| ?x203)))
+(let (($x201 (>= ?x200 10)))
+(let ((?x205 (ite $x201 ?x204 ?x17)))
+(let (($x213 (= ?x17 ?x205)))
+(let (($x214 (not $x201)))
+(let (($x284 (<= ?x200 4)))
+(let (($x256 (= ?x200 4)))
+(let (($x275 (or $x274 $x256)))
+(let ((@x259 (rewrite (= (>= 4 0) true))))
+(let ((@x266 (trans (monotonicity @x259 (= (not (>= 4 0)) (not true))) (rewrite (= (not true) false)) (= (not (>= 4 0)) false))))
+(let ((@x269 (monotonicity @x266 (= (or (not (>= 4 0)) $x256) (or false $x256)))))
+(let ((@x273 (trans @x269 (rewrite (= (or false $x256) $x256)) (= (or (not (>= 4 0)) $x256) $x256))))
+(let ((@x279 (monotonicity @x273 (= (or $x274 (or (not (>= 4 0)) $x256)) $x275))))
+(let ((@x282 (trans @x279 (rewrite (= $x275 $x275)) (= (or $x274 (or (not (>= 4 0)) $x256)) $x275))))
+(let ((@x283 (mp ((_ |quant-inst| 4) (or $x274 (or (not (>= 4 0)) $x256))) @x282 $x275)))
+(let ((@x433 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x256) $x284)) (|unit-resolution| @x283 @x193 $x256) $x284)))
+(let ((@x438 (|unit-resolution| (|def-axiom| (or $x201 $x213)) (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x284) $x214)) @x433 $x214) $x213)))
+(let (($x206 (= ?x18 ?x205)))
+(let (($x210 (or $x209 $x206)))
+(let ((@x211 ((_ |quant-inst| (|nat$| 4)) $x210)))
+(let ((@x443 (trans (|unit-resolution| @x211 @x180 $x206) (symm @x438 (= ?x205 ?x17)) (= ?x18 ?x17))))
+(let ((@x448 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x382) $x385)) (monotonicity @x443 $x382) $x385)))
+(let (($x386 (>= ?x384 0)))
+(let ((@x451 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x382) $x386)) (monotonicity @x443 $x382) $x386)))
+(let (($x285 (>= ?x200 4)))
+(let ((@x454 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x256) $x285)) (|unit-resolution| @x283 @x193 $x256) $x285)))
+(let ((?x207 (|of_nat$| ?x21)))
+(let ((?x309 (* (~ 1) ?x207)))
+(let ((?x310 (+ ?x20 ?x309)))
+(let (($x325 (<= ?x310 0)))
+(let (($x307 (= ?x310 0)))
+(let (($x299 (>= ?x19 0)))
+(let ((@x459 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1) (or $x299 (not $x285) (not $x386))) @x454 @x451 $x299)))
+(let (($x302 (not $x299)))
+(let (($x311 (or $x302 $x307)))
+(let (($x314 (or $x274 $x302 $x307)))
+(let (($x297 (= ?x207 ?x20)))
+(let (($x295 (>= ?x20 0)))
+(let (($x296 (not $x295)))
+(let (($x298 (or $x296 $x297)))
+(let (($x315 (or $x274 $x298)))
+(let ((@x313 (monotonicity (monotonicity (rewrite (= $x295 $x299)) (= $x296 $x302)) (rewrite (= $x297 $x307)) (= $x298 $x311))))
+(let ((@x323 (trans (monotonicity @x313 (= $x315 (or $x274 $x311))) (rewrite (= (or $x274 $x311) $x314)) (= $x315 $x314))))
+(let ((@x324 (mp ((_ |quant-inst| (* 4 ?x19)) $x315) @x323 $x314)))
+(let ((@x465 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x307) $x325)) (|unit-resolution| (|unit-resolution| @x324 @x193 $x311) @x459 $x307) $x325)))
+(let (($x326 (>= ?x310 0)))
+(let ((@x468 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x307) $x326)) (|unit-resolution| (|unit-resolution| @x324 @x193 $x311) @x459 $x307) $x326)))
+(let ((@x472 (monotonicity ((_ |th-lemma| arith eq-propagate 1 1 -4 -4 -4 -4) @x468 @x465 @x454 @x433 @x451 @x448 (= (+ (~ 10) ?x207) 6)) (= (|nat$| (+ (~ 10) ?x207)) ?x24))))
+(let ((?x219 (+ (~ 10) ?x207)))
+(let ((?x220 (|nat$| ?x219)))
+(let ((?x221 (|dec_10$| ?x220)))
+(let (($x208 (>= ?x207 10)))
+(let ((?x222 (ite $x208 ?x221 ?x21)))
+(let (($x228 (= ?x221 ?x222)))
+(let ((@x476 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 4 4) (or $x208 (not $x325) (not $x285) (not $x386))) @x454 @x465 @x451 $x208)))
+(let ((@x480 (symm (|unit-resolution| (|def-axiom| (or (not $x208) $x228)) @x476 $x228) (= ?x222 ?x221))))
+(let (($x223 (= ?x22 ?x222)))
+(let (($x226 (or $x209 $x223)))
+(let ((@x227 ((_ |quant-inst| (|nat$| ?x20)) $x226)))
+(let ((@x488 (trans (trans (|unit-resolution| @x227 @x180 $x223) @x480 (= ?x22 ?x221)) (monotonicity @x472 (= ?x221 ?x389)) (= ?x22 ?x389))))
+(let ((@x491 (trans (trans @x488 (|unit-resolution| @x401 @x180 $x397) (= ?x22 ?x396)) (symm @x427 (= ?x396 ?x24)) $x25)))
+(let (($x26 (not $x25)))
+(let ((@x102 (asserted $x26)))
+(|unit-resolution| @x102 @x491 false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
 
-b6d06ee5e346cf098143de9de1b69fb576a485c2 289 0
+a25b64a8f04cffe57bd9a525d4bad154c19d2b20 310 0
 unsat
 ((set-logic <null>)
 (proof
+(let ((?x42 (|map$| |uu$| |xs$|)))
+(let ((?x43 (|eval_dioph$| |ks$| ?x42)))
+(let ((?x145 (* (~ 1) ?x43)))
+(let ((?x146 (+ |l$| ?x145)))
+(let ((?x149 (|div$| ?x146 2)))
+(let ((?x47 (|map$| |uua$| |xs$|)))
+(let ((?x48 (|eval_dioph$| |ks$| ?x47)))
+(let ((?x769 (+ ?x48 (* (~ 1) ?x149))))
+(let (($x771 (>= ?x769 0)))
+(let ((?x452 (* (~ 1) |l$|)))
+(let ((?x39 (|eval_dioph$| |ks$| |xs$|)))
+(let ((?x776 (+ ?x39 ?x452)))
+(let (($x778 (>= ?x776 0)))
+(let (($x41 (= ?x39 |l$|)))
+(let (($x152 (= ?x48 ?x149)))
+(let (($x362 (not $x152)))
 (let ((?x45 (|mod$| |l$| 2)))
-(let ((?x43 (|eval_dioph$| |ks$| (|map$| |uu$| |xs$|))))
 (let ((?x44 (|mod$| ?x43 2)))
 (let (($x46 (= ?x44 ?x45)))
-(let ((?x39 (|eval_dioph$| |ks$| |xs$|)))
-(let (($x41 (= ?x39 |l$|)))
-(let ((?x116 (* (~ 1) ?x43)))
-(let ((?x117 (+ |l$| ?x116)))
-(let ((?x120 (|div$| ?x117 2)))
-(let ((?x48 (|eval_dioph$| |ks$| (|map$| |uua$| |xs$|))))
-(let (($x123 (= ?x48 ?x120)))
-(let (($x338 (not $x123)))
-(let (($x337 (not $x46)))
-(let (($x339 (or $x337 $x338)))
-(let ((?x686 (|mod$| ?x39 2)))
-(let ((?x441 (* (~ 1) ?x686)))
-(let ((?x678 (* (~ 1) (mod |l$| 2))))
-(let ((?x946 (+ |l$| ?x45 (* (~ 1) (div ?x39 2)) (* (~ 1) (div |l$| 2)) ?x678 ?x441)))
-(let (($x864 (<= (+ ?x45 ?x441) 0)))
-(let (($x796 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(!(= (|mod$| (|eval_dioph$| ?v0 ?v1) 2) (|mod$| (|eval_dioph$| ?v0 (|map$| |uu$| ?v1)) 2)) :pattern ( (|eval_dioph$| ?v0 (|map$| |uu$| ?v1)) )))
+(let (($x361 (not $x46)))
+(let (($x363 (or $x361 $x362)))
+(let ((?x730 (div ?x43 2)))
+(let ((?x913 (* (~ 1) ?x730)))
+(let ((?x685 (mod ?x43 2)))
+(let ((?x712 (* (~ 1) ?x685)))
+(let ((?x645 (div |l$| 2)))
+(let ((?x671 (* (~ 1) ?x645)))
+(let ((?x599 (mod |l$| 2)))
+(let ((?x626 (* (~ 1) ?x599)))
+(let ((?x656 (* (~ 1) ?x48)))
+(let (($x737 (>= (+ |l$| ?x44 ?x656 ?x626 ?x671 ?x712 ?x913) 1)))
+(let ((?x658 (* (~ 2) ?x645)))
+(let ((?x659 (+ |l$| ?x626 ?x658)))
+(let (($x657 (= ?x659 0)))
+(let ((@x108 (|true-axiom| true)))
+(let ((@x945 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x657) (>= ?x659 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x657)) @x108 $x657) (>= ?x659 0))))
+(let ((?x627 (+ ?x45 ?x626)))
+(let (($x628 (= ?x627 0)))
+(let (($x418 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x83 (mod ?v0 ?v1)))
+(let ((?x230 (* (~ 1) ?v1)))
+(let ((?x227 (* (~ 1) ?v0)))
+(let ((?x273 (mod ?x227 ?x230)))
+(let ((?x279 (* (~ 1) ?x273)))
+(let (($x248 (<= ?v1 0)))
+(let ((?x299 (ite $x248 ?x279 ?x83)))
+(let (($x72 (= ?v1 0)))
+(let ((?x304 (ite $x72 ?v0 ?x299)))
+(let ((?x82 (|mod$| ?v0 ?v1)))
+(= ?x82 ?x304))))))))))) :pattern ( (|mod$| ?v0 ?v1) )))
+))
+(let (($x310 (forall ((?v0 Int) (?v1 Int) )(let ((?x83 (mod ?v0 ?v1)))
+(let ((?x230 (* (~ 1) ?v1)))
+(let ((?x227 (* (~ 1) ?v0)))
+(let ((?x273 (mod ?x227 ?x230)))
+(let ((?x279 (* (~ 1) ?x273)))
+(let (($x248 (<= ?v1 0)))
+(let ((?x299 (ite $x248 ?x279 ?x83)))
+(let (($x72 (= ?v1 0)))
+(let ((?x304 (ite $x72 ?v0 ?x299)))
+(let ((?x82 (|mod$| ?v0 ?v1)))
+(= ?x82 ?x304))))))))))))
+))
+(let ((?x83 (mod ?1 ?0)))
+(let ((?x230 (* (~ 1) ?0)))
+(let ((?x227 (* (~ 1) ?1)))
+(let ((?x273 (mod ?x227 ?x230)))
+(let ((?x279 (* (~ 1) ?x273)))
+(let (($x248 (<= ?0 0)))
+(let ((?x299 (ite $x248 ?x279 ?x83)))
+(let (($x72 (= ?0 0)))
+(let ((?x304 (ite $x72 ?1 ?x299)))
+(let ((?x82 (|mod$| ?1 ?0)))
+(let (($x307 (= ?x82 ?x304)))
+(let (($x89 (forall ((?v0 Int) (?v1 Int) )(let (($x72 (= ?v1 0)))
+(let ((?x87 (ite $x72 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
+(let ((?x82 (|mod$| ?v0 ?v1)))
+(= ?x82 ?x87)))))
+))
+(let (($x293 (forall ((?v0 Int) (?v1 Int) )(let ((?x230 (* (~ 1) ?v1)))
+(let ((?x227 (* (~ 1) ?v0)))
+(let ((?x273 (mod ?x227 ?x230)))
+(let ((?x279 (* (~ 1) ?x273)))
+(let ((?x83 (mod ?v0 ?v1)))
+(let (($x73 (< 0 ?v1)))
+(let ((?x284 (ite $x73 ?x83 ?x279)))
+(let (($x72 (= ?v1 0)))
+(let ((?x287 (ite $x72 ?v0 ?x284)))
+(let ((?x82 (|mod$| ?v0 ?v1)))
+(= ?x82 ?x287))))))))))))
+))
+(let ((@x298 (monotonicity (rewrite (= (< 0 ?0) (not $x248))) (= (ite (< 0 ?0) ?x83 ?x279) (ite (not $x248) ?x83 ?x279)))))
+(let ((@x303 (trans @x298 (rewrite (= (ite (not $x248) ?x83 ?x279) ?x299)) (= (ite (< 0 ?0) ?x83 ?x279) ?x299))))
+(let ((@x306 (monotonicity @x303 (= (ite $x72 ?1 (ite (< 0 ?0) ?x83 ?x279)) ?x304))))
+(let ((@x309 (monotonicity @x306 (= (= ?x82 (ite $x72 ?1 (ite (< 0 ?0) ?x83 ?x279))) $x307))))
+(let (($x73 (< 0 ?0)))
+(let ((?x284 (ite $x73 ?x83 ?x279)))
+(let ((?x287 (ite $x72 ?1 ?x284)))
+(let (($x290 (= ?x82 ?x287)))
+(let (($x291 (= (= ?x82 (ite $x72 ?1 (ite $x73 ?x83 (- (mod (- ?1) (- ?0)))))) $x290)))
+(let ((@x275 (monotonicity (rewrite (= (- ?1) ?x227)) (rewrite (= (- ?0) ?x230)) (= (mod (- ?1) (- ?0)) ?x273))))
+(let ((@x283 (trans (monotonicity @x275 (= (- (mod (- ?1) (- ?0))) (- ?x273))) (rewrite (= (- ?x273) ?x279)) (= (- (mod (- ?1) (- ?0))) ?x279))))
+(let ((@x286 (monotonicity @x283 (= (ite $x73 ?x83 (- (mod (- ?1) (- ?0)))) ?x284))))
+(let ((@x289 (monotonicity @x286 (= (ite $x72 ?1 (ite $x73 ?x83 (- (mod (- ?1) (- ?0))))) ?x287))))
+(let ((@x314 (trans (|quant-intro| (monotonicity @x289 $x291) (= $x89 $x293)) (|quant-intro| @x309 (= $x293 $x310)) (= $x89 $x310))))
+(let ((@x360 (|mp~| (mp (asserted $x89) @x314 $x310) (|nnf-pos| (refl (|~| $x307 $x307)) (|~| $x310 $x310)) $x310)))
+(let ((@x423 (mp @x360 (|quant-intro| (refl (= $x307 $x307)) (= $x310 $x418)) $x418)))
+(let (($x633 (not $x418)))
+(let (($x634 (or $x633 $x628)))
+(let (($x440 (<= 2 0)))
+(let ((?x600 (ite $x440 (* (~ 1) (mod ?x452 (* (~ 1) 2))) ?x599)))
+(let (($x439 (= 2 0)))
+(let ((?x601 (ite $x439 |l$| ?x600)))
+(let (($x602 (= ?x45 ?x601)))
+(let ((@x457 (rewrite (= (* (~ 1) 2) (~ 2)))))
+(let ((@x608 (monotonicity (monotonicity @x457 (= (mod ?x452 (* (~ 1) 2)) (mod ?x452 (~ 2)))) (= (* (~ 1) (mod ?x452 (* (~ 1) 2))) (* (~ 1) (mod ?x452 (~ 2)))))))
+(let ((@x451 (rewrite (= $x440 false))))
+(let ((@x611 (monotonicity @x451 @x608 (= ?x600 (ite false (* (~ 1) (mod ?x452 (~ 2))) ?x599)))))
+(let ((@x615 (trans @x611 (rewrite (= (ite false (* (~ 1) (mod ?x452 (~ 2))) ?x599) ?x599)) (= ?x600 ?x599))))
+(let ((@x449 (rewrite (= $x439 false))))
+(let ((@x622 (trans (monotonicity @x449 @x615 (= ?x601 (ite false |l$| ?x599))) (rewrite (= (ite false |l$| ?x599) ?x599)) (= ?x601 ?x599))))
+(let ((@x632 (trans (monotonicity @x622 (= $x602 (= ?x45 ?x599))) (rewrite (= (= ?x45 ?x599) $x628)) (= $x602 $x628))))
+(let ((@x641 (trans (monotonicity @x632 (= (or $x633 $x602) $x634)) (rewrite (= $x634 $x634)) (= (or $x633 $x602) $x634))))
+(let ((@x950 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x628) (>= ?x627 0))) (|unit-resolution| (mp ((_ |quant-inst| |l$| 2) (or $x633 $x602)) @x641 $x634) @x423 $x628) (>= ?x627 0))))
+(let (($x1021 (not $x778)))
+(let (($x777 (<= ?x776 0)))
+(let (($x770 (<= ?x769 0)))
+(let (($x364 (not $x363)))
+(let ((@x741 (hypothesis $x364)))
+(let ((@x1018 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x362 $x770)) (|unit-resolution| (|def-axiom| (or $x363 $x152)) @x741 $x152) $x770)))
+(let ((?x520 (+ |l$| ?x145 (* (~ 2) (div ?x146 2)) (* (~ 1) (mod (+ |l$| ?x43) 2)))))
+(let (($x517 (= ?x520 0)))
+(let ((@x876 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x517) (>= ?x520 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x517)) @x108 $x517) (>= ?x520 0))))
+(let ((?x584 (* (~ 2) ?x48)))
+(let ((?x585 (+ ?x39 ?x145 ?x584)))
+(let (($x586 (= ?x585 0)))
+(let (($x384 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(!(let ((?x24 (|eval_dioph$| ?v0 ?v1)))
+(let ((?x136 (+ ?x24 (* (~ 1) (|eval_dioph$| ?v0 (|map$| |uu$| ?v1))) (* (~ 2) (|eval_dioph$| ?v0 (|map$| |uua$| ?v1))))))
+(= ?x136 0))) :pattern ( (|eval_dioph$| ?v0 (|map$| |uu$| ?v1)) ) :pattern ( (|eval_dioph$| ?v0 (|map$| |uua$| ?v1)) )))
+))
+(let (($x138 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(let ((?x24 (|eval_dioph$| ?v0 ?v1)))
+(let ((?x136 (+ ?x24 (* (~ 1) (|eval_dioph$| ?v0 (|map$| |uu$| ?v1))) (* (~ 2) (|eval_dioph$| ?v0 (|map$| |uua$| ?v1))))))
+(= ?x136 0))))
+))
+(let ((?x24 (|eval_dioph$| ?1 ?0)))
+(let ((?x136 (+ ?x24 (* (~ 1) (|eval_dioph$| ?1 (|map$| |uu$| ?0))) (* (~ 2) (|eval_dioph$| ?1 (|map$| |uua$| ?0))))))
+(let (($x132 (= ?x136 0)))
+(let (($x36 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(let ((?x24 (|eval_dioph$| ?v0 ?v1)))
+(let ((?x27 (|eval_dioph$| ?v0 (|map$| |uu$| ?v1))))
+(let ((?x34 (+ (* (|eval_dioph$| ?v0 (|map$| |uua$| ?v1)) 2) ?x27)))
+(= ?x34 ?x24)))))
+))
+(let (($x127 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(let ((?x24 (|eval_dioph$| ?v0 ?v1)))
+(let ((?x32 (|eval_dioph$| ?v0 (|map$| |uua$| ?v1))))
+(let ((?x113 (* 2 ?x32)))
+(let ((?x27 (|eval_dioph$| ?v0 (|map$| |uu$| ?v1))))
+(let ((?x119 (+ ?x27 ?x113)))
+(= ?x119 ?x24)))))))
+))
+(let ((?x32 (|eval_dioph$| ?1 (|map$| |uua$| ?0))))
+(let ((?x113 (* 2 ?x32)))
+(let ((?x27 (|eval_dioph$| ?1 (|map$| |uu$| ?0))))
+(let ((?x119 (+ ?x27 ?x113)))
+(let (($x124 (= ?x119 ?x24)))
+(let ((@x118 (monotonicity (rewrite (= (* ?x32 2) ?x113)) (= (+ (* ?x32 2) ?x27) (+ ?x113 ?x27)))))
+(let ((@x123 (trans @x118 (rewrite (= (+ ?x113 ?x27) ?x119)) (= (+ (* ?x32 2) ?x27) ?x119))))
+(let ((@x129 (|quant-intro| (monotonicity @x123 (= (= (+ (* ?x32 2) ?x27) ?x24) $x124)) (= $x36 $x127))))
+(let ((@x142 (trans @x129 (|quant-intro| (rewrite (= $x124 $x132)) (= $x127 $x138)) (= $x36 $x138))))
+(let ((@x335 (|mp~| (mp (asserted $x36) @x142 $x138) (|nnf-pos| (refl (|~| $x132 $x132)) (|~| $x138 $x138)) $x138)))
+(let ((@x389 (mp @x335 (|quant-intro| (refl (= $x132 $x132)) (= $x138 $x384)) $x384)))
+(let ((@x883 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x586) (<= ?x585 0))) (|unit-resolution| ((_ |quant-inst| |ks$| |xs$|) (or (not $x384) $x586)) @x389 $x586) (<= ?x585 0))))
+(let ((?x479 (+ ?x149 (* (~ 1) (div ?x146 2)))))
+(let (($x480 (= ?x479 0)))
+(let (($x411 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x74 (div ?v0 ?v1)))
+(let ((?x230 (* (~ 1) ?v1)))
+(let ((?x227 (* (~ 1) ?v0)))
+(let ((?x233 (div ?x227 ?x230)))
+(let (($x248 (<= ?v1 0)))
+(let ((?x255 (ite $x248 ?x233 ?x74)))
+(let (($x72 (= ?v1 0)))
+(let ((?x71 (|div$| ?v0 ?v1)))
+(= ?x71 (ite $x72 0 ?x255)))))))))) :pattern ( (|div$| ?v0 ?v1) )))
+))
+(let (($x266 (forall ((?v0 Int) (?v1 Int) )(let ((?x74 (div ?v0 ?v1)))
+(let ((?x230 (* (~ 1) ?v1)))
+(let ((?x227 (* (~ 1) ?v0)))
+(let ((?x233 (div ?x227 ?x230)))
+(let (($x248 (<= ?v1 0)))
+(let ((?x255 (ite $x248 ?x233 ?x74)))
+(let (($x72 (= ?v1 0)))
+(let ((?x71 (|div$| ?v0 ?v1)))
+(= ?x71 (ite $x72 0 ?x255)))))))))))
+))
+(let ((?x71 (|div$| ?1 ?0)))
+(let (($x263 (= ?x71 (ite $x72 0 (ite $x248 (div ?x227 ?x230) (div ?1 ?0))))))
+(let (($x81 (forall ((?v0 Int) (?v1 Int) )(let (($x72 (= ?v1 0)))
+(let ((?x79 (ite $x72 0 (ite (< 0 ?v1) (div ?v0 ?v1) (div (- ?v0) (- ?v1))))))
+(let ((?x71 (|div$| ?v0 ?v1)))
+(= ?x71 ?x79)))))
+))
+(let (($x245 (forall ((?v0 Int) (?v1 Int) )(let ((?x230 (* (~ 1) ?v1)))
+(let ((?x227 (* (~ 1) ?v0)))
+(let ((?x233 (div ?x227 ?x230)))
+(let ((?x74 (div ?v0 ?v1)))
+(let (($x73 (< 0 ?v1)))
+(let ((?x236 (ite $x73 ?x74 ?x233)))
+(let (($x72 (= ?v1 0)))
+(let ((?x239 (ite $x72 0 ?x236)))
+(let ((?x71 (|div$| ?v0 ?v1)))
+(= ?x71 ?x239)))))))))))
+))
+(let ((?x233 (div ?x227 ?x230)))
+(let ((?x74 (div ?1 ?0)))
+(let ((?x236 (ite $x73 ?x74 ?x233)))
+(let ((?x239 (ite $x72 0 ?x236)))
+(let (($x242 (= ?x71 ?x239)))
+(let ((@x254 (monotonicity (rewrite (= $x73 (not $x248))) (= ?x236 (ite (not $x248) ?x74 ?x233)))))
+(let ((@x259 (trans @x254 (rewrite (= (ite (not $x248) ?x74 ?x233) (ite $x248 ?x233 ?x74))) (= ?x236 (ite $x248 ?x233 ?x74)))))
+(let ((@x265 (monotonicity (monotonicity @x259 (= ?x239 (ite $x72 0 (ite $x248 ?x233 ?x74)))) (= $x242 $x263))))
+(let (($x243 (= (= ?x71 (ite $x72 0 (ite $x73 ?x74 (div (- ?1) (- ?0))))) $x242)))
+(let ((@x235 (monotonicity (rewrite (= (- ?1) ?x227)) (rewrite (= (- ?0) ?x230)) (= (div (- ?1) (- ?0)) ?x233))))
+(let ((@x241 (monotonicity (monotonicity @x235 (= (ite $x73 ?x74 (div (- ?1) (- ?0))) ?x236)) (= (ite $x72 0 (ite $x73 ?x74 (div (- ?1) (- ?0)))) ?x239))))
+(let ((@x270 (trans (|quant-intro| (monotonicity @x241 $x243) (= $x81 $x245)) (|quant-intro| @x265 (= $x245 $x266)) (= $x81 $x266))))
+(let ((@x355 (|mp~| (mp (asserted $x81) @x270 $x266) (|nnf-pos| (refl (|~| $x263 $x263)) (|~| $x266 $x266)) $x266)))
+(let ((@x416 (mp @x355 (|quant-intro| (refl (= $x263 $x263)) (= $x266 $x411)) $x411)))
+(let (($x486 (or (not $x411) $x480)))
+(let ((?x444 (div ?x146 2)))
+(let ((?x445 (ite $x440 (div (* (~ 1) ?x146) (* (~ 1) 2)) ?x444)))
+(let ((?x446 (ite $x439 0 ?x445)))
+(let (($x447 (= ?x149 ?x446)))
+(let ((@x460 (monotonicity (rewrite (= (* (~ 1) ?x146) (+ ?x452 ?x43))) @x457 (= (div (* (~ 1) ?x146) (* (~ 1) 2)) (div (+ ?x452 ?x43) (~ 2))))))
+(let ((@x463 (monotonicity @x451 @x460 (= ?x445 (ite false (div (+ ?x452 ?x43) (~ 2)) ?x444)))))
+(let ((@x467 (trans @x463 (rewrite (= (ite false (div (+ ?x452 ?x43) (~ 2)) ?x444) ?x444)) (= ?x445 ?x444))))
+(let ((@x474 (trans (monotonicity @x449 @x467 (= ?x446 (ite false 0 ?x444))) (rewrite (= (ite false 0 ?x444) ?x444)) (= ?x446 ?x444))))
+(let ((@x484 (trans (monotonicity @x474 (= $x447 (= ?x149 ?x444))) (rewrite (= (= ?x149 ?x444) $x480)) (= $x447 $x480))))
+(let ((@x493 (trans (monotonicity @x484 (= (or (not $x411) $x447) $x486)) (rewrite (= $x486 $x486)) (= (or (not $x411) $x447) $x486))))
+(let ((@x885 (|unit-resolution| (mp ((_ |quant-inst| (+ |l$| ?x145) 2) (or (not $x411) $x447)) @x493 $x486) @x416 $x480)))
+(let ((@x889 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x480) (<= ?x479 0))) @x885 (<= ?x479 0))))
+(let ((@x892 (|unit-resolution| ((_ |th-lemma| arith) (or false (>= (mod (+ |l$| ?x43) 2) 0))) @x108 (>= (mod (+ |l$| ?x43) 2) 0))))
+(let ((@x893 ((_ |th-lemma| arith farkas 1 -2 -2 -1 1 1) @x892 @x889 (hypothesis $x770) @x883 (hypothesis (not $x777)) @x876 false)))
+(let (($x169 (not $x41)))
+(let (($x370 (= $x41 $x363)))
+(let ((@x369 (monotonicity (rewrite (= (and $x46 $x152) $x364)) (= (= $x169 (and $x46 $x152)) (= $x169 $x364)))))
+(let ((@x374 (trans @x369 (rewrite (= (= $x169 $x364) $x370)) (= (= $x169 (and $x46 $x152)) $x370))))
+(let (($x155 (and $x46 $x152)))
+(let (($x170 (= $x169 $x155)))
+(let (($x53 (= $x41 (and $x46 (= ?x48 (|div$| (- |l$| ?x43) 2))))))
+(let (($x54 (not $x53)))
+(let ((@x151 (monotonicity (rewrite (= (- |l$| ?x43) ?x146)) (= (|div$| (- |l$| ?x43) 2) ?x149))))
+(let ((@x157 (monotonicity (monotonicity @x151 (= (= ?x48 (|div$| (- |l$| ?x43) 2)) $x152)) (= (and $x46 (= ?x48 (|div$| (- |l$| ?x43) 2))) $x155))))
+(let ((@x165 (trans (monotonicity @x157 (= $x53 (= $x41 $x155))) (rewrite (= (= $x41 $x155) (= $x41 $x155))) (= $x53 (= $x41 $x155)))))
+(let ((@x174 (trans (monotonicity @x165 (= $x54 (not (= $x41 $x155)))) (rewrite (= (not (= $x41 $x155)) $x170)) (= $x54 $x170))))
+(let ((@x375 (mp (mp (asserted $x54) @x174 $x170) @x374 $x370)))
+(let ((@x438 (|unit-resolution| (|def-axiom| (or $x169 $x363 (not $x370))) @x375 (or $x169 $x363))))
+(let ((@x1025 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x41 (not $x777) $x1021)) (|unit-resolution| @x438 @x741 $x169) (or (not $x777) $x1021))))
+(let ((@x1026 (|unit-resolution| @x1025 (|unit-resolution| (lemma @x893 (or $x777 (not $x770))) @x1018 $x777) $x1021)))
+(let ((@x1029 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x361 (>= (+ ?x44 (* (~ 1) ?x45)) 0))) (|unit-resolution| (|def-axiom| (or $x363 $x46)) @x741 $x46) (>= (+ ?x44 (* (~ 1) ?x45)) 0))))
+(let ((?x744 (+ ?x43 ?x712 (* (~ 2) ?x730))))
+(let (($x742 (= ?x744 0)))
+(let ((@x1032 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x742) (>= ?x744 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x742)) @x108 $x742) (>= ?x744 0))))
+(let ((?x713 (+ ?x44 ?x712)))
+(let (($x714 (= ?x713 0)))
+(let (($x719 (or $x633 $x714)))
+(let ((?x686 (ite $x440 (* (~ 1) (mod ?x145 (* (~ 1) 2))) ?x685)))
+(let ((?x687 (ite $x439 ?x43 ?x686)))
+(let (($x688 (= ?x44 ?x687)))
+(let ((@x694 (monotonicity (monotonicity @x457 (= (mod ?x145 (* (~ 1) 2)) (mod ?x145 (~ 2)))) (= (* (~ 1) (mod ?x145 (* (~ 1) 2))) (* (~ 1) (mod ?x145 (~ 2)))))))
+(let ((@x697 (monotonicity @x451 @x694 (= ?x686 (ite false (* (~ 1) (mod ?x145 (~ 2))) ?x685)))))
+(let ((@x701 (trans @x697 (rewrite (= (ite false (* (~ 1) (mod ?x145 (~ 2))) ?x685) ?x685)) (= ?x686 ?x685))))
+(let ((@x708 (trans (monotonicity @x449 @x701 (= ?x687 (ite false ?x43 ?x685))) (rewrite (= (ite false ?x43 ?x685) ?x685)) (= ?x687 ?x685))))
+(let ((@x718 (trans (monotonicity @x708 (= $x688 (= ?x44 ?x685))) (rewrite (= (= ?x44 ?x685) $x714)) (= $x688 $x714))))
+(let ((@x726 (trans (monotonicity @x718 (= (or $x633 $x688) $x719)) (rewrite (= $x719 $x719)) (= (or $x633 $x688) $x719))))
+(let ((@x1035 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x714) (>= ?x713 0))) (|unit-resolution| (mp ((_ |quant-inst| (|eval_dioph$| |ks$| ?x42) 2) (or $x633 $x688)) @x726 $x719) @x423 $x714) (>= ?x713 0))))
+(let ((@x992 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x586) (>= ?x585 0))) (|unit-resolution| ((_ |quant-inst| |ks$| |xs$|) (or (not $x384) $x586)) @x389 $x586) (>= ?x585 0))))
+(let ((?x773 (+ ?x44 (* (~ 1) ?x45))))
+(let (($x774 (<= ?x773 0)))
+(let ((@x1010 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x361 $x774)) (|unit-resolution| (|def-axiom| (or $x363 $x46)) @x741 $x46) $x774)))
+(let ((@x1014 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x362 $x771)) (|unit-resolution| (|def-axiom| (or $x363 $x152)) @x741 $x152) $x771)))
+(let ((@x963 (|unit-resolution| ((_ |th-lemma| arith) (or false (not (>= (mod (+ |l$| ?x43) 2) 2)))) @x108 (not (>= (mod (+ |l$| ?x43) 2) 2)))))
+(let ((@x748 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x628) (<= ?x627 0))) (|unit-resolution| (mp ((_ |quant-inst| |l$| 2) (or $x633 $x602)) @x641 $x634) @x423 $x628) (<= ?x627 0))))
+(let ((@x932 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x742) (<= ?x744 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x742)) @x108 $x742) (<= ?x744 0))))
+(let ((@x852 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x657) (<= ?x659 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x657)) @x108 $x657) (<= ?x659 0))))
+(let ((@x937 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x714) (<= ?x713 0))) (|unit-resolution| (mp ((_ |quant-inst| (|eval_dioph$| |ks$| ?x42) 2) (or $x633 $x688)) @x726 $x719) @x423 $x714) (<= ?x713 0))))
+(let ((@x954 (hypothesis $x771)))
+(let ((@x957 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x480) (>= ?x479 0))) @x885 (>= ?x479 0))))
+(let ((@x960 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x517) (<= ?x520 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x517)) @x108 $x517) (<= ?x520 0))))
+(let ((@x515 ((_ |th-lemma| arith farkas 1 -2 -2 -2 1 1 1 1 1 1) @x960 @x957 @x954 (hypothesis $x737) @x937 @x852 @x932 (hypothesis $x774) @x748 @x963 false)))
+(let ((@x1015 (|unit-resolution| (lemma @x515 (or (not $x737) (not $x771) (not $x774))) @x1014 @x1010 (not $x737))))
+(let ((@x1037 (|unit-resolution| @x1015 ((_ |th-lemma| arith) @x992 @x1035 @x1032 @x1029 @x1026 @x950 @x945 $x737) false)))
+(let ((@x1038 (lemma @x1037 $x363)))
+(let ((@x434 (|unit-resolution| (|def-axiom| (or $x41 $x364 (not $x370))) @x375 (or $x41 $x364))))
+(let ((@x1120 (|unit-resolution| @x434 @x1038 $x41)))
+(let ((@x1125 ((_ |th-lemma| arith farkas 2 2 1 1 1 1) (hypothesis (not $x771)) @x889 @x892 @x876 @x883 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x169 $x778)) @x1120 $x778) false)))
+(let ((@x1048 ((_ |th-lemma| arith farkas -1 1 1 -2 -2 1) @x992 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x169 $x777)) @x1120 $x777) @x960 @x957 (hypothesis (not $x770)) @x963 false)))
+(let ((?x587 (|mod$| ?x39 2)))
+(let (($x588 (= ?x587 ?x44)))
+(let (($x377 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(!(= (|mod$| (|eval_dioph$| ?v0 ?v1) 2) (|mod$| (|eval_dioph$| ?v0 (|map$| |uu$| ?v1)) 2)) :pattern ( (|eval_dioph$| ?v0 (|map$| |uu$| ?v1)) )))
 ))
 (let (($x30 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(= (|mod$| (|eval_dioph$| ?v0 ?v1) 2) (|mod$| (|eval_dioph$| ?v0 (|map$| |uu$| ?v1)) 2)))
 ))
-(let (($x29 (= (|mod$| (|eval_dioph$| ?1 ?0) 2) (|mod$| (|eval_dioph$| ?1 (|map$| |uu$| ?0)) 2))))
-(let ((@x300 (|mp~| (asserted $x30) (|nnf-pos| (refl (|~| $x29 $x29)) (|~| $x30 $x30)) $x30)))
-(let ((@x910 (|unit-resolution| ((_ |quant-inst| |ks$| |xs$|) (or (not $x796) (= ?x686 ?x44))) (mp @x300 (|quant-intro| (refl (= $x29 $x29)) (= $x30 $x796)) $x796) (= ?x686 ?x44))))
-(let (($x340 (not $x339)))
-(let ((@x605 (hypothesis $x340)))
-(let ((@x896 (symm (|unit-resolution| (|def-axiom| (or $x339 $x46)) @x605 $x46) (= ?x45 ?x44))))
-(let ((@x1028 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x45 ?x686)) $x864)) (trans @x896 (symm @x910 (= ?x44 ?x686)) (= ?x45 ?x686)) $x864)))
-(let (($x505 (>= (+ ?x48 (* (~ 1) ?x120)) 0)))
-(let ((@x1032 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x338 $x505)) (|unit-resolution| (|def-axiom| (or $x339 $x123)) @x605 $x123) $x505)))
-(let ((@x249 (|true-axiom| true)))
-(let ((@x998 (|unit-resolution| ((_ |th-lemma| arith) (or false (not (>= (mod (+ |l$| ?x43) 2) 2)))) @x249 (not (>= (mod (+ |l$| ?x43) 2) 2)))))
-(let ((?x596 (+ |l$| (* (~ 2) (div |l$| 2)) ?x678)))
-(let (($x637 (= ?x596 0)))
-(let ((@x894 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x637) (<= ?x596 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x637)) @x249 $x637) (<= ?x596 0))))
-(let ((?x660 (+ ?x45 ?x678)))
-(let (($x661 (= ?x660 0)))
-(let (($x838 (forall ((?v0 Int) (?v1 Int) )(!(let (($x172 (<= ?v1 0)))
-(let (($x373 (ite $x172 (= (+ (|mod$| ?v0 ?v1) (mod (* (~ 1) ?v0) (* (~ 1) ?v1))) 0) (= (+ (|mod$| ?v0 ?v1) (* (~ 1) (mod ?v0 ?v1))) 0))))
-(let (($x72 (= ?v1 0)))
-(ite $x72 (= (|mod$| ?v0 ?v1) ?v0) $x373)))) :pattern ( (|mod$| ?v0 ?v1) )))
-))
-(let (($x377 (forall ((?v0 Int) (?v1 Int) )(let (($x172 (<= ?v1 0)))
-(let (($x373 (ite $x172 (= (+ (|mod$| ?v0 ?v1) (mod (* (~ 1) ?v0) (* (~ 1) ?v1))) 0) (= (+ (|mod$| ?v0 ?v1) (* (~ 1) (mod ?v0 ?v1))) 0))))
-(let (($x72 (= ?v1 0)))
-(ite $x72 (= (|mod$| ?v0 ?v1) ?v0) $x373)))))
-))
-(let (($x172 (<= ?0 0)))
-(let (($x373 (ite $x172 (= (+ (|mod$| ?1 ?0) (mod (* (~ 1) ?1) (* (~ 1) ?0))) 0) (= (+ (|mod$| ?1 ?0) (* (~ 1) (mod ?1 ?0))) 0))))
-(let (($x72 (= ?0 0)))
-(let (($x374 (ite $x72 (= (|mod$| ?1 ?0) ?1) $x373)))
-(let (($x228 (forall ((?v0 Int) (?v1 Int) )(let ((?x83 (mod ?v0 ?v1)))
-(let ((?x179 (* (~ 1) ?v1)))
-(let ((?x176 (* (~ 1) ?v0)))
-(let ((?x203 (mod ?x176 ?x179)))
-(let ((?x209 (* (~ 1) ?x203)))
-(let (($x172 (<= ?v1 0)))
-(let ((?x217 (ite $x172 ?x209 ?x83)))
-(let (($x72 (= ?v1 0)))
-(let ((?x82 (|mod$| ?v0 ?v1)))
-(= ?x82 (ite $x72 ?v0 ?x217))))))))))))
-))
-(let ((?x83 (mod ?1 ?0)))
-(let ((?x179 (* (~ 1) ?0)))
-(let ((?x176 (* (~ 1) ?1)))
-(let ((?x203 (mod ?x176 ?x179)))
-(let ((?x209 (* (~ 1) ?x203)))
-(let ((?x217 (ite $x172 ?x209 ?x83)))
-(let ((?x82 (|mod$| ?1 ?0)))
-(let (($x225 (= ?x82 (ite $x72 ?1 ?x217))))
-(let (($x89 (forall ((?v0 Int) (?v1 Int) )(let ((?x85 (- (mod (- ?v0) (- ?v1)))))
-(let ((?x83 (mod ?v0 ?v1)))
-(let (($x73 (< 0 ?v1)))
-(let ((?x86 (ite $x73 ?x83 ?x85)))
-(let (($x72 (= ?v1 0)))
-(let ((?x82 (|mod$| ?v0 ?v1)))
-(= ?x82 (ite $x72 ?v0 ?x86)))))))))
-))
-(let ((?x85 (- (mod (- ?1) (- ?0)))))
-(let (($x73 (< 0 ?0)))
-(let ((?x86 (ite $x73 ?x83 ?x85)))
-(let ((@x205 (monotonicity (rewrite (= (- ?1) ?x176)) (rewrite (= (- ?0) ?x179)) (= (mod (- ?1) (- ?0)) ?x203))))
-(let ((@x213 (trans (monotonicity @x205 (= ?x85 (- ?x203))) (rewrite (= (- ?x203) ?x209)) (= ?x85 ?x209))))
-(let ((@x216 (monotonicity (rewrite (= $x73 (not $x172))) @x213 (= ?x86 (ite (not $x172) ?x83 ?x209)))))
-(let ((@x221 (trans @x216 (rewrite (= (ite (not $x172) ?x83 ?x209) ?x217)) (= ?x86 ?x217))))
-(let ((@x227 (monotonicity (monotonicity @x221 (= (ite $x72 ?1 ?x86) (ite $x72 ?1 ?x217))) (= (= ?x82 (ite $x72 ?1 ?x86)) $x225))))
-(let ((@x336 (|mp~| (mp (asserted $x89) (|quant-intro| @x227 (= $x89 $x228)) $x228) (|nnf-pos| (refl (|~| $x225 $x225)) (|~| $x228 $x228)) $x228)))
-(let ((@x380 (mp @x336 (|quant-intro| (rewrite (= $x225 $x374)) (= $x228 $x377)) $x377)))
-(let (($x584 (not $x838)))
-(let (($x643 (or $x584 $x661)))
-(let (($x448 (<= 2 0)))
-(let (($x662 (ite $x448 (= (+ ?x45 (mod (* (~ 1) |l$|) (* (~ 1) 2))) 0) $x661)))
-(let (($x784 (= 2 0)))
-(let (($x663 (ite $x784 (= ?x45 |l$|) $x662)))
-(let (($x650 (= (ite false (= (+ ?x45 (mod (* (~ 1) |l$|) (~ 2))) 0) $x661) $x661)))
-(let (($x648 (= $x662 (ite false (= (+ ?x45 (mod (* (~ 1) |l$|) (~ 2))) 0) $x661))))
-(let (($x640 (= (= (+ ?x45 (mod (* (~ 1) |l$|) (* (~ 1) 2))) 0) (= (+ ?x45 (mod (* (~ 1) |l$|) (~ 2))) 0))))
-(let (($x668 (= (+ ?x45 (mod (* (~ 1) |l$|) (* (~ 1) 2))) (+ ?x45 (mod (* (~ 1) |l$|) (~ 2))))))
-(let ((@x780 (rewrite (= (* (~ 1) 2) (~ 2)))))
-(let ((@x666 (monotonicity @x780 (= (mod (* (~ 1) |l$|) (* (~ 1) 2)) (mod (* (~ 1) |l$|) (~ 2))))))
-(let ((@x777 (rewrite (= $x448 false))))
-(let ((@x653 (trans (monotonicity @x777 (monotonicity (monotonicity @x666 $x668) $x640) $x648) (rewrite $x650) (= $x662 $x661))))
-(let ((@x775 (rewrite (= $x784 false))))
-(let ((@x642 (trans (monotonicity @x775 @x653 (= $x663 (ite false (= ?x45 |l$|) $x661))) (rewrite (= (ite false (= ?x45 |l$|) $x661) $x661)) (= $x663 $x661))))
-(let ((@x617 (trans (monotonicity @x642 (= (or $x584 $x663) $x643)) (rewrite (= $x643 $x643)) (= (or $x584 $x663) $x643))))
-(let ((@x968 (|unit-resolution| (mp ((_ |quant-inst| |l$| 2) (or $x584 $x663)) @x617 $x643) (mp @x380 (|quant-intro| (refl (= $x374 $x374)) (= $x377 $x838)) $x838) $x661)))
-(let ((@x899 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x661) (<= ?x660 0))) @x968 (<= ?x660 0))))
-(let ((?x442 (+ (mod ?x39 2) ?x441)))
-(let (($x443 (= ?x442 0)))
-(let (($x413 (or $x584 $x443)))
-(let (($x485 (= (+ ?x686 (* (~ 1) (mod ?x39 2))) 0)))
-(let (($x486 (ite $x448 (= (+ ?x686 (mod (* (~ 1) ?x39) (* (~ 1) 2))) 0) $x485)))
-(let (($x453 (ite $x784 (= ?x686 ?x39) $x486)))
-(let (($x418 (= (ite false (= (+ (mod (* (~ 1) ?x39) (~ 2)) ?x686) 0) $x443) $x443)))
-(let (($x416 (= $x486 (ite false (= (+ (mod (* (~ 1) ?x39) (~ 2)) ?x686) 0) $x443))))
-(let (($x436 (= (+ ?x686 (* (~ 1) (mod ?x39 2))) (+ (* (~ 1) (mod ?x39 2)) ?x686))))
-(let ((@x440 (monotonicity (rewrite $x436) (= $x485 (= (+ (* (~ 1) (mod ?x39 2)) ?x686) 0)))))
-(let ((@x427 (trans @x440 (rewrite (= (= (+ (* (~ 1) (mod ?x39 2)) ?x686) 0) $x443)) (= $x485 $x443))))
-(let (($x451 (= (= (+ ?x686 (mod (* (~ 1) ?x39) (* (~ 1) 2))) 0) (= (+ (mod (* (~ 1) ?x39) (~ 2)) ?x686) 0))))
-(let ((?x454 (mod (* (~ 1) ?x39) (~ 2))))
-(let ((?x462 (+ ?x454 ?x686)))
-(let ((?x479 (+ ?x686 (mod (* (~ 1) ?x39) (* (~ 1) 2)))))
-(let ((@x461 (monotonicity (monotonicity @x780 (= (mod (* (~ 1) ?x39) (* (~ 1) 2)) ?x454)) (= ?x479 (+ ?x686 ?x454)))))
-(let ((@x430 (monotonicity (trans @x461 (rewrite (= (+ ?x686 ?x454) ?x462)) (= ?x479 ?x462)) $x451)))
-(let ((@x423 (trans (monotonicity @x777 @x430 @x427 $x416) (rewrite $x418) (= $x486 $x443))))
-(let ((@x412 (trans (monotonicity @x775 @x423 (= $x453 (ite false (= ?x686 ?x39) $x443))) (rewrite (= (ite false (= ?x686 ?x39) $x443) $x443)) (= $x453 $x443))))
-(let ((@x405 (trans (monotonicity @x412 (= (or $x584 $x453) $x413)) (rewrite (= $x413 $x413)) (= (or $x584 $x453) $x413))))
-(let ((@x927 (|unit-resolution| (mp ((_ |quant-inst| (|eval_dioph$| |ks$| |xs$|) 2) (or $x584 $x453)) @x405 $x413) (mp @x380 (|quant-intro| (refl (= $x374 $x374)) (= $x377 $x838)) $x838) $x443)))
-(let ((@x1008 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x443) (<= ?x442 0))) @x927 (<= ?x442 0))))
-(let ((?x483 (* (~ 1) (mod ?x39 2))))
-(let ((?x383 (+ ?x39 (* (~ 2) (div ?x39 2)) ?x483)))
-(let (($x395 (= ?x383 0)))
-(let ((@x1015 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x395) (<= ?x383 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x395)) @x249 $x395) (<= ?x383 0))))
-(let ((?x684 (+ ?x39 ?x116 (* (~ 2) ?x48))))
-(let (($x685 (= ?x684 0)))
-(let (($x803 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(!(let ((?x24 (|eval_dioph$| ?v0 ?v1)))
-(let ((?x264 (+ ?x24 (* (~ 1) (|eval_dioph$| ?v0 (|map$| |uu$| ?v1))) (* (~ 2) (|eval_dioph$| ?v0 (|map$| |uua$| ?v1))))))
-(= ?x264 0))) :pattern ( (|eval_dioph$| ?v0 (|map$| |uu$| ?v1)) ) :pattern ( (|eval_dioph$| ?v0 (|map$| |uua$| ?v1)) )))
-))
-(let (($x266 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(let ((?x24 (|eval_dioph$| ?v0 ?v1)))
-(let ((?x264 (+ ?x24 (* (~ 1) (|eval_dioph$| ?v0 (|map$| |uu$| ?v1))) (* (~ 2) (|eval_dioph$| ?v0 (|map$| |uua$| ?v1))))))
-(= ?x264 0))))
-))
-(let ((?x24 (|eval_dioph$| ?1 ?0)))
-(let ((?x264 (+ ?x24 (* (~ 1) (|eval_dioph$| ?1 (|map$| |uu$| ?0))) (* (~ 2) (|eval_dioph$| ?1 (|map$| |uua$| ?0))))))
-(let (($x260 (= ?x264 0)))
-(let (($x111 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(let ((?x24 (|eval_dioph$| ?v0 ?v1)))
-(let ((?x27 (|eval_dioph$| ?v0 (|map$| |uu$| ?v1))))
-(let ((?x32 (|eval_dioph$| ?v0 (|map$| |uua$| ?v1))))
-(let ((?x102 (* 2 ?x32)))
-(let ((?x105 (+ ?x102 ?x27)))
-(= ?x105 ?x24)))))))
-))
-(let (($x256 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(let ((?x24 (|eval_dioph$| ?v0 ?v1)))
-(let ((?x32 (|eval_dioph$| ?v0 (|map$| |uua$| ?v1))))
-(let ((?x102 (* 2 ?x32)))
-(let ((?x27 (|eval_dioph$| ?v0 (|map$| |uu$| ?v1))))
-(= (+ ?x27 ?x102) ?x24))))))
-))
-(let ((?x32 (|eval_dioph$| ?1 (|map$| |uua$| ?0))))
-(let ((?x102 (* 2 ?x32)))
-(let ((?x27 (|eval_dioph$| ?1 (|map$| |uu$| ?0))))
-(let (($x253 (= (+ ?x27 ?x102) ?x24)))
-(let ((@x255 (monotonicity (rewrite (= (+ ?x102 ?x27) (+ ?x27 ?x102))) (= (= (+ ?x102 ?x27) ?x24) $x253))))
-(let ((@x270 (trans (|quant-intro| @x255 (= $x111 $x256)) (|quant-intro| (rewrite (= $x253 $x260)) (= $x256 $x266)) (= $x111 $x266))))
-(let (($x36 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(let ((?x24 (|eval_dioph$| ?v0 ?v1)))
-(let ((?x27 (|eval_dioph$| ?v0 (|map$| |uu$| ?v1))))
-(= (+ (* (|eval_dioph$| ?v0 (|map$| |uua$| ?v1)) 2) ?x27) ?x24))))
-))
-(let ((@x107 (monotonicity (rewrite (= (* ?x32 2) ?x102)) (= (+ (* ?x32 2) ?x27) (+ ?x102 ?x27)))))
-(let ((@x110 (monotonicity @x107 (= (= (+ (* ?x32 2) ?x27) ?x24) (= (+ ?x102 ?x27) ?x24)))))
-(let ((@x271 (mp (mp (asserted $x36) (|quant-intro| @x110 (= $x36 $x111)) $x111) @x270 $x266)))
-(let ((@x808 (mp (|mp~| @x271 (|nnf-pos| (refl (|~| $x260 $x260)) (|~| $x266 $x266)) $x266) (|quant-intro| (refl (= $x260 $x260)) (= $x266 $x803)) $x803)))
-(let ((@x1019 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x685) (>= ?x684 0))) (|unit-resolution| ((_ |quant-inst| |ks$| |xs$|) (or (not $x803) $x685)) @x808 $x685) (>= ?x684 0))))
-(let ((?x435 (+ ?x120 (* (~ 1) (div ?x117 2)))))
-(let (($x771 (= ?x435 0)))
-(let (($x831 (forall ((?v0 Int) (?v1 Int) )(!(let (($x355 (= (+ (|div$| ?v0 ?v1) (* (~ 1) (div (* (~ 1) ?v0) (* (~ 1) ?v1)))) 0)))
-(let (($x172 (<= ?v1 0)))
-(let (($x359 (ite $x172 $x355 (= (+ (|div$| ?v0 ?v1) (* (~ 1) (div ?v0 ?v1))) 0))))
-(let (($x72 (= ?v1 0)))
-(ite $x72 (= (|div$| ?v0 ?v1) 0) $x359))))) :pattern ( (|div$| ?v0 ?v1) )))
-))
-(let (($x363 (forall ((?v0 Int) (?v1 Int) )(let (($x355 (= (+ (|div$| ?v0 ?v1) (* (~ 1) (div (* (~ 1) ?v0) (* (~ 1) ?v1)))) 0)))
-(let (($x172 (<= ?v1 0)))
-(let (($x359 (ite $x172 $x355 (= (+ (|div$| ?v0 ?v1) (* (~ 1) (div ?v0 ?v1))) 0))))
-(let (($x72 (= ?v1 0)))
-(ite $x72 (= (|div$| ?v0 ?v1) 0) $x359))))))
-))
-(let (($x359 (ite $x172 (= (+ (|div$| ?1 ?0) (* (~ 1) (div ?x176 ?x179))) 0) (= (+ (|div$| ?1 ?0) (* (~ 1) (div ?1 ?0))) 0))))
-(let (($x360 (ite $x72 (= (|div$| ?1 ?0) 0) $x359)))
-(let (($x199 (forall ((?v0 Int) (?v1 Int) )(let ((?x74 (div ?v0 ?v1)))
-(let ((?x179 (* (~ 1) ?v1)))
-(let ((?x176 (* (~ 1) ?v0)))
-(let ((?x182 (div ?x176 ?x179)))
-(let (($x172 (<= ?v1 0)))
-(let ((?x188 (ite $x172 ?x182 ?x74)))
-(let (($x72 (= ?v1 0)))
-(let ((?x71 (|div$| ?v0 ?v1)))
-(= ?x71 (ite $x72 0 ?x188)))))))))))
-))
-(let ((?x71 (|div$| ?1 ?0)))
-(let (($x196 (= ?x71 (ite $x72 0 (ite $x172 (div ?x176 ?x179) (div ?1 ?0))))))
-(let (($x81 (forall ((?v0 Int) (?v1 Int) )(let ((?x74 (div ?v0 ?v1)))
-(let (($x73 (< 0 ?v1)))
-(let ((?x78 (ite $x73 ?x74 (div (- ?v0) (- ?v1)))))
-(let (($x72 (= ?v1 0)))
-(let ((?x71 (|div$| ?v0 ?v1)))
-(= ?x71 (ite $x72 0 ?x78))))))))
-))
-(let (($x80 (= ?x71 (ite $x72 0 (ite $x73 (div ?1 ?0) (div (- ?1) (- ?0)))))))
-(let (($x194 (= (ite $x72 0 (ite $x73 (div ?1 ?0) (div (- ?1) (- ?0)))) (ite $x72 0 (ite $x172 (div ?x176 ?x179) (div ?1 ?0))))))
-(let ((?x74 (div ?1 ?0)))
-(let ((?x182 (div ?x176 ?x179)))
-(let ((?x188 (ite $x172 ?x182 ?x74)))
-(let ((?x78 (ite $x73 ?x74 (div (- ?1) (- ?0)))))
-(let ((@x184 (monotonicity (rewrite (= (- ?1) ?x176)) (rewrite (= (- ?0) ?x179)) (= (div (- ?1) (- ?0)) ?x182))))
-(let ((@x187 (monotonicity (rewrite (= $x73 (not $x172))) @x184 (= ?x78 (ite (not $x172) ?x74 ?x182)))))
-(let ((@x192 (trans @x187 (rewrite (= (ite (not $x172) ?x74 ?x182) ?x188)) (= ?x78 ?x188))))
-(let ((@x201 (|quant-intro| (monotonicity (monotonicity @x192 $x194) (= $x80 $x196)) (= $x81 $x199))))
-(let ((@x331 (|mp~| (mp (asserted $x81) @x201 $x199) (|nnf-pos| (refl (|~| $x196 $x196)) (|~| $x199 $x199)) $x199)))
-(let ((@x366 (mp @x331 (|quant-intro| (rewrite (= $x196 $x360)) (= $x199 $x363)) $x363)))
-(let (($x761 (or (not $x831) $x771)))
-(let (($x772 (ite $x448 (= (+ ?x120 (* (~ 1) (div (* (~ 1) ?x117) (* (~ 1) 2)))) 0) $x771)))
-(let (($x773 (ite $x784 (= ?x120 0) $x772)))
-(let (($x495 (ite false (= (+ ?x120 (* (~ 1) (div (+ (* (~ 1) |l$|) ?x43) (~ 2)))) 0) $x771)))
-(let (($x763 (= (= (+ ?x120 (* (~ 1) (div (* (~ 1) ?x117) (* (~ 1) 2)))) 0) (= (+ ?x120 (* (~ 1) (div (+ (* (~ 1) |l$|) ?x43) (~ 2)))) 0))))
-(let (($x490 (= (+ ?x120 (* (~ 1) (div (* (~ 1) ?x117) (* (~ 1) 2)))) (+ ?x120 (* (~ 1) (div (+ (* (~ 1) |l$|) ?x43) (~ 2)))))))
-(let (($x487 (= (* (~ 1) (div (* (~ 1) ?x117) (* (~ 1) 2))) (* (~ 1) (div (+ (* (~ 1) |l$|) ?x43) (~ 2))))))
-(let (($x782 (= (div (* (~ 1) ?x117) (* (~ 1) 2)) (div (+ (* (~ 1) |l$|) ?x43) (~ 2)))))
-(let ((@x768 (monotonicity (rewrite (= (* (~ 1) ?x117) (+ (* (~ 1) |l$|) ?x43))) @x780 $x782)))
-(let ((@x765 (monotonicity @x777 (monotonicity (monotonicity (monotonicity @x768 $x487) $x490) $x763) (= $x772 $x495))))
-(let ((@x756 (monotonicity @x775 (trans @x765 (rewrite (= $x495 $x771)) (= $x772 $x771)) (= $x773 (ite false (= ?x120 0) $x771)))))
-(let ((@x759 (trans @x756 (rewrite (= (ite false (= ?x120 0) $x771) $x771)) (= $x773 $x771))))
-(let ((@x753 (trans (monotonicity @x759 (= (or (not $x831) $x773) $x761)) (rewrite (= $x761 $x761)) (= (or (not $x831) $x773) $x761))))
-(let ((@x881 (|unit-resolution| (mp ((_ |quant-inst| (+ |l$| ?x116) 2) (or (not $x831) $x773)) @x753 $x761) (mp @x366 (|quant-intro| (refl (= $x360 $x360)) (= $x363 $x831)) $x831) $x771)))
-(let ((@x992 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x771) (>= ?x435 0))) @x881 (>= ?x435 0))))
-(let ((?x613 (+ |l$| ?x116 (* (~ 2) (div ?x117 2)) (* (~ 1) (mod (+ |l$| ?x43) 2)))))
-(let (($x735 (= ?x613 0)))
-(let ((@x995 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x735) (<= ?x613 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x735)) @x249 $x735) (<= ?x613 0))))
-(let ((@x1020 ((_ |th-lemma| arith farkas 1 -2 -2 -1 -2 1 1 1 1 1 1) @x995 @x992 (hypothesis $x505) @x1019 (hypothesis (>= ?x946 1)) @x1015 @x1008 (hypothesis $x864) @x899 @x894 @x998 false)))
-(let ((@x1033 (|unit-resolution| (lemma @x1020 (or (not (>= ?x946 1)) (not $x505) (not $x864))) @x1032 @x1028 (not (>= ?x946 1)))))
-(let ((@x972 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x661) (>= ?x660 0))) @x968 (>= ?x660 0))))
-(let ((@x987 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x637) (>= ?x596 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x637)) @x249 $x637) (>= ?x596 0))))
-(let ((@x1036 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x45 ?x686)) (>= (+ ?x45 ?x441) 0))) (trans @x896 (symm @x910 (= ?x44 ?x686)) (= ?x45 ?x686)) (>= (+ ?x45 ?x441) 0))))
-(let ((@x1039 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x443) (>= ?x442 0))) @x927 (>= ?x442 0))))
-(let (($x498 (>= (+ ?x39 (* (~ 1) |l$|)) 0)))
-(let (($x1045 (not $x498)))
-(let (($x497 (<= (+ ?x39 (* (~ 1) |l$|)) 0)))
-(let (($x504 (<= (+ ?x48 (* (~ 1) ?x120)) 0)))
-(let ((@x1042 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x338 $x504)) (|unit-resolution| (|def-axiom| (or $x339 $x123)) @x605 $x123) $x504)))
-(let (($x726 (>= ?x613 0)))
-(let ((@x872 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x735) $x726)) (|unit-resolution| ((_ |th-lemma| arith) (or false $x735)) @x249 $x735) $x726)))
-(let (($x691 (<= ?x684 0)))
-(let ((@x879 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x685) $x691)) (|unit-resolution| ((_ |quant-inst| |ks$| |xs$|) (or (not $x803) $x685)) @x808 $x685) $x691)))
-(let (($x593 (<= ?x435 0)))
-(let ((?x745 (mod (+ |l$| ?x43) 2)))
-(let (($x730 (>= ?x745 0)))
-(let ((@x889 ((_ |th-lemma| arith farkas 1 -2 -2 -1 1 1) (|unit-resolution| ((_ |th-lemma| arith) (or false $x730)) @x249 $x730) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x771) $x593)) @x881 $x593) (hypothesis $x504) @x879 (hypothesis (not $x497)) @x872 false)))
-(let (($x135 (not $x41)))
-(let (($x346 (= $x41 $x339)))
-(let ((@x345 (monotonicity (rewrite (= (and $x46 $x123) $x340)) (= (= $x135 (and $x46 $x123)) (= $x135 $x340)))))
-(let ((@x350 (trans @x345 (rewrite (= (= $x135 $x340) $x346)) (= (= $x135 (and $x46 $x123)) $x346))))
-(let (($x126 (and $x46 $x123)))
-(let (($x136 (= $x135 $x126)))
-(let (($x54 (not (= $x41 (and $x46 (= ?x48 (|div$| (- |l$| ?x43) 2)))))))
-(let (($x130 (= (= $x41 (and $x46 (= ?x48 (|div$| (- |l$| ?x43) 2)))) (= $x41 $x126))))
-(let ((@x122 (monotonicity (rewrite (= (- |l$| ?x43) ?x117)) (= (|div$| (- |l$| ?x43) 2) ?x120))))
-(let ((@x128 (monotonicity (monotonicity @x122 (= (= ?x48 (|div$| (- |l$| ?x43) 2)) $x123)) (= (and $x46 (= ?x48 (|div$| (- |l$| ?x43) 2))) $x126))))
-(let ((@x140 (trans (monotonicity (monotonicity @x128 $x130) (= $x54 (not (= $x41 $x126)))) (rewrite (= (not (= $x41 $x126)) $x136)) (= $x54 $x136))))
-(let ((@x794 (|unit-resolution| (|def-axiom| (or $x135 $x339 (not $x346))) (mp (mp (asserted $x54) @x140 $x136) @x350 $x346) (or $x135 $x339))))
-(let ((@x1049 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x41 (not $x497) $x1045)) (|unit-resolution| @x794 @x605 $x135) (or (not $x497) $x1045))))
-(let ((@x1050 (|unit-resolution| @x1049 (|unit-resolution| (lemma @x889 (or $x497 (not $x504))) @x1042 $x497) $x1045)))
-(let ((@x1053 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x395) (>= ?x383 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x395)) @x249 $x395) (>= ?x383 0))))
-(let ((@x790 (|unit-resolution| (|def-axiom| (or $x41 $x340 (not $x346))) (mp (mp (asserted $x54) @x140 $x136) @x350 $x346) (or $x41 $x340))))
-(let ((@x1123 (|unit-resolution| @x790 (lemma ((_ |th-lemma| arith farkas -1/2 1/2 -1/2 -1/2 -1/2 -1/2 1) @x1053 @x1050 @x1039 @x1036 @x987 @x972 @x1033 false) $x339) $x41)))
-(let ((@x932 (trans (symm @x910 (= ?x44 ?x686)) (monotonicity @x1123 (= ?x686 ?x45)) $x46)))
-(let (($x890 (not $x504)))
-(let ((@x1135 ((_ |th-lemma| arith assign-bounds 1 -1/2 -1/2 1/2 -1/2) (or $x505 (not $x593) (not $x730) (not $x726) (not $x691) $x1045))))
-(let ((@x1136 (|unit-resolution| @x1135 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x771) $x593)) @x881 $x593) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x135 $x498)) @x1123 $x498) @x872 (|unit-resolution| ((_ |th-lemma| arith) (or false $x730)) @x249 $x730) @x879 $x505)))
-(let ((@x1141 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x123 $x890 (not $x505))) (hypothesis $x338) (or $x890 (not $x505)))))
-(let ((@x1143 ((_ |th-lemma| arith farkas -2 -2 1 -1 1 1) (|unit-resolution| @x1141 @x1136 $x890) @x992 @x995 @x1019 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x135 $x497)) @x1123 $x497) @x998 false)))
-(let ((@x575 (|unit-resolution| (|def-axiom| (or $x340 $x337 $x338)) (lemma ((_ |th-lemma| arith farkas -1/2 1/2 -1/2 -1/2 -1/2 -1/2 1) @x1053 @x1050 @x1039 @x1036 @x987 @x972 @x1033 false) $x339) $x339)))
-(|unit-resolution| (|unit-resolution| @x575 (lemma @x1143 $x123) $x337) @x932 false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
+(let (($x29 (= (|mod$| ?x24 2) (|mod$| ?x27 2))))
+(let ((@x330 (|mp~| (asserted $x30) (|nnf-pos| (refl (|~| $x29 $x29)) (|~| $x30 $x30)) $x30)))
+(let ((@x382 (mp @x330 (|quant-intro| (refl (= $x29 $x29)) (= $x30 $x377)) $x377)))
+(let ((@x1104 (symm (|unit-resolution| ((_ |quant-inst| |ks$| |xs$|) (or (not $x377) $x588)) @x382 $x588) (= ?x44 ?x587))))
+(let ((@x763 (|unit-resolution| (hypothesis $x361) (trans @x1104 (monotonicity @x1120 (= ?x587 ?x45)) $x46) false)))
+(let ((@x1050 (|unit-resolution| (|unit-resolution| (|def-axiom| (or $x364 $x361 $x362)) @x1038 $x363) (lemma @x763 $x46) $x362)))
+(|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x152 (not $x770) (not $x771))) @x1050 (lemma @x1048 $x770) (lemma @x1125 $x771) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
 
-4e21a28a63259a50737712606d48d7d4a769c900 46 0
+d4d0e08ac1741a77a8448ec3a55e48fb2a240ee9 62 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let ((?x33 (|sup$| (|collect$| |uu$|))))
+(let ((?x32 (|collect$| |uu$|)))
+(let ((?x33 (|sup$| ?x32)))
 (let (($x38 (|less_eq$| ?x33 ?x33)))
 (let (($x39 (not $x38)))
-(let ((?x35 (|sup$| (|collect$| |uua$|))))
+(let ((@x117 (asserted $x39)))
+(let ((?x34 (|collect$| |uua$|)))
+(let ((?x35 (|sup$| ?x34)))
 (let (($x37 (|less_eq$| ?x35 ?x33)))
+(let ((@x115 (asserted $x37)))
 (let (($x36 (|less_eq$| ?x33 ?x35)))
-(let (($x597 (forall ((?v0 |A$|) (?v1 |A$|) (?v2 |A$|) )(!(let (($x29 (|less_eq$| ?v0 ?v2)))
-(or (not (|less_eq$| ?v0 ?v1)) (not (|less_eq$| ?v1 ?v2)) $x29)) :pattern ( (|less_eq$| ?v0 ?v1) (|less_eq$| ?v1 ?v2) )))
+(let ((@x114 (asserted $x36)))
+(let (($x159 (forall ((?v0 |A$|) (?v1 |A$|) (?v2 |A$|) )(!(let (($x29 (|less_eq$| ?v0 ?v2)))
+(let (($x27 (|less_eq$| ?v1 ?v2)))
+(let (($x136 (not $x27)))
+(let (($x26 (|less_eq$| ?v0 ?v1)))
+(let (($x135 (not $x26)))
+(or $x135 $x136 $x29)))))) :pattern ( (|less_eq$| ?v0 ?v1) (|less_eq$| ?v1 ?v2) )))
 ))
-(let (($x175 (forall ((?v0 |A$|) (?v1 |A$|) (?v2 |A$|) )(let (($x29 (|less_eq$| ?v0 ?v2)))
-(or (not (|less_eq$| ?v0 ?v1)) (not (|less_eq$| ?v1 ?v2)) $x29)))
+(let (($x154 (forall ((?v0 |A$|) (?v1 |A$|) (?v2 |A$|) )(let (($x29 (|less_eq$| ?v0 ?v2)))
+(let (($x27 (|less_eq$| ?v1 ?v2)))
+(let (($x136 (not $x27)))
+(let (($x26 (|less_eq$| ?v0 ?v1)))
+(let (($x135 (not $x26)))
+(or $x135 $x136 $x29)))))))
 ))
-(let ((@x602 (trans (rewrite (= $x175 $x597)) (rewrite (= $x597 $x597)) (= $x175 $x597))))
-(let (($x84 (forall ((?v0 |A$|) (?v1 |A$|) (?v2 |A$|) )(let (($x29 (|less_eq$| ?v0 ?v2)))
+(let (($x29 (|less_eq$| ?2 ?0)))
+(let (($x27 (|less_eq$| ?1 ?0)))
+(let (($x136 (not $x27)))
+(let (($x26 (|less_eq$| ?2 ?1)))
+(let (($x135 (not $x26)))
+(let (($x149 (or $x135 $x136 $x29)))
+(let (($x111 (forall ((?v0 |A$|) (?v1 |A$|) (?v2 |A$|) )(let (($x29 (|less_eq$| ?v0 ?v2)))
 (let (($x27 (|less_eq$| ?v1 ?v2)))
 (let (($x26 (|less_eq$| ?v0 ?v1)))
 (let (($x28 (and $x26 $x27)))
-(let (($x80 (not $x28)))
-(or $x80 $x29)))))))
+(let (($x106 (not $x28)))
+(or $x106 $x29)))))))
 ))
-(let (($x29 (|less_eq$| ?2 ?0)))
-(let (($x170 (or (not (|less_eq$| ?2 ?1)) (not (|less_eq$| ?1 ?0)) $x29)))
-(let (($x27 (|less_eq$| ?1 ?0)))
-(let (($x26 (|less_eq$| ?2 ?1)))
-(let (($x28 (and $x26 $x27)))
-(let (($x80 (not $x28)))
-(let (($x81 (or $x80 $x29)))
-(let (($x156 (or (not $x26) (not $x27))))
-(let ((@x162 (monotonicity (rewrite (= $x28 (not $x156))) (= $x80 (not (not $x156))))))
-(let ((@x169 (monotonicity (trans @x162 (rewrite (= (not (not $x156)) $x156)) (= $x80 $x156)) (= $x81 (or $x156 $x29)))))
-(let ((@x177 (|quant-intro| (trans @x169 (rewrite (= (or $x156 $x29) $x170)) (= $x81 $x170)) (= $x84 $x175))))
+(let ((@x141 (monotonicity (rewrite (= (and $x26 $x27) (not (or $x135 $x136)))) (= (not (and $x26 $x27)) (not (not (or $x135 $x136)))))))
+(let ((@x145 (trans @x141 (rewrite (= (not (not (or $x135 $x136))) (or $x135 $x136))) (= (not (and $x26 $x27)) (or $x135 $x136)))))
+(let ((@x148 (monotonicity @x145 (= (or (not (and $x26 $x27)) $x29) (or (or $x135 $x136) $x29)))))
+(let ((@x153 (trans @x148 (rewrite (= (or (or $x135 $x136) $x29) $x149)) (= (or (not (and $x26 $x27)) $x29) $x149))))
+(let ((@x129 (refl (|~| (or (not (and $x26 $x27)) $x29) (or (not (and $x26 $x27)) $x29)))))
 (let (($x31 (forall ((?v0 |A$|) (?v1 |A$|) (?v2 |A$|) )(let (($x29 (|less_eq$| ?v0 ?v2)))
 (let (($x27 (|less_eq$| ?v1 ?v2)))
 (let (($x26 (|less_eq$| ?v0 ?v1)))
 (let (($x28 (and $x26 $x27)))
 (=> $x28 $x29))))))
 ))
-(let ((@x87 (mp (asserted $x31) (|quant-intro| (rewrite (= (=> $x28 $x29) $x81)) (= $x31 $x84)) $x84)))
-(let ((@x153 (|mp~| (mp @x87 (|rewrite*| (= $x84 $x84)) $x84) (|nnf-pos| (refl (|~| $x81 $x81)) (|~| $x84 $x84)) $x84)))
-(let (($x252 (= (or (not $x597) (or (not $x36) (not $x37) $x38)) (or (not $x597) (not $x36) (not $x37) $x38))))
-(let ((@x589 (mp ((_ |quant-inst| (|sup$| (|collect$| |uu$|)) (|sup$| (|collect$| |uua$|)) (|sup$| (|collect$| |uu$|))) (or (not $x597) (or (not $x36) (not $x37) $x38))) (rewrite $x252) (or (not $x597) (not $x36) (not $x37) $x38))))
-(|unit-resolution| @x589 (mp (mp @x153 @x177 $x175) @x602 $x597) (mp (asserted $x36) (|rewrite*| (= $x36 $x36)) $x36) (mp (asserted $x37) (|rewrite*| (= $x37 $x37)) $x37) (mp (asserted $x39) (|rewrite*| (= $x39 $x39)) $x39) false)))))))))))))))))))))))))))))
+(let ((@x110 (rewrite (= (=> (and $x26 $x27) $x29) (or (not (and $x26 $x27)) $x29)))))
+(let ((@x132 (|mp~| (mp (asserted $x31) (|quant-intro| @x110 (= $x31 $x111)) $x111) (|nnf-pos| @x129 (|~| $x111 $x111)) $x111)))
+(let ((@x164 (mp (mp @x132 (|quant-intro| @x153 (= $x111 $x154)) $x154) (|quant-intro| (refl (= $x149 $x149)) (= $x154 $x159)) $x159)))
+(let (($x166 (not $x37)))
+(let (($x165 (not $x36)))
+(let (($x170 (not $x159)))
+(let (($x171 (or $x170 $x165 $x166 $x38)))
+(let ((@x176 (mp ((_ |quant-inst| (|sup$| ?x32) (|sup$| ?x34) (|sup$| ?x32)) (or $x170 (or $x165 $x166 $x38))) (rewrite (= (or $x170 (or $x165 $x166 $x38)) $x171)) $x171)))
+(|unit-resolution| @x176 @x164 @x114 @x115 @x117 false)))))))))))))))))))))))))))))))))))))
 
-dbbd203b9296b09c05b52742aa274aa3af897311 20 0
+ce2ba5128c1bc3cef10c9328de9b15558b908319 25 0
 unsat
 ((set-logic AUFLIA)
 (proof
-(let (($x52 (not (|pred$e| 1))))
-(let (($x630 (forall ((?v0 Int) )(!(|pred$e| ?v0) :pattern ( (|pred$e| ?v0) )))
+(let (($x51 (|pred$e| 1)))
+(let (($x52 (not $x51)))
+(let ((@x142 (asserted $x52)))
+(let (($x198 (forall ((?v0 Int) )(!(|pred$e| ?v0) :pattern ( (|pred$e| ?v0) )))
 ))
-(let (($x120 (forall ((?v0 Int) )(|pred$e| ?v0))
+(let (($x139 (forall ((?v0 Int) )(|pred$e| ?v0))
 ))
 (let (($x49 (forall ((?v0 Int) )(let (($x47 (or (|pred$d| (|cons$d| ?v0 |nil$d|)) (not (|pred$d| (|cons$d| ?v0 |nil$d|))))))
 (let (($x42 (|pred$e| ?v0)))
@@ -4327,8 +4547,11 @@
 (let (($x42 (|pred$e| ?0)))
 (let (($x47 (or (|pred$d| (|cons$d| ?0 |nil$d|)) (not (|pred$d| (|cons$d| ?0 |nil$d|))))))
 (let (($x48 (and $x42 $x47)))
-(let ((@x115 (monotonicity (rewrite (= $x47 true)) (= $x48 (and $x42 true)))))
-(let ((@x122 (|quant-intro| (trans @x115 (rewrite (= (and $x42 true) $x42)) (= $x48 $x42)) (= $x49 $x120))))
-(let ((@x185 (|mp~| (mp (mp (asserted $x49) @x122 $x120) (|rewrite*| (= $x120 $x120)) $x120) (|nnf-pos| (refl (|~| $x42 $x42)) (|~| $x120 $x120)) $x120)))
-(|unit-resolution| ((_ |quant-inst| 1) (or (not $x630) (|pred$e| 1))) (mp @x185 (|quant-intro| (refl (= $x42 $x42)) (= $x120 $x630)) $x630) (mp (asserted $x52) (|rewrite*| (= $x52 $x52)) $x52) false)))))))))))))
+(let ((@x134 (monotonicity (rewrite (= $x47 true)) (= $x48 (and $x42 true)))))
+(let ((@x141 (|quant-intro| (trans @x134 (rewrite (= (and $x42 true) $x42)) (= $x48 $x42)) (= $x49 $x139))))
+(let ((@x168 (|mp~| (mp (asserted $x49) @x141 $x139) (|nnf-pos| (refl (|~| $x42 $x42)) (|~| $x139 $x139)) $x139)))
+(let ((@x203 (mp @x168 (|quant-intro| (refl (= $x42 $x42)) (= $x139 $x198)) $x198)))
+(let (($x207 (or (not $x198) $x51)))
+(let ((@x208 ((_ |quant-inst| 1) $x207)))
+(|unit-resolution| @x208 @x203 @x142 false))))))))))))))))))
 

--- a/src/HOL/SMT_Examples/SMT_Examples.thy	Thu Mar 13 15:54:41 2014 +0100
+++ b/src/HOL/SMT_Examples/SMT_Examples.thy	Thu Mar 13 16:17:14 2014 +0100
@@ -338,16 +338,16 @@
 lemma "~ (\<exists>x::real. False)" by smt2
 
 lemma "\<exists>x::int. 0 < x"
-  using [[smt2_oracle=true]] (* no Z3 proof *)
-  by smt2
+  using [[smt_oracle=true]] (* no Z3 proof *)
+  by smt (* smt2 FIXME: requires Z3 4.3.1 *)
 
 lemma "\<exists>x::real. 0 < x"
-  using [[smt2_oracle=true]] (* no Z3 proof *)
-  by smt2
+  using [[smt_oracle=true]] (* no Z3 proof *)
+  by smt (* smt2 FIXME: requires Z3 4.3.1 *)
 
 lemma "\<forall>x::int. \<exists>y. y > x"
-  using [[smt2_oracle=true]] (* no Z3 proof *)
-  by smt2
+  using [[smt_oracle=true]] (* no Z3 proof *)
+  by smt (* smt2 FIXME: requires Z3 4.3.1 *)
 
 lemma "\<forall>x y::int. (x = 0 \<and> y = 1) \<longrightarrow> x \<noteq> y" by smt2
 lemma "\<exists>x::int. \<forall>y. x < y \<longrightarrow> y < 0 \<or> y >= 0" by smt2
@@ -355,12 +355,12 @@
 lemma "\<forall>x y::int. (2 * x + 1) \<noteq> (2 * y)" by smt2
 lemma "\<forall>x y::int. x + y > 2 \<or> x + y = 2 \<or> x + y < 2" by smt2
 lemma "\<forall>x::int. if x > 0 then x + 1 > 0 else 1 > x" by smt2
-lemma "if (ALL x::int. x < 0 \<or> x > 0) then False else True" by smt2
-lemma "(if (ALL x::int. x < 0 \<or> x > 0) then -1 else 3) > (0::int)" by smt2
+lemma "if (ALL x::int. x < 0 \<or> x > 0) then False else True"  by smt (* smt2 FIXME: requires Z3 4.3.1 *)
+lemma "(if (ALL x::int. x < 0 \<or> x > 0) then -1 else 3) > (0::int)" by smt (* smt2 FIXME: requires Z3 4.3.1 *)
 lemma "~ (\<exists>x y z::int. 4 * x + -6 * y = (1::int))" by smt2
 lemma "\<exists>x::int. \<forall>x y. 0 < x \<and> 0 < y \<longrightarrow> (0::int) < x + y" by smt2
 lemma "\<exists>u::int. \<forall>(x::int) y::real. 0 < x \<and> 0 < y \<longrightarrow> -1 < x" by smt2
-lemma "\<exists>x::int. (\<forall>y. y \<ge> x \<longrightarrow> y > 0) \<longrightarrow> x > 0" by smt2
+lemma "\<exists>x::int. (\<forall>y. y \<ge> x \<longrightarrow> y > 0) \<longrightarrow> x > 0" by smt (* smt2 FIXME: requires Z3 4.3.1 *)
 lemma "\<forall>x::int. SMT2.trigger [[SMT2.pat x]] (x < a \<longrightarrow> 2 * x < 2 * a)" by smt2
 lemma "\<forall>(a::int) b::int. 0 < b \<or> b < 1" by smt2
 

--- a/src/HOL/SMT_Examples/SMT_Word_Examples.certs2	Thu Mar 13 15:54:41 2014 +0100
+++ b/src/HOL/SMT_Examples/SMT_Word_Examples.certs2	Thu Mar 13 16:17:14 2014 +0100
@@ -1,262 +1,256 @@
-dc8c858f052f26aef8b5074b0928c36cdb77715f 8 0
-unsat
-((set-logic <null>)
-(proof
-(let ((@x17 (monotonicity (rewrite (= (bvneg (_ bv5 4)) (_ bv11 4))) (= (= (_ bv11 4) (bvneg (_ bv5 4))) (= (_ bv11 4) (_ bv11 4))))))
-(let ((@x21 (trans @x17 (rewrite (= (= (_ bv11 4) (_ bv11 4)) true)) (= (= (_ bv11 4) (bvneg (_ bv5 4))) true))))
-(let ((@x28 (trans (monotonicity @x21 (= (not (= (_ bv11 4) (bvneg (_ bv5 4)))) (not true))) (rewrite (= (not true) false)) (= (not (= (_ bv11 4) (bvneg (_ bv5 4)))) false))))
-(mp (asserted (not (= (_ bv11 4) (bvneg (_ bv5 4))))) @x28 false))))))
-
-38ebb1a1c83886ef8d6b0b73826d86887f2423ca 7 0
+d47653c43412ab1eb54730f2f5a4f4bdf44fcb5a 8 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((@x15 (monotonicity (rewrite (= (= (_ bv11 4) (_ bv11 4)) true)) (= (not (= (_ bv11 4) (_ bv11 4))) (not true)))))
-(let ((@x19 (trans @x15 (rewrite (= (not true) false)) (= (not (= (_ bv11 4) (_ bv11 4))) false))))
-(mp (asserted (not (= (_ bv11 4) (_ bv11 4)))) @x19 false)))))
+(let ((@x36 (monotonicity (rewrite (= (bvneg (_ bv5 4)) (_ bv11 4))) (= (= (_ bv11 4) (bvneg (_ bv5 4))) (= (_ bv11 4) (_ bv11 4))))))
+(let ((@x40 (trans @x36 (rewrite (= (= (_ bv11 4) (_ bv11 4)) true)) (= (= (_ bv11 4) (bvneg (_ bv5 4))) true))))
+(let ((@x47 (trans (monotonicity @x40 (= (not (= (_ bv11 4) (bvneg (_ bv5 4)))) (not true))) (rewrite (= (not true) false)) (= (not (= (_ bv11 4) (bvneg (_ bv5 4)))) false))))
+(mp (asserted (not (= (_ bv11 4) (bvneg (_ bv5 4))))) @x47 false))))))
 
-c6d83466054928b78e6689965bb6cebee60c2936 9 0
+da258c2a22a4a00129b43deac09b90d379043340 7 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((@x20 (monotonicity (rewrite (= (bvule (_ bv27 8) (_ bv23 8)) false)) (= (not (bvule (_ bv27 8) (_ bv23 8))) (not false)))))
-(let ((@x24 (trans @x20 (rewrite (= (not false) true)) (= (not (bvule (_ bv27 8) (_ bv23 8))) true))))
-(let ((@x26 (trans (rewrite (= (bvult (_ bv23 8) (_ bv27 8)) (not (bvule (_ bv27 8) (_ bv23 8))))) @x24 (= (bvult (_ bv23 8) (_ bv27 8)) true))))
-(let ((@x33 (trans (monotonicity @x26 (= (not (bvult (_ bv23 8) (_ bv27 8))) (not true))) (rewrite (= (not true) false)) (= (not (bvult (_ bv23 8) (_ bv27 8))) false))))
-(mp (asserted (not (bvult (_ bv23 8) (_ bv27 8)))) @x33 false)))))))
+(let ((@x33 (monotonicity (rewrite (= (= (_ bv11 4) (_ bv11 4)) true)) (= (not (= (_ bv11 4) (_ bv11 4))) (not true)))))
+(let ((@x37 (trans @x33 (rewrite (= (not true) false)) (= (not (= (_ bv11 4) (_ bv11 4))) false))))
+(mp (asserted (not (= (_ bv11 4) (_ bv11 4)))) @x37 false)))))
 
-14d636cdb866e9777d3117e19151ae924c03667c 9 0
+f2b47b92988d2f0c1404b109b621ba9a6c2b9d1c 7 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((@x17 (monotonicity (rewrite (= (bvadd (_ bv27 5) (_ bv11 5)) (_ bv6 5))) (= (= (bvadd (_ bv27 5) (_ bv11 5)) (_ bv6 5)) (= (_ bv6 5) (_ bv6 5))))))
-(let ((@x21 (trans @x17 (rewrite (= (= (_ bv6 5) (_ bv6 5)) true)) (= (= (bvadd (_ bv27 5) (_ bv11 5)) (_ bv6 5)) true))))
-(let ((@x24 (monotonicity @x21 (= (not (= (bvadd (_ bv27 5) (_ bv11 5)) (_ bv6 5))) (not true)))))
-(let ((@x28 (trans @x24 (rewrite (= (not true) false)) (= (not (= (bvadd (_ bv27 5) (_ bv11 5)) (_ bv6 5))) false))))
-(mp (asserted (not (= (bvadd (_ bv27 5) (_ bv11 5)) (_ bv6 5)))) @x28 false)))))))
+(let ((@x36 (monotonicity (rewrite (= (bvult (_ bv23 8) (_ bv27 8)) true)) (= (not (bvult (_ bv23 8) (_ bv27 8))) (not true)))))
+(let ((@x40 (trans @x36 (rewrite (= (not true) false)) (= (not (bvult (_ bv23 8) (_ bv27 8))) false))))
+(mp (asserted (not (bvult (_ bv23 8) (_ bv27 8)))) @x40 false)))))
 
-28e98bcab265918e014391e9f9a849deb0d36844 9 0
+1c22485fb98e3caa4d683df39ead427fc3568432 9 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((@x17 (monotonicity (rewrite (= (bvmul (_ bv7 8) (_ bv3 8)) (_ bv21 8))) (= (= (bvmul (_ bv7 8) (_ bv3 8)) (_ bv21 8)) (= (_ bv21 8) (_ bv21 8))))))
-(let ((@x21 (trans @x17 (rewrite (= (= (_ bv21 8) (_ bv21 8)) true)) (= (= (bvmul (_ bv7 8) (_ bv3 8)) (_ bv21 8)) true))))
-(let ((@x24 (monotonicity @x21 (= (not (= (bvmul (_ bv7 8) (_ bv3 8)) (_ bv21 8))) (not true)))))
-(let ((@x28 (trans @x24 (rewrite (= (not true) false)) (= (not (= (bvmul (_ bv7 8) (_ bv3 8)) (_ bv21 8))) false))))
-(mp (asserted (not (= (bvmul (_ bv7 8) (_ bv3 8)) (_ bv21 8)))) @x28 false)))))))
+(let ((@x36 (monotonicity (rewrite (= (bvadd (_ bv27 5) (_ bv11 5)) (_ bv6 5))) (= (= (bvadd (_ bv27 5) (_ bv11 5)) (_ bv6 5)) (= (_ bv6 5) (_ bv6 5))))))
+(let ((@x40 (trans @x36 (rewrite (= (= (_ bv6 5) (_ bv6 5)) true)) (= (= (bvadd (_ bv27 5) (_ bv11 5)) (_ bv6 5)) true))))
+(let ((@x43 (monotonicity @x40 (= (not (= (bvadd (_ bv27 5) (_ bv11 5)) (_ bv6 5))) (not true)))))
+(let ((@x47 (trans @x43 (rewrite (= (not true) false)) (= (not (= (bvadd (_ bv27 5) (_ bv11 5)) (_ bv6 5))) false))))
+(mp (asserted (not (= (bvadd (_ bv27 5) (_ bv11 5)) (_ bv6 5)))) @x47 false)))))))
 
-23975488836c112224f10c2b57e07b8455ec7fe0 12 0
+651f74a079a4aa15d5d621208d8e038db0369475 9 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((@x25 (monotonicity (rewrite (= (bvmul (_ bv255 8) (_ bv27 8)) (_ bv229 8))) (= (bvadd (_ bv11 8) (bvmul (_ bv255 8) (_ bv27 8))) (bvadd (_ bv11 8) (_ bv229 8))))))
-(let ((@x30 (trans @x25 (rewrite (= (bvadd (_ bv11 8) (_ bv229 8)) (_ bv240 8))) (= (bvadd (_ bv11 8) (bvmul (_ bv255 8) (_ bv27 8))) (_ bv240 8)))))
-(let ((@x32 (trans (rewrite (= (bvsub (_ bv11 8) (_ bv27 8)) (bvadd (_ bv11 8) (bvmul (_ bv255 8) (_ bv27 8))))) @x30 (= (bvsub (_ bv11 8) (_ bv27 8)) (_ bv240 8)))))
-(let ((@x37 (monotonicity @x32 (rewrite (= (bvneg (_ bv16 8)) (_ bv240 8))) (= (= (bvsub (_ bv11 8) (_ bv27 8)) (bvneg (_ bv16 8))) (= (_ bv240 8) (_ bv240 8))))))
-(let ((@x41 (trans @x37 (rewrite (= (= (_ bv240 8) (_ bv240 8)) true)) (= (= (bvsub (_ bv11 8) (_ bv27 8)) (bvneg (_ bv16 8))) true))))
-(let ((@x44 (monotonicity @x41 (= (not (= (bvsub (_ bv11 8) (_ bv27 8)) (bvneg (_ bv16 8)))) (not true)))))
-(let ((@x48 (trans @x44 (rewrite (= (not true) false)) (= (not (= (bvsub (_ bv11 8) (_ bv27 8)) (bvneg (_ bv16 8)))) false))))
-(mp (asserted (not (= (bvsub (_ bv11 8) (_ bv27 8)) (bvneg (_ bv16 8))))) @x48 false))))))))))
+(let ((@x36 (monotonicity (rewrite (= (bvmul (_ bv7 8) (_ bv3 8)) (_ bv21 8))) (= (= (bvmul (_ bv7 8) (_ bv3 8)) (_ bv21 8)) (= (_ bv21 8) (_ bv21 8))))))
+(let ((@x40 (trans @x36 (rewrite (= (= (_ bv21 8) (_ bv21 8)) true)) (= (= (bvmul (_ bv7 8) (_ bv3 8)) (_ bv21 8)) true))))
+(let ((@x43 (monotonicity @x40 (= (not (= (bvmul (_ bv7 8) (_ bv3 8)) (_ bv21 8))) (not true)))))
+(let ((@x47 (trans @x43 (rewrite (= (not true) false)) (= (not (= (bvmul (_ bv7 8) (_ bv3 8)) (_ bv21 8))) false))))
+(mp (asserted (not (= (bvmul (_ bv7 8) (_ bv3 8)) (_ bv21 8)))) @x47 false)))))))
 
-1710061d8b0d577fe2eb77901fef3b9aee0a20f6 7 0
+eefb4f0a8b690f38fb11c31757b3209b40cfd1c5 9 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((@x15 (monotonicity (rewrite (= (= (_ bv11 5) (_ bv11 5)) true)) (= (not (= (_ bv11 5) (_ bv11 5))) (not true)))))
-(let ((@x19 (trans @x15 (rewrite (= (not true) false)) (= (not (= (_ bv11 5) (_ bv11 5))) false))))
-(mp (asserted (not (= (_ bv11 5) (_ bv11 5)))) @x19 false)))))
+(let ((@x41 (monotonicity (rewrite (= (bvsub (_ bv11 8) (_ bv27 8)) (_ bv240 8))) (rewrite (= (bvneg (_ bv16 8)) (_ bv240 8))) (= (= (bvsub (_ bv11 8) (_ bv27 8)) (bvneg (_ bv16 8))) (= (_ bv240 8) (_ bv240 8))))))
+(let ((@x45 (trans @x41 (rewrite (= (= (_ bv240 8) (_ bv240 8)) true)) (= (= (bvsub (_ bv11 8) (_ bv27 8)) (bvneg (_ bv16 8))) true))))
+(let ((@x48 (monotonicity @x45 (= (not (= (bvsub (_ bv11 8) (_ bv27 8)) (bvneg (_ bv16 8)))) (not true)))))
+(let ((@x52 (trans @x48 (rewrite (= (not true) false)) (= (not (= (bvsub (_ bv11 8) (_ bv27 8)) (bvneg (_ bv16 8)))) false))))
+(mp (asserted (not (= (bvsub (_ bv11 8) (_ bv27 8)) (bvneg (_ bv16 8))))) @x52 false)))))))
 
-2454bee77813182e9d40ef80f1da33b7f6491d99 11 0
+e251dcc0ad168cb65c5bc1d32039c72ca2609bb3 7 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((@x21 (monotonicity (rewrite (= (bvneg (_ bv40 7)) (_ bv88 7))) (= (bvadd (bvneg (_ bv40 7)) (_ bv1 7)) (bvadd (_ bv88 7) (_ bv1 7))))))
-(let ((@x26 (trans @x21 (rewrite (= (bvadd (_ bv88 7) (_ bv1 7)) (_ bv89 7))) (= (bvadd (bvneg (_ bv40 7)) (_ bv1 7)) (_ bv89 7)))))
-(let ((@x31 (monotonicity @x26 (rewrite (= (bvneg (_ bv39 7)) (_ bv89 7))) (= (= (bvadd (bvneg (_ bv40 7)) (_ bv1 7)) (bvneg (_ bv39 7))) (= (_ bv89 7) (_ bv89 7))))))
-(let ((@x35 (trans @x31 (rewrite (= (= (_ bv89 7) (_ bv89 7)) true)) (= (= (bvadd (bvneg (_ bv40 7)) (_ bv1 7)) (bvneg (_ bv39 7))) true))))
-(let ((@x38 (monotonicity @x35 (= (not (= (bvadd (bvneg (_ bv40 7)) (_ bv1 7)) (bvneg (_ bv39 7)))) (not true)))))
-(let ((@x42 (trans @x38 (rewrite (= (not true) false)) (= (not (= (bvadd (bvneg (_ bv40 7)) (_ bv1 7)) (bvneg (_ bv39 7)))) false))))
-(mp (asserted (not (= (bvadd (bvneg (_ bv40 7)) (_ bv1 7)) (bvneg (_ bv39 7))))) @x42 false)))))))))
+(let ((@x33 (monotonicity (rewrite (= (= (_ bv11 5) (_ bv11 5)) true)) (= (not (= (_ bv11 5) (_ bv11 5))) (not true)))))
+(let ((@x37 (trans @x33 (rewrite (= (not true) false)) (= (not (= (_ bv11 5) (_ bv11 5))) false))))
+(mp (asserted (not (= (_ bv11 5) (_ bv11 5)))) @x37 false)))))
 
-f91bed7c245df452ab941e5bca3d54c2d6c6e86a 16 0
+4f488dde65b4a70d1d31d589531d3445a9be689f 11 0
+unsat
+((set-logic <null>)
+(proof
+(let ((@x40 (monotonicity (rewrite (= (bvneg (_ bv40 7)) (_ bv88 7))) (= (bvadd (bvneg (_ bv40 7)) (_ bv1 7)) (bvadd (_ bv88 7) (_ bv1 7))))))
+(let ((@x45 (trans @x40 (rewrite (= (bvadd (_ bv88 7) (_ bv1 7)) (_ bv89 7))) (= (bvadd (bvneg (_ bv40 7)) (_ bv1 7)) (_ bv89 7)))))
+(let ((@x50 (monotonicity @x45 (rewrite (= (bvneg (_ bv39 7)) (_ bv89 7))) (= (= (bvadd (bvneg (_ bv40 7)) (_ bv1 7)) (bvneg (_ bv39 7))) (= (_ bv89 7) (_ bv89 7))))))
+(let ((@x54 (trans @x50 (rewrite (= (= (_ bv89 7) (_ bv89 7)) true)) (= (= (bvadd (bvneg (_ bv40 7)) (_ bv1 7)) (bvneg (_ bv39 7))) true))))
+(let ((@x57 (monotonicity @x54 (= (not (= (bvadd (bvneg (_ bv40 7)) (_ bv1 7)) (bvneg (_ bv39 7)))) (not true)))))
+(let ((@x61 (trans @x57 (rewrite (= (not true) false)) (= (not (= (bvadd (bvneg (_ bv40 7)) (_ bv1 7)) (bvneg (_ bv39 7)))) false))))
+(mp (asserted (not (= (bvadd (bvneg (_ bv40 7)) (_ bv1 7)) (bvneg (_ bv39 7))))) @x61 false)))))))))
+
+2e53bd8b513a3dc9dee350d0d8b1c315cf2b2449 19 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((?x12 (bvsub (bvadd (bvadd |a$| (bvmul (_ bv2 32) |b$|)) |c$|) |b$|)))
-(let (($x15 (= ?x12 (bvadd (bvadd |b$| |c$|) |a$|))))
+(let ((?x13 (bvadd |b$| |c$|)))
+(let ((?x14 (bvadd ?x13 |a$|)))
+(let ((?x8 (bvmul (_ bv2 32) |b$|)))
+(let ((?x9 (bvadd |a$| ?x8)))
+(let ((?x11 (bvadd ?x9 |c$|)))
+(let ((?x12 (bvsub ?x11 |b$|)))
+(let (($x15 (= ?x12 ?x14)))
 (let (($x16 (not $x15)))
-(let ((@x45 (rewrite (= (= (bvadd |a$| |b$| |c$|) (bvadd |b$| |c$| |a$|)) true))))
-(let ((?x33 (bvadd |a$| |b$| |c$|)))
-(let ((?x20 (bvadd |a$| (bvmul (_ bv2 32) |b$|) |c$|)))
-(let ((?x28 (bvadd ?x20 (bvmul (_ bv4294967295 32) |b$|))))
-(let ((@x25 (monotonicity (rewrite (= (bvadd (bvadd |a$| (bvmul (_ bv2 32) |b$|)) |c$|) ?x20)) (= ?x12 (bvsub ?x20 |b$|)))))
-(let ((@x37 (trans (trans @x25 (rewrite (= (bvsub ?x20 |b$|) ?x28)) (= ?x12 ?x28)) (rewrite (= ?x28 ?x33)) (= ?x12 ?x33))))
-(let ((@x43 (monotonicity @x37 (rewrite (= (bvadd (bvadd |b$| |c$|) |a$|) (bvadd |b$| |c$| |a$|))) (= $x15 (= ?x33 (bvadd |b$| |c$| |a$|))))))
-(let ((@x50 (monotonicity (trans @x43 @x45 (= $x15 true)) (= $x16 (not true)))))
-(mp (asserted $x16) (trans @x50 (rewrite (= (not true) false)) (= $x16 false)) false))))))))))))))
+(let ((@x56 (rewrite (= (= (bvadd |a$| |b$| |c$|) (bvadd |a$| |b$| |c$|)) true))))
+(let ((@x46 (rewrite (= (bvsub (bvadd |a$| ?x8 |c$|) |b$|) (bvadd |a$| |b$| |c$|)))))
+(let ((@x44 (monotonicity (rewrite (= ?x11 (bvadd |a$| ?x8 |c$|))) (= ?x12 (bvsub (bvadd |a$| ?x8 |c$|) |b$|)))))
+(let ((@x54 (monotonicity (trans @x44 @x46 (= ?x12 (bvadd |a$| |b$| |c$|))) (rewrite (= ?x14 (bvadd |a$| |b$| |c$|))) (= $x15 (= (bvadd |a$| |b$| |c$|) (bvadd |a$| |b$| |c$|))))))
+(let ((@x61 (monotonicity (trans @x54 @x56 (= $x15 true)) (= $x16 (not true)))))
+(let ((@x65 (trans @x61 (rewrite (= (not true) false)) (= $x16 false))))
+(mp (asserted $x16) @x65 false)))))))))))))))))
 
-cc5bd36aa3ac0a29e9a3f76b09b06048d8aad857 14 0
+570be43092e6421d4222501467362afbd680c2e2 18 0
 unsat
 ((set-logic <null>)
 (proof
-(let (($x10 (= (bvmul (_ bv4 4) |x$|) (_ bv4 4))))
-(let (($x7 (= |x$| (_ bv5 4))))
-(let ((@x22 (monotonicity (rewrite (= (=> $x7 $x10) (or (not $x7) $x10))) (= (not (=> $x7 $x10)) (not (or (not $x7) $x10))))))
-(let ((@x24 (|not-or-elim| (mp (asserted (not (=> $x7 $x10))) @x22 (not (or (not $x7) $x10))) $x7)))
-(let ((@x32 (trans (monotonicity @x24 (= (bvmul (_ bv4 4) |x$|) (bvmul (_ bv4 4) (_ bv5 4)))) (rewrite (= (bvmul (_ bv4 4) (_ bv5 4)) (_ bv4 4))) $x10)))
-(let ((@x39 (trans (monotonicity @x32 (= $x10 (= (_ bv4 4) (_ bv4 4)))) (rewrite (= (= (_ bv4 4) (_ bv4 4)) true)) (= $x10 true))))
-(let ((@x46 (trans (monotonicity @x39 (= (not $x10) (not true))) (rewrite (= (not true) false)) (= (not $x10) false))))
-(let (($x25 (not $x10)))
-(let ((@x26 (|not-or-elim| (mp (asserted (not (=> $x7 $x10))) @x22 (not (or (not $x7) $x10))) $x25)))
-(mp @x26 @x46 false))))))))))))
+(let ((?x9 (bvmul (_ bv4 4) |x$|)))
+(let (($x10 (= ?x9 (_ bv4 4))))
+(let (($x41 (= (_ bv5 4) |x$|)))
+(let (($x54 (not (or (not $x41) (= (_ bv4 4) ?x9)))))
+(let ((@x46 (monotonicity (rewrite (= (= |x$| (_ bv5 4)) $x41)) (= (not (= |x$| (_ bv5 4))) (not $x41)))))
+(let ((@x53 (monotonicity @x46 (rewrite (= $x10 (= (_ bv4 4) ?x9))) (= (or (not (= |x$| (_ bv5 4))) $x10) (or (not $x41) (= (_ bv4 4) ?x9))))))
+(let (($x12 (not (=> (= |x$| (_ bv5 4)) $x10))))
+(let ((@x37 (rewrite (= (=> (= |x$| (_ bv5 4)) $x10) (or (not (= |x$| (_ bv5 4))) $x10)))))
+(let ((@x58 (trans (monotonicity @x37 (= $x12 (not (or (not (= |x$| (_ bv5 4))) $x10)))) (monotonicity @x53 (= (not (or (not (= |x$| (_ bv5 4))) $x10)) $x54)) (= $x12 $x54))))
+(let ((@x65 (monotonicity (|not-or-elim| (mp (asserted $x12) @x58 $x54) $x41) (= ?x9 (bvmul (_ bv4 4) (_ bv5 4))))))
+(let ((@x71 (monotonicity (trans @x65 (rewrite (= (bvmul (_ bv4 4) (_ bv5 4)) (_ bv4 4))) $x10) (= (= (_ bv4 4) ?x9) (= (_ bv4 4) (_ bv4 4))))))
+(let ((@x75 (trans @x71 (rewrite (= (= (_ bv4 4) (_ bv4 4)) true)) (= (= (_ bv4 4) ?x9) true))))
+(let ((@x82 (trans (monotonicity @x75 (= (not (= (_ bv4 4) ?x9)) (not true))) (rewrite (= (not true) false)) (= (not (= (_ bv4 4) ?x9)) false))))
+(mp (|not-or-elim| (mp (asserted $x12) @x58 $x54) (not (= (_ bv4 4) ?x9))) @x82 false))))))))))))))))
 
-747da4972d72bf528990da27d234631eff1239e8 13 0
-unsat
-((set-logic <null>)
-(proof
-(let (($x9 (= (bvand (_ bv6 32) (_ bv5 32)) (_ bv4 32))))
-(let ((@x28 (monotonicity (rewrite (= (bvnot (_ bv6 32)) (_ bv4294967289 32))) (rewrite (= (bvnot (_ bv5 32)) (_ bv4294967290 32))) (= (bvor (bvnot (_ bv6 32)) (bvnot (_ bv5 32))) (bvor (_ bv4294967289 32) (_ bv4294967290 32))))))
-(let ((@x33 (trans @x28 (rewrite (= (bvor (_ bv4294967289 32) (_ bv4294967290 32)) (_ bv4294967291 32))) (= (bvor (bvnot (_ bv6 32)) (bvnot (_ bv5 32))) (_ bv4294967291 32)))))
-(let ((@x36 (monotonicity @x33 (= (bvnot (bvor (bvnot (_ bv6 32)) (bvnot (_ bv5 32)))) (bvnot (_ bv4294967291 32))))))
-(let ((@x40 (trans @x36 (rewrite (= (bvnot (_ bv4294967291 32)) (_ bv4 32))) (= (bvnot (bvor (bvnot (_ bv6 32)) (bvnot (_ bv5 32)))) (_ bv4 32)))))
-(let ((@x19 (rewrite (= (bvand (_ bv6 32) (_ bv5 32)) (bvnot (bvor (bvnot (_ bv6 32)) (bvnot (_ bv5 32))))))))
-(let ((@x48 (trans (monotonicity (trans @x19 @x40 $x9) (= $x9 (= (_ bv4 32) (_ bv4 32)))) (rewrite (= (= (_ bv4 32) (_ bv4 32)) true)) (= $x9 true))))
-(let ((@x55 (trans (monotonicity @x48 (= (not $x9) (not true))) (rewrite (= (not true) false)) (= (not $x9) false))))
-(mp (asserted (not $x9)) @x55 false)))))))))))
-
-b63f92eea9e0f63b913d182a0dfd7f2c9a3f2e7a 9 0
+2538d74409c652fbc39d33a15f25d18c9bb179bf 9 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((@x17 (monotonicity (rewrite (= (bvor (_ bv6 8) (_ bv3 8)) (_ bv7 8))) (= (= (bvor (_ bv6 8) (_ bv3 8)) (_ bv7 8)) (= (_ bv7 8) (_ bv7 8))))))
-(let ((@x21 (trans @x17 (rewrite (= (= (_ bv7 8) (_ bv7 8)) true)) (= (= (bvor (_ bv6 8) (_ bv3 8)) (_ bv7 8)) true))))
-(let ((@x24 (monotonicity @x21 (= (not (= (bvor (_ bv6 8) (_ bv3 8)) (_ bv7 8))) (not true)))))
-(let ((@x28 (trans @x24 (rewrite (= (not true) false)) (= (not (= (bvor (_ bv6 8) (_ bv3 8)) (_ bv7 8))) false))))
-(mp (asserted (not (= (bvor (_ bv6 8) (_ bv3 8)) (_ bv7 8)))) @x28 false)))))))
+(let ((@x35 (monotonicity (rewrite (= (bvand (_ bv6 32) (_ bv5 32)) (_ bv4 32))) (= (= (bvand (_ bv6 32) (_ bv5 32)) (_ bv4 32)) (= (_ bv4 32) (_ bv4 32))))))
+(let ((@x39 (trans @x35 (rewrite (= (= (_ bv4 32) (_ bv4 32)) true)) (= (= (bvand (_ bv6 32) (_ bv5 32)) (_ bv4 32)) true))))
+(let ((@x42 (monotonicity @x39 (= (not (= (bvand (_ bv6 32) (_ bv5 32)) (_ bv4 32))) (not true)))))
+(let ((@x46 (trans @x42 (rewrite (= (not true) false)) (= (not (= (bvand (_ bv6 32) (_ bv5 32)) (_ bv4 32))) false))))
+(mp (asserted (not (= (bvand (_ bv6 32) (_ bv5 32)) (_ bv4 32)))) @x46 false)))))))
 
-f7f194a25d0cded05a77a6c86048a6ddbefb22b9 9 0
+ea3351a199ecbca8cfc913892024d6ba767f41dc 9 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((@x17 (monotonicity (rewrite (= (bvxor (_ bv240 8) (_ bv255 8)) (_ bv15 8))) (= (= (bvxor (_ bv240 8) (_ bv255 8)) (_ bv15 8)) (= (_ bv15 8) (_ bv15 8))))))
-(let ((@x21 (trans @x17 (rewrite (= (= (_ bv15 8) (_ bv15 8)) true)) (= (= (bvxor (_ bv240 8) (_ bv255 8)) (_ bv15 8)) true))))
-(let ((@x24 (monotonicity @x21 (= (not (= (bvxor (_ bv240 8) (_ bv255 8)) (_ bv15 8))) (not true)))))
-(let ((@x28 (trans @x24 (rewrite (= (not true) false)) (= (not (= (bvxor (_ bv240 8) (_ bv255 8)) (_ bv15 8))) false))))
-(mp (asserted (not (= (bvxor (_ bv240 8) (_ bv255 8)) (_ bv15 8)))) @x28 false)))))))
+(let ((@x35 (monotonicity (rewrite (= (bvor (_ bv6 8) (_ bv3 8)) (_ bv7 8))) (= (= (bvor (_ bv6 8) (_ bv3 8)) (_ bv7 8)) (= (_ bv7 8) (_ bv7 8))))))
+(let ((@x39 (trans @x35 (rewrite (= (= (_ bv7 8) (_ bv7 8)) true)) (= (= (bvor (_ bv6 8) (_ bv3 8)) (_ bv7 8)) true))))
+(let ((@x42 (monotonicity @x39 (= (not (= (bvor (_ bv6 8) (_ bv3 8)) (_ bv7 8))) (not true)))))
+(let ((@x46 (trans @x42 (rewrite (= (not true) false)) (= (not (= (bvor (_ bv6 8) (_ bv3 8)) (_ bv7 8))) false))))
+(mp (asserted (not (= (bvor (_ bv6 8) (_ bv3 8)) (_ bv7 8)))) @x46 false)))))))
 
-c5cec5c0e82b76412a52558237744e0b82447224 8 0
+a36393e9d24b671ce68aafbd67bbc7bcd4c32a9f 9 0
+unsat
+((set-logic <null>)
+(proof
+(let ((@x35 (monotonicity (rewrite (= (bvxor (_ bv240 8) (_ bv255 8)) (_ bv15 8))) (= (= (bvxor (_ bv240 8) (_ bv255 8)) (_ bv15 8)) (= (_ bv15 8) (_ bv15 8))))))
+(let ((@x39 (trans @x35 (rewrite (= (= (_ bv15 8) (_ bv15 8)) true)) (= (= (bvxor (_ bv240 8) (_ bv255 8)) (_ bv15 8)) true))))
+(let ((@x42 (monotonicity @x39 (= (not (= (bvxor (_ bv240 8) (_ bv255 8)) (_ bv15 8))) (not true)))))
+(let ((@x46 (trans @x42 (rewrite (= (not true) false)) (= (not (= (bvxor (_ bv240 8) (_ bv255 8)) (_ bv15 8))) false))))
+(mp (asserted (not (= (bvxor (_ bv240 8) (_ bv255 8)) (_ bv15 8)))) @x46 false)))))))
+
+48dba82ab628843121b1cc45b6a662d4282a5dfd 8 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((@x16 (monotonicity (rewrite (= (bvnot (_ bv240 16)) (_ bv65295 16))) (= (= (bvnot (_ bv240 16)) (_ bv65295 16)) (= (_ bv65295 16) (_ bv65295 16))))))
-(let ((@x20 (trans @x16 (rewrite (= (= (_ bv65295 16) (_ bv65295 16)) true)) (= (= (bvnot (_ bv240 16)) (_ bv65295 16)) true))))
-(let ((@x27 (trans (monotonicity @x20 (= (not (= (bvnot (_ bv240 16)) (_ bv65295 16))) (not true))) (rewrite (= (not true) false)) (= (not (= (bvnot (_ bv240 16)) (_ bv65295 16))) false))))
-(mp (asserted (not (= (bvnot (_ bv240 16)) (_ bv65295 16)))) @x27 false))))))
+(let ((@x34 (monotonicity (rewrite (= (bvnot (_ bv240 16)) (_ bv65295 16))) (= (= (bvnot (_ bv240 16)) (_ bv65295 16)) (= (_ bv65295 16) (_ bv65295 16))))))
+(let ((@x38 (trans @x34 (rewrite (= (= (_ bv65295 16) (_ bv65295 16)) true)) (= (= (bvnot (_ bv240 16)) (_ bv65295 16)) true))))
+(let ((@x45 (trans (monotonicity @x38 (= (not (= (bvnot (_ bv240 16)) (_ bv65295 16))) (not true))) (rewrite (= (not true) false)) (= (not (= (bvnot (_ bv240 16)) (_ bv65295 16))) false))))
+(mp (asserted (not (= (bvnot (_ bv240 16)) (_ bv65295 16)))) @x45 false))))))
 
-bd5c0956c6d9ce0fe1b46966d2bd414a02a41462 9 0
+ffdba93b71ca27a7275f33b87244eb12ceb5e9c2 9 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((@x17 (monotonicity (rewrite (= (concat (_ bv11 4) (_ bv27 8)) (_ bv2843 12))) (= (= (concat (_ bv11 4) (_ bv27 8)) (_ bv2843 12)) (= (_ bv2843 12) (_ bv2843 12))))))
-(let ((@x21 (trans @x17 (rewrite (= (= (_ bv2843 12) (_ bv2843 12)) true)) (= (= (concat (_ bv11 4) (_ bv27 8)) (_ bv2843 12)) true))))
-(let ((@x24 (monotonicity @x21 (= (not (= (concat (_ bv11 4) (_ bv27 8)) (_ bv2843 12))) (not true)))))
-(let ((@x28 (trans @x24 (rewrite (= (not true) false)) (= (not (= (concat (_ bv11 4) (_ bv27 8)) (_ bv2843 12))) false))))
-(mp (asserted (not (= (concat (_ bv11 4) (_ bv27 8)) (_ bv2843 12)))) @x28 false)))))))
+(let ((@x35 (monotonicity (rewrite (= (concat (_ bv11 4) (_ bv27 8)) (_ bv2843 12))) (= (= (concat (_ bv11 4) (_ bv27 8)) (_ bv2843 12)) (= (_ bv2843 12) (_ bv2843 12))))))
+(let ((@x39 (trans @x35 (rewrite (= (= (_ bv2843 12) (_ bv2843 12)) true)) (= (= (concat (_ bv11 4) (_ bv27 8)) (_ bv2843 12)) true))))
+(let ((@x42 (monotonicity @x39 (= (not (= (concat (_ bv11 4) (_ bv27 8)) (_ bv2843 12))) (not true)))))
+(let ((@x46 (trans @x42 (rewrite (= (not true) false)) (= (not (= (concat (_ bv11 4) (_ bv27 8)) (_ bv2843 12))) false))))
+(mp (asserted (not (= (concat (_ bv11 4) (_ bv27 8)) (_ bv2843 12)))) @x46 false)))))))
 
-a9398b02eb8add9631e972e3353a920fa6b65882 9 0
+24677a2d05cd59ffe782bea3654e41f124fc1b93 9 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((@x17 (monotonicity (rewrite (= (concat (_ bv3 4) (_ bv15 6)) (_ bv207 10))) (= (= (concat (_ bv3 4) (_ bv15 6)) (_ bv207 10)) (= (_ bv207 10) (_ bv207 10))))))
-(let ((@x21 (trans @x17 (rewrite (= (= (_ bv207 10) (_ bv207 10)) true)) (= (= (concat (_ bv3 4) (_ bv15 6)) (_ bv207 10)) true))))
-(let ((@x24 (monotonicity @x21 (= (not (= (concat (_ bv3 4) (_ bv15 6)) (_ bv207 10))) (not true)))))
-(let ((@x28 (trans @x24 (rewrite (= (not true) false)) (= (not (= (concat (_ bv3 4) (_ bv15 6)) (_ bv207 10))) false))))
-(mp (asserted (not (= (concat (_ bv3 4) (_ bv15 6)) (_ bv207 10)))) @x28 false)))))))
+(let ((@x35 (monotonicity (rewrite (= (concat (_ bv3 4) (_ bv15 6)) (_ bv207 10))) (= (= (concat (_ bv3 4) (_ bv15 6)) (_ bv207 10)) (= (_ bv207 10) (_ bv207 10))))))
+(let ((@x39 (trans @x35 (rewrite (= (= (_ bv207 10) (_ bv207 10)) true)) (= (= (concat (_ bv3 4) (_ bv15 6)) (_ bv207 10)) true))))
+(let ((@x42 (monotonicity @x39 (= (not (= (concat (_ bv3 4) (_ bv15 6)) (_ bv207 10))) (not true)))))
+(let ((@x46 (trans @x42 (rewrite (= (not true) false)) (= (not (= (concat (_ bv3 4) (_ bv15 6)) (_ bv207 10))) false))))
+(mp (asserted (not (= (concat (_ bv3 4) (_ bv15 6)) (_ bv207 10)))) @x46 false)))))))
 
-21e135ee99492411c2b40b3f6c9851fc9c8751ff 8 0
+bf709bf2b13e6bf4f9668ad197c5d7a4ca581525 8 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((@x36 (monotonicity (rewrite (= ((_ extract 2 1) (_ bv6 4)) (_ bv3 2))) (= (= ((_ extract 2 1) (_ bv6 4)) (_ bv3 2)) (= (_ bv3 2) (_ bv3 2))))))
-(let ((@x40 (trans @x36 (rewrite (= (= (_ bv3 2) (_ bv3 2)) true)) (= (= ((_ extract 2 1) (_ bv6 4)) (_ bv3 2)) true))))
-(let ((@x47 (trans (monotonicity @x40 (= (not (= ((_ extract 2 1) (_ bv6 4)) (_ bv3 2))) (not true))) (rewrite (= (not true) false)) (= (not (= ((_ extract 2 1) (_ bv6 4)) (_ bv3 2))) false))))
-(mp (asserted (not (= ((_ extract 2 1) (_ bv6 4)) (_ bv3 2)))) @x47 false))))))
+(let ((@x50 (monotonicity (rewrite (= ((_ extract 2 1) (_ bv6 4)) (_ bv3 2))) (= (= ((_ extract 2 1) (_ bv6 4)) (_ bv3 2)) (= (_ bv3 2) (_ bv3 2))))))
+(let ((@x54 (trans @x50 (rewrite (= (= (_ bv3 2) (_ bv3 2)) true)) (= (= ((_ extract 2 1) (_ bv6 4)) (_ bv3 2)) true))))
+(let ((@x61 (trans (monotonicity @x54 (= (not (= ((_ extract 2 1) (_ bv6 4)) (_ bv3 2))) (not true))) (rewrite (= (not true) false)) (= (not (= ((_ extract 2 1) (_ bv6 4)) (_ bv3 2))) false))))
+(mp (asserted (not (= ((_ extract 2 1) (_ bv6 4)) (_ bv3 2)))) @x61 false))))))
 
-e1415b87a5b4eb662a5657d1dfe4d551edf248b7 9 0
+f487669e8e249c60376443304a5a78c58eddd1cc 9 0
 unsat
 ((set-logic <null>)
 (proof
-(let (($x8 (= ((_ zero_extend 6) (_ bv10 4)) (_ bv10 10))))
-(let ((@x19 (trans (rewrite (= ((_ zero_extend 6) (_ bv10 4)) (concat (_ bv0 6) (_ bv10 4)))) (rewrite (= (concat (_ bv0 6) (_ bv10 4)) (_ bv10 10))) $x8)))
-(let ((@x26 (trans (monotonicity @x19 (= $x8 (= (_ bv10 10) (_ bv10 10)))) (rewrite (= (= (_ bv10 10) (_ bv10 10)) true)) (= $x8 true))))
-(let ((@x33 (trans (monotonicity @x26 (= (not $x8) (not true))) (rewrite (= (not true) false)) (= (not $x8) false))))
-(mp (asserted (not $x8)) @x33 false)))))))
+(let ((@x34 (monotonicity (rewrite (= ((_ zero_extend 6) (_ bv10 4)) (_ bv10 10))) (= (= ((_ zero_extend 6) (_ bv10 4)) (_ bv10 10)) (= (_ bv10 10) (_ bv10 10))))))
+(let ((@x38 (trans @x34 (rewrite (= (= (_ bv10 10) (_ bv10 10)) true)) (= (= ((_ zero_extend 6) (_ bv10 4)) (_ bv10 10)) true))))
+(let ((@x41 (monotonicity @x38 (= (not (= ((_ zero_extend 6) (_ bv10 4)) (_ bv10 10))) (not true)))))
+(let ((@x45 (trans @x41 (rewrite (= (not true) false)) (= (not (= ((_ zero_extend 6) (_ bv10 4)) (_ bv10 10))) false))))
+(mp (asserted (not (= ((_ zero_extend 6) (_ bv10 4)) (_ bv10 10)))) @x45 false)))))))
 
-178d8d16724e49deba92985130e376a590d7472a 9 0
+e6179d5000250fb81646a549216cd9ad7b2619a2 9 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((@x16 (monotonicity (rewrite (= ((_ sign_extend 2) (_ bv10 4)) (_ bv58 6))) (= (= ((_ sign_extend 2) (_ bv10 4)) (_ bv58 6)) (= (_ bv58 6) (_ bv58 6))))))
-(let ((@x20 (trans @x16 (rewrite (= (= (_ bv58 6) (_ bv58 6)) true)) (= (= ((_ sign_extend 2) (_ bv10 4)) (_ bv58 6)) true))))
-(let ((@x23 (monotonicity @x20 (= (not (= ((_ sign_extend 2) (_ bv10 4)) (_ bv58 6))) (not true)))))
-(let ((@x27 (trans @x23 (rewrite (= (not true) false)) (= (not (= ((_ sign_extend 2) (_ bv10 4)) (_ bv58 6))) false))))
-(mp (asserted (not (= ((_ sign_extend 2) (_ bv10 4)) (_ bv58 6)))) @x27 false)))))))
+(let ((@x34 (monotonicity (rewrite (= ((_ sign_extend 2) (_ bv10 4)) (_ bv58 6))) (= (= ((_ sign_extend 2) (_ bv10 4)) (_ bv58 6)) (= (_ bv58 6) (_ bv58 6))))))
+(let ((@x38 (trans @x34 (rewrite (= (= (_ bv58 6) (_ bv58 6)) true)) (= (= ((_ sign_extend 2) (_ bv10 4)) (_ bv58 6)) true))))
+(let ((@x41 (monotonicity @x38 (= (not (= ((_ sign_extend 2) (_ bv10 4)) (_ bv58 6))) (not true)))))
+(let ((@x45 (trans @x41 (rewrite (= (not true) false)) (= (not (= ((_ sign_extend 2) (_ bv10 4)) (_ bv58 6))) false))))
+(mp (asserted (not (= ((_ sign_extend 2) (_ bv10 4)) (_ bv58 6)))) @x45 false)))))))
 
-c6b1cf5c4ded8882d16be523581927de69dbb8af 9 0
+5ca573788c44ee26ee19907e7d9d9ec1635c9a5b 9 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((@x37 (monotonicity (rewrite (= (bvshl (_ bv19 8) (_ bv2 8)) (_ bv76 8))) (= (= (bvshl (_ bv19 8) (_ bv2 8)) (_ bv76 8)) (= (_ bv76 8) (_ bv76 8))))))
-(let ((@x41 (trans @x37 (rewrite (= (= (_ bv76 8) (_ bv76 8)) true)) (= (= (bvshl (_ bv19 8) (_ bv2 8)) (_ bv76 8)) true))))
-(let ((@x44 (monotonicity @x41 (= (not (= (bvshl (_ bv19 8) (_ bv2 8)) (_ bv76 8))) (not true)))))
-(let ((@x48 (trans @x44 (rewrite (= (not true) false)) (= (not (= (bvshl (_ bv19 8) (_ bv2 8)) (_ bv76 8))) false))))
-(mp (asserted (not (= (bvshl (_ bv19 8) (_ bv2 8)) (_ bv76 8)))) @x48 false)))))))
+(let ((@x51 (monotonicity (rewrite (= (bvshl (_ bv19 8) (_ bv2 8)) (_ bv76 8))) (= (= (bvshl (_ bv19 8) (_ bv2 8)) (_ bv76 8)) (= (_ bv76 8) (_ bv76 8))))))
+(let ((@x55 (trans @x51 (rewrite (= (= (_ bv76 8) (_ bv76 8)) true)) (= (= (bvshl (_ bv19 8) (_ bv2 8)) (_ bv76 8)) true))))
+(let ((@x58 (monotonicity @x55 (= (not (= (bvshl (_ bv19 8) (_ bv2 8)) (_ bv76 8))) (not true)))))
+(let ((@x62 (trans @x58 (rewrite (= (not true) false)) (= (not (= (bvshl (_ bv19 8) (_ bv2 8)) (_ bv76 8))) false))))
+(mp (asserted (not (= (bvshl (_ bv19 8) (_ bv2 8)) (_ bv76 8)))) @x62 false)))))))
 
-0e385f4a6baafc61da9693d7b6b0037bf18ced69 9 0
+b4a2032ff1791888567d8f54fa94d95365cb3255 9 0
 unsat
 ((set-logic <null>)
 (proof
-(let ((@x37 (monotonicity (rewrite (= (bvlshr (_ bv25 8) (_ bv2 8)) (_ bv6 8))) (= (= (bvlshr (_ bv25 8) (_ bv2 8)) (_ bv6 8)) (= (_ bv6 8) (_ bv6 8))))))
-(let ((@x41 (trans @x37 (rewrite (= (= (_ bv6 8) (_ bv6 8)) true)) (= (= (bvlshr (_ bv25 8) (_ bv2 8)) (_ bv6 8)) true))))
-(let ((@x44 (monotonicity @x41 (= (not (= (bvlshr (_ bv25 8) (_ bv2 8)) (_ bv6 8))) (not true)))))
-(let ((@x48 (trans @x44 (rewrite (= (not true) false)) (= (not (= (bvlshr (_ bv25 8) (_ bv2 8)) (_ bv6 8))) false))))
-(mp (asserted (not (= (bvlshr (_ bv25 8) (_ bv2 8)) (_ bv6 8)))) @x48 false)))))))
+(let ((@x51 (monotonicity (rewrite (= (bvlshr (_ bv25 8) (_ bv2 8)) (_ bv6 8))) (= (= (bvlshr (_ bv25 8) (_ bv2 8)) (_ bv6 8)) (= (_ bv6 8) (_ bv6 8))))))
+(let ((@x55 (trans @x51 (rewrite (= (= (_ bv6 8) (_ bv6 8)) true)) (= (= (bvlshr (_ bv25 8) (_ bv2 8)) (_ bv6 8)) true))))
+(let ((@x58 (monotonicity @x55 (= (not (= (bvlshr (_ bv25 8) (_ bv2 8)) (_ bv6 8))) (not true)))))
+(let ((@x62 (trans @x58 (rewrite (= (not true) false)) (= (not (= (bvlshr (_ bv25 8) (_ bv2 8)) (_ bv6 8))) false))))
+(mp (asserted (not (= (bvlshr (_ bv25 8) (_ bv2 8)) (_ bv6 8)))) @x62 false)))))))
 
-7d896522fe362abba8d2768cab253bbc8b92ad49 9 0
-unsat
-((set-logic <null>)
-(proof
-(let ((@x37 (monotonicity (rewrite (= (bvashr (_ bv19 8) (_ bv2 8)) (_ bv4 8))) (= (= (bvashr (_ bv19 8) (_ bv2 8)) (_ bv4 8)) (= (_ bv4 8) (_ bv4 8))))))
-(let ((@x41 (trans @x37 (rewrite (= (= (_ bv4 8) (_ bv4 8)) true)) (= (= (bvashr (_ bv19 8) (_ bv2 8)) (_ bv4 8)) true))))
-(let ((@x44 (monotonicity @x41 (= (not (= (bvashr (_ bv19 8) (_ bv2 8)) (_ bv4 8))) (not true)))))
-(let ((@x48 (trans @x44 (rewrite (= (not true) false)) (= (not (= (bvashr (_ bv19 8) (_ bv2 8)) (_ bv4 8))) false))))
-(mp (asserted (not (= (bvashr (_ bv19 8) (_ bv2 8)) (_ bv4 8)))) @x48 false)))))))
-
-867ea9722404471d6daa5f484f08fb1134d3c3d1 11 0
+7a4f6966fce99a20413ba9068cef650098d5df66 9 0
 unsat
 ((set-logic <null>)
 (proof
-(let (($x8 (= ((_ rotate_right 2) (_ bv6 4)) (_ bv9 4))))
-(let ((@x46 (monotonicity (rewrite (= ((_ extract 1 0) (_ bv6 4)) (_ bv2 2))) (rewrite (= ((_ extract 3 2) (_ bv6 4)) (_ bv1 2))) (= (concat ((_ extract 1 0) (_ bv6 4)) ((_ extract 3 2) (_ bv6 4))) (concat (_ bv2 2) (_ bv1 2))))))
-(let ((@x50 (trans @x46 (rewrite (= (concat (_ bv2 2) (_ bv1 2)) (_ bv9 4))) (= (concat ((_ extract 1 0) (_ bv6 4)) ((_ extract 3 2) (_ bv6 4))) (_ bv9 4)))))
-(let ((@x37 (rewrite (= ((_ rotate_right 2) (_ bv6 4)) (concat ((_ extract 1 0) (_ bv6 4)) ((_ extract 3 2) (_ bv6 4)))))))
-(let ((@x58 (trans (monotonicity (trans @x37 @x50 $x8) (= $x8 (= (_ bv9 4) (_ bv9 4)))) (rewrite (= (= (_ bv9 4) (_ bv9 4)) true)) (= $x8 true))))
-(let ((@x65 (trans (monotonicity @x58 (= (not $x8) (not true))) (rewrite (= (not true) false)) (= (not $x8) false))))
-(mp (asserted (not $x8)) @x65 false)))))))))
+(let ((@x51 (monotonicity (rewrite (= (bvashr (_ bv19 8) (_ bv2 8)) (_ bv4 8))) (= (= (bvashr (_ bv19 8) (_ bv2 8)) (_ bv4 8)) (= (_ bv4 8) (_ bv4 8))))))
+(let ((@x55 (trans @x51 (rewrite (= (= (_ bv4 8) (_ bv4 8)) true)) (= (= (bvashr (_ bv19 8) (_ bv2 8)) (_ bv4 8)) true))))
+(let ((@x58 (monotonicity @x55 (= (not (= (bvashr (_ bv19 8) (_ bv2 8)) (_ bv4 8))) (not true)))))
+(let ((@x62 (trans @x58 (rewrite (= (not true) false)) (= (not (= (bvashr (_ bv19 8) (_ bv2 8)) (_ bv4 8))) false))))
+(mp (asserted (not (= (bvashr (_ bv19 8) (_ bv2 8)) (_ bv4 8)))) @x62 false)))))))
 
-c373efe2cbce6fe12a529ce0b3bfdfa0b82ccec7 11 0
+17e3ce1c7a7f4469b5b93e126887f9f5cc55a51d 9 0
 unsat
 ((set-logic <null>)
 (proof
-(let (($x8 (= ((_ rotate_left 1) (_ bv14 4)) (_ bv13 4))))
-(let ((@x45 (monotonicity (rewrite (= ((_ extract 2 0) (_ bv14 4)) (_ bv6 3))) (rewrite (= ((_ extract 3 3) (_ bv14 4)) (_ bv1 1))) (= (concat ((_ extract 2 0) (_ bv14 4)) ((_ extract 3 3) (_ bv14 4))) (concat (_ bv6 3) (_ bv1 1))))))
-(let ((@x49 (trans @x45 (rewrite (= (concat (_ bv6 3) (_ bv1 1)) (_ bv13 4))) (= (concat ((_ extract 2 0) (_ bv14 4)) ((_ extract 3 3) (_ bv14 4))) (_ bv13 4)))))
-(let ((@x50 (trans (rewrite (= ((_ rotate_left 1) (_ bv14 4)) (concat ((_ extract 2 0) (_ bv14 4)) ((_ extract 3 3) (_ bv14 4))))) @x49 $x8)))
-(let ((@x57 (trans (monotonicity @x50 (= $x8 (= (_ bv13 4) (_ bv13 4)))) (rewrite (= (= (_ bv13 4) (_ bv13 4)) true)) (= $x8 true))))
-(let ((@x64 (trans (monotonicity @x57 (= (not $x8) (not true))) (rewrite (= (not true) false)) (= (not $x8) false))))
-(mp (asserted (not $x8)) @x64 false)))))))))
+(let ((@x50 (monotonicity (rewrite (= ((_ rotate_right 2) (_ bv6 4)) (_ bv9 4))) (= (= ((_ rotate_right 2) (_ bv6 4)) (_ bv9 4)) (= (_ bv9 4) (_ bv9 4))))))
+(let ((@x54 (trans @x50 (rewrite (= (= (_ bv9 4) (_ bv9 4)) true)) (= (= ((_ rotate_right 2) (_ bv6 4)) (_ bv9 4)) true))))
+(let ((@x57 (monotonicity @x54 (= (not (= ((_ rotate_right 2) (_ bv6 4)) (_ bv9 4))) (not true)))))
+(let ((@x61 (trans @x57 (rewrite (= (not true) false)) (= (not (= ((_ rotate_right 2) (_ bv6 4)) (_ bv9 4))) false))))
+(mp (asserted (not (= ((_ rotate_right 2) (_ bv6 4)) (_ bv9 4)))) @x61 false)))))))
 
-a182f0aa79adadd545fe3d792074b3ce7a69af9a 44 0
+070667ff72c73dc8cd9ebb50cc06803d9785fef4 9 0
+unsat
+((set-logic <null>)
+(proof
+(let ((@x50 (monotonicity (rewrite (= ((_ rotate_left 1) (_ bv14 4)) (_ bv13 4))) (= (= ((_ rotate_left 1) (_ bv14 4)) (_ bv13 4)) (= (_ bv13 4) (_ bv13 4))))))
+(let ((@x54 (trans @x50 (rewrite (= (= (_ bv13 4) (_ bv13 4)) true)) (= (= ((_ rotate_left 1) (_ bv14 4)) (_ bv13 4)) true))))
+(let ((@x57 (monotonicity @x54 (= (not (= ((_ rotate_left 1) (_ bv14 4)) (_ bv13 4))) (not true)))))
+(let ((@x61 (trans @x57 (rewrite (= (not true) false)) (= (not (= ((_ rotate_left 1) (_ bv14 4)) (_ bv13 4))) false))))
+(mp (asserted (not (= ((_ rotate_left 1) (_ bv14 4)) (_ bv13 4)))) @x61 false)))))))
+
+222d5f4b74cc91bf83cca8b1b96f9cfe0f7db0f7 17 0
 unsat
 ((set-logic <null>)
 (proof
@@ -265,170 +259,111 @@
 (let ((?x10 (bvor ?x7 ?x9)))
 (let (($x11 (= ?x10 |x$|)))
 (let (($x12 (not $x11)))
-(let ((?x113 (concat ((_ extract 15 8) (concat ((_ extract 15 8) |x$|) (_ bv0 8))) ((_ extract 7 0) (concat (_ bv0 8) ((_ extract 7 0) |x$|))))))
-(let ((@x124 (monotonicity (rewrite (= ((_ extract 15 8) (concat ((_ extract 15 8) |x$|) (_ bv0 8))) ((_ extract 15 8) |x$|))) (rewrite (= ((_ extract 7 0) (concat (_ bv0 8) ((_ extract 7 0) |x$|))) ((_ extract 7 0) |x$|))) (= ?x113 (concat ((_ extract 15 8) |x$|) ((_ extract 7 0) |x$|))))))
-(let ((@x129 (trans @x124 (rewrite (= (concat ((_ extract 15 8) |x$|) ((_ extract 7 0) |x$|)) ((_ extract 15 0) |x$|))) (= ?x113 ((_ extract 15 0) |x$|)))))
-(let (($x114 (= (bvor (concat ((_ extract 15 8) |x$|) (_ bv0 8)) (concat (_ bv0 8) ((_ extract 7 0) |x$|))) ?x113)))
-(let (($x109 (= ?x10 (bvor (concat ((_ extract 15 8) |x$|) (_ bv0 8)) (concat (_ bv0 8) ((_ extract 7 0) |x$|))))))
-(let ((?x81 ((_ extract 7 0) |x$|)))
-(let ((?x101 (concat (_ bv0 8) ?x81)))
-(let ((?x16 (bvnot |x$|)))
-(let ((?x66 (bvor ?x16 (bvnot (_ bv255 16)))))
-(let ((?x67 (bvnot ?x66)))
-(let ((@x103 (monotonicity (rewrite (= (bvnot (_ bv255 8)) (_ bv0 8))) (rewrite (= (bvnot (bvnot ?x81)) ?x81)) (= (concat (bvnot (_ bv255 8)) (bvnot (bvnot ?x81))) ?x101))))
-(let ((?x47 (bvnot (_ bv255 8))))
-(let ((?x94 (concat ?x47 (bvnot (bvnot ?x81)))))
-(let ((@x87 (monotonicity (rewrite (= ((_ extract 7 0) ?x16) (bvnot ?x81))) (= (concat (_ bv255 8) ((_ extract 7 0) ?x16)) (concat (_ bv255 8) (bvnot ?x81))))))
-(let ((@x74 (monotonicity (rewrite (= (bvnot (_ bv255 16)) (_ bv65280 16))) (= ?x66 (bvor ?x16 (_ bv65280 16))))))
-(let ((@x80 (trans @x74 (rewrite (= (bvor ?x16 (_ bv65280 16)) (concat (_ bv255 8) ((_ extract 7 0) ?x16)))) (= ?x66 (concat (_ bv255 8) ((_ extract 7 0) ?x16))))))
-(let ((@x92 (monotonicity (trans @x80 @x87 (= ?x66 (concat (_ bv255 8) (bvnot ?x81)))) (= ?x67 (bvnot (concat (_ bv255 8) (bvnot ?x81)))))))
-(let ((@x98 (trans @x92 (rewrite (= (bvnot (concat (_ bv255 8) (bvnot ?x81))) ?x94)) (= ?x67 ?x94))))
-(let ((@x107 (trans (rewrite (= ?x9 ?x67)) (trans @x98 @x103 (= ?x67 ?x101)) (= ?x9 ?x101))))
-(let ((?x34 ((_ extract 15 8) |x$|)))
-(let ((?x58 (concat ?x34 (_ bv0 8))))
-(let ((?x48 (concat (bvnot (bvnot ?x34)) ?x47)))
-(let ((@x60 (monotonicity (rewrite (= (bvnot (bvnot ?x34)) ?x34)) (rewrite (= ?x47 (_ bv0 8))) (= ?x48 ?x58))))
-(let ((?x18 (bvor ?x16 (bvnot (_ bv65280 16)))))
-(let ((?x19 (bvnot ?x18)))
-(let ((@x40 (monotonicity (rewrite (= ((_ extract 15 8) ?x16) (bvnot ?x34))) (= (concat ((_ extract 15 8) ?x16) (_ bv255 8)) (concat (bvnot ?x34) (_ bv255 8))))))
-(let ((@x26 (monotonicity (rewrite (= (bvnot (_ bv65280 16)) (_ bv255 16))) (= ?x18 (bvor ?x16 (_ bv255 16))))))
-(let ((@x33 (trans @x26 (rewrite (= (bvor ?x16 (_ bv255 16)) (concat ((_ extract 15 8) ?x16) (_ bv255 8)))) (= ?x18 (concat ((_ extract 15 8) ?x16) (_ bv255 8))))))
-(let ((@x45 (monotonicity (trans @x33 @x40 (= ?x18 (concat (bvnot ?x34) (_ bv255 8)))) (= ?x19 (bvnot (concat (bvnot ?x34) (_ bv255 8)))))))
-(let ((@x52 (trans @x45 (rewrite (= (bvnot (concat (bvnot ?x34) (_ bv255 8))) ?x48)) (= ?x19 ?x48))))
-(let ((@x64 (trans (rewrite (= ?x7 ?x19)) (trans @x52 @x60 (= ?x19 ?x58)) (= ?x7 ?x58))))
-(let ((@x134 (trans (trans (monotonicity @x64 @x107 $x109) (rewrite $x114) (= ?x10 ?x113)) (trans @x129 (rewrite (= ((_ extract 15 0) |x$|) |x$|)) (= ?x113 |x$|)) $x11)))
-(let ((@x141 (trans (monotonicity @x134 (= $x11 (= |x$| |x$|))) (rewrite (= (= |x$| |x$|) true)) (= $x11 true))))
-(let ((@x148 (trans (monotonicity @x141 (= $x12 (not true))) (rewrite (= (not true) false)) (= $x12 false))))
-(mp (asserted $x12) @x148 false))))))))))))))))))))))))))))))))))))))))))
+(let ((@x57 (symm (commutativity (= (= |x$| ?x10) $x11)) (= $x11 (= |x$| ?x10)))))
+(let ((@x33 (asserted $x12)))
+(let ((@x61 (mp @x33 (monotonicity @x57 (= $x12 (not (= |x$| ?x10)))) (not (= |x$| ?x10)))))
+(let (($x50 (= |x$| ?x10)))
+(let ((@x32 (|true-axiom| true)))
+(let (($x51 (or $x50 false false false false false false false false false false false false false false false false)))
+(let ((@x53 (|unit-resolution| ((_ |th-lemma| bv) $x51) @x32 @x32 @x32 @x32 @x32 @x32 @x32 @x32 @x32 @x32 @x32 @x32 @x32 @x32 @x32 @x32 $x50)))
+(|unit-resolution| @x53 @x61 false)))))))))))))))
 
-ca557d28761bb4642d53f86787f6caf2ff06ecdd 97 0
-unsat
-((set-logic <null>)
-(declare-fun k!150 () Bool)
-(declare-fun k!140 () Bool)
-(declare-fun k!130 () Bool)
-(declare-fun k!120 () Bool)
-(declare-fun k!110 () Bool)
-(declare-fun k!100 () Bool)
-(declare-fun k!90 () Bool)
-(declare-fun k!80 () Bool)
-(declare-fun k!70 () Bool)
-(declare-fun k!60 () Bool)
-(declare-fun k!50 () Bool)
-(declare-fun k!40 () Bool)
-(declare-fun k!30 () Bool)
-(declare-fun k!20 () Bool)
-(declare-fun k!10 () Bool)
-(declare-fun k!00 () Bool)
-(proof
-(let (($x199 (or k!80 k!90 k!100 k!110 k!120 k!130 k!140 k!150)))
-(let (($x364 (= (or false false false false false false false false) false)))
-(let (($x362 (= $x199 (or false false false false false false false false))))
-(let (($x312 (= k!150 false)))
-(let ((@x316 (symm (rewrite (= $x312 (not k!150))) (= (not k!150) $x312))))
-(let (($x143 (not k!150)))
-(let (($x119 (not (or k!90 k!80 (not (or (not k!90) (not k!80)))))))
-(let (($x118 (not k!100)))
-(let (($x122 (or k!100 (or k!90 k!80 (not (or (not k!90) (not k!80)))) (not (or $x118 $x119)))))
-(let (($x123 (not k!110)))
-(let (($x128 (not k!120)))
-(let (($x131 (not (or $x128 (not (or k!110 $x122 (not (or $x123 (not $x122)))))))))
-(let (($x134 (not (or k!120 (or k!110 $x122 (not (or $x123 (not $x122)))) $x131))))
-(let (($x133 (not k!130)))
-(let (($x137 (or k!130 (or k!120 (or k!110 $x122 (not (or $x123 (not $x122)))) $x131) (not (or $x133 $x134)))))
-(let (($x138 (not k!140)))
-(let (($x146 (not (or $x143 (not (or k!140 $x137 (not (or $x138 (not $x137)))))))))
-(let (($x147 (or k!150 (or k!140 $x137 (not (or $x138 (not $x137)))) $x146)))
-(let ((?x107 (mkbv k!00 k!10 k!20 k!30 k!40 k!50 k!60 k!70 k!80 k!90 k!100 k!110 k!120 k!130 k!140 k!150)))
-(let ((?x88 (mkbv false false false false false false false false true false false false false false false false)))
-(let ((@x109 (rewrite (= |w$| ?x107))))
-(let ((@x112 (monotonicity (rewrite (= (_ bv256 16) ?x88)) @x109 (= (bvule (_ bv256 16) |w$|) (bvule ?x88 ?x107)))))
-(let ((@x151 (trans @x112 (rewrite (= (bvule ?x88 ?x107) $x147)) (= (bvule (_ bv256 16) |w$|) $x147))))
-(let (($x16 (bvule (_ bv256 16) |w$|)))
-(let (($x17 (not $x16)))
-(let (($x11 (=> (bvult |w$| (_ bv256 16)) (= (bvand |w$| (_ bv255 16)) |w$|))))
-(let (($x12 (not $x11)))
-(let ((?x39 ((_ extract 7 0) |w$|)))
-(let ((?x63 (concat (_ bv0 8) ?x39)))
-(let (($x70 (= ?x63 |w$|)))
-(let (($x76 (or $x16 $x70)))
-(let ((@x65 (monotonicity (rewrite (= (bvnot (_ bv255 8)) (_ bv0 8))) (rewrite (= (bvnot (bvnot ?x39)) ?x39)) (= (concat (bvnot (_ bv255 8)) (bvnot (bvnot ?x39))) ?x63))))
-(let ((?x53 (concat (bvnot (_ bv255 8)) (bvnot (bvnot ?x39)))))
-(let ((?x20 (bvnot |w$|)))
-(let ((?x22 (bvor ?x20 (bvnot (_ bv255 16)))))
-(let ((?x23 (bvnot ?x22)))
-(let ((@x45 (monotonicity (rewrite (= ((_ extract 7 0) ?x20) (bvnot ?x39))) (= (concat (_ bv255 8) ((_ extract 7 0) ?x20)) (concat (_ bv255 8) (bvnot ?x39))))))
-(let ((@x31 (monotonicity (rewrite (= (bvnot (_ bv255 16)) (_ bv65280 16))) (= ?x22 (bvor ?x20 (_ bv65280 16))))))
-(let ((@x38 (trans @x31 (rewrite (= (bvor ?x20 (_ bv65280 16)) (concat (_ bv255 8) ((_ extract 7 0) ?x20)))) (= ?x22 (concat (_ bv255 8) ((_ extract 7 0) ?x20))))))
-(let ((@x50 (monotonicity (trans @x38 @x45 (= ?x22 (concat (_ bv255 8) (bvnot ?x39)))) (= ?x23 (bvnot (concat (_ bv255 8) (bvnot ?x39)))))))
-(let ((@x57 (trans @x50 (rewrite (= (bvnot (concat (_ bv255 8) (bvnot ?x39))) ?x53)) (= ?x23 ?x53))))
-(let ((@x69 (trans (rewrite (= (bvand |w$| (_ bv255 16)) ?x23)) (trans @x57 @x65 (= ?x23 ?x63)) (= (bvand |w$| (_ bv255 16)) ?x63))))
-(let ((@x75 (monotonicity (rewrite (= (bvult |w$| (_ bv256 16)) $x17)) (monotonicity @x69 (= (= (bvand |w$| (_ bv255 16)) |w$|) $x70)) (= $x11 (=> $x17 $x70)))))
-(let ((@x83 (monotonicity (trans @x75 (rewrite (= (=> $x17 $x70) $x76)) (= $x11 $x76)) (= $x12 (not $x76)))))
-(let ((@x155 (mp (|not-or-elim| (mp (asserted $x12) @x83 (not $x76)) $x17) (monotonicity @x151 (= $x17 (not $x147))) (not $x147))))
-(let (($x318 (= k!140 false)))
-(let ((@x157 (|not-or-elim| @x155 (not (or k!140 $x137 (not (or $x138 (not $x137))))))))
-(let ((@x323 (mp (|not-or-elim| @x157 $x138) (symm (rewrite (= $x318 $x138)) (= $x138 $x318)) $x318)))
-(let (($x324 (= k!130 false)))
-(let ((@x329 (mp (|not-or-elim| (|not-or-elim| @x157 (not $x137)) $x133) (symm (rewrite (= $x324 $x133)) (= $x133 $x324)) $x324)))
-(let (($x330 (= k!120 false)))
-(let ((@x335 (mp (|not-or-elim| (|not-or-elim| (|not-or-elim| @x157 (not $x137)) $x134) $x128) (symm (rewrite (= $x330 $x128)) (= $x128 $x330)) $x330)))
-(let (($x336 (= k!110 false)))
-(let ((@x163 (|not-or-elim| (|not-or-elim| (|not-or-elim| @x157 (not $x137)) $x134) (not (or k!110 $x122 (not (or $x123 (not $x122))))))))
-(let ((@x341 (mp (|not-or-elim| @x163 $x123) (symm (rewrite (= $x336 $x123)) (= $x123 $x336)) $x336)))
-(let (($x342 (= k!100 false)))
-(let ((@x347 (mp (|not-or-elim| (|not-or-elim| @x163 (not $x122)) $x118) (symm (rewrite (= $x342 $x118)) (= $x118 $x342)) $x342)))
-(let (($x348 (= k!90 false)))
-(let ((@x352 (symm (rewrite (= $x348 (not k!90))) (= (not k!90) $x348))))
-(let (($x113 (not k!90)))
-(let ((@x353 (mp (|not-or-elim| (|not-or-elim| (|not-or-elim| @x163 (not $x122)) $x119) $x113) @x352 $x348)))
-(let (($x354 (= k!80 false)))
-(let ((@x358 (symm (rewrite (= $x354 (not k!80))) (= (not k!80) $x354))))
-(let (($x114 (not k!80)))
-(let ((@x359 (mp (|not-or-elim| (|not-or-elim| (|not-or-elim| @x163 (not $x122)) $x119) $x114) @x358 $x354)))
-(let ((@x363 (monotonicity @x359 @x353 @x347 @x341 @x335 @x329 @x323 (mp (|not-or-elim| @x155 $x143) @x316 $x312) $x362)))
-(let (($x200 (not $x199)))
-(let (($x205 (not $x200)))
-(let ((?x191 (mkbv k!00 k!10 k!20 k!30 k!40 k!50 k!60 k!70 false false false false false false false false)))
-(let ((?x183 (mkbv k!00 k!10 k!20 k!30 k!40 k!50 k!60 k!70)))
-(let ((?x188 (concat (mkbv false false false false false false false false) ?x183)))
-(let ((@x187 (trans (monotonicity @x109 (= ?x39 ((_ extract 7 0) ?x107))) (rewrite (= ((_ extract 7 0) ?x107) ?x183)) (= ?x39 ?x183))))
-(let (($x178 (= (_ bv0 8) (mkbv false false false false false false false false))))
-(let ((@x195 (trans (monotonicity (rewrite $x178) @x187 (= ?x63 ?x188)) (rewrite (= ?x188 ?x191)) (= ?x63 ?x191))))
-(let ((@x204 (trans (monotonicity @x195 @x109 (= $x70 (= ?x191 ?x107))) (rewrite (= (= ?x191 ?x107) $x200)) (= $x70 $x200))))
-(let ((@x208 (mp (|not-or-elim| (mp (asserted $x12) @x83 (not $x76)) (not $x70)) (monotonicity @x204 (= (not $x70) $x205)) $x205)))
-(mp (mp @x208 (rewrite (= $x205 $x199)) $x199) (trans @x363 (rewrite $x364) (= $x199 false)) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
-
-934b753ba18ced93b3abefe28ac123e272856e65 18 0
+f856dea62e897c0065d5a1827265d3ff37ee50c8 51 0
 unsat
 ((set-logic <null>)
 (proof
-(let (($x600 (forall ((?v0 (_ BitVec 2)) )(!(not (<= (|bv2int$| ?v0) 0)) :pattern ( (|bv2int$| ?v0) )))
+(let ((?x9 (bvand |w$| (_ bv255 16))))
+(let (($x10 (= ?x9 |w$|)))
+(let (($x62 (not $x10)))
+(let ((@x316 (symm (commutativity (= (= |w$| ?x9) $x10)) (= $x10 (= |w$| ?x9)))))
+(let (($x55 (not (or (bvule (_ bv256 16) |w$|) $x10))))
+(let ((@x47 (monotonicity (rewrite (= (bvult |w$| (_ bv256 16)) (not (bvule (_ bv256 16) |w$|)))) (= (not (bvult |w$| (_ bv256 16))) (not (not (bvule (_ bv256 16) |w$|)))))))
+(let ((@x51 (trans @x47 (rewrite (= (not (not (bvule (_ bv256 16) |w$|))) (bvule (_ bv256 16) |w$|))) (= (not (bvult |w$| (_ bv256 16))) (bvule (_ bv256 16) |w$|)))))
+(let ((@x54 (monotonicity @x51 (= (or (not (bvult |w$| (_ bv256 16))) $x10) (or (bvule (_ bv256 16) |w$|) $x10)))))
+(let ((@x57 (monotonicity @x54 (= (not (or (not (bvult |w$| (_ bv256 16))) $x10)) $x55))))
+(let (($x12 (not (=> (bvult |w$| (_ bv256 16)) $x10))))
+(let ((@x37 (rewrite (= (=> (bvult |w$| (_ bv256 16)) $x10) (or (not (bvult |w$| (_ bv256 16))) $x10)))))
+(let ((@x40 (monotonicity @x37 (= $x12 (not (or (not (bvult |w$| (_ bv256 16))) $x10))))))
+(let ((@x63 (|not-or-elim| (mp (asserted $x12) (trans @x40 @x57 (= $x12 $x55)) $x55) $x62)))
+(let ((@x320 (mp @x63 (monotonicity @x316 (= $x62 (not (= |w$| ?x9)))) (not (= |w$| ?x9)))))
+(let (($x298 (= |w$| ?x9)))
+(let (($x79 (= ((_ extract 15 15) |w$|) (_ bv1 1))))
+(let (($x262 (not $x79)))
+(let (($x72 (= ((_ extract 8 8) |w$|) (_ bv1 1))))
+(let (($x73 (= ((_ extract 9 9) |w$|) (_ bv1 1))))
+(let (($x80 (and $x73 $x72)))
+(let (($x81 (or $x73 $x72 $x80)))
+(let (($x74 (= ((_ extract 10 10) |w$|) (_ bv1 1))))
+(let (($x82 (and $x74 $x81)))
+(let (($x83 (or $x74 $x73 $x72 $x80 $x82)))
+(let (($x75 (= ((_ extract 11 11) |w$|) (_ bv1 1))))
+(let (($x84 (and $x75 $x83)))
+(let (($x85 (or $x75 $x74 $x73 $x72 $x80 $x82 $x84)))
+(let (($x76 (= ((_ extract 12 12) |w$|) (_ bv1 1))))
+(let (($x86 (and $x76 $x85)))
+(let (($x87 (or $x76 $x75 $x74 $x73 $x72 $x80 $x82 $x84 $x86)))
+(let (($x77 (= ((_ extract 13 13) |w$|) (_ bv1 1))))
+(let (($x88 (and $x77 $x87)))
+(let (($x89 (or $x77 $x76 $x75 $x74 $x73 $x72 $x80 $x82 $x84 $x86 $x88)))
+(let (($x78 (= ((_ extract 14 14) |w$|) (_ bv1 1))))
+(let (($x90 (and $x78 $x89)))
+(let (($x91 (or $x78 $x77 $x76 $x75 $x74 $x73 $x72 $x80 $x82 $x84 $x86 $x88 $x90)))
+(let (($x92 (and $x79 $x91)))
+(let (($x93 (or $x79 $x78 $x77 $x76 $x75 $x74 $x73 $x72 $x80 $x82 $x84 $x86 $x88 $x90 $x92)))
+(let (($x295 (not $x93)))
+(let (($x41 (bvule (_ bv256 16) |w$|)))
+(let (($x42 (not $x41)))
+(let ((@x61 (|not-or-elim| (mp (asserted $x12) (trans @x40 @x57 (= $x12 $x55)) $x55) $x42)))
+(let ((@x301 (|unit-resolution| ((_ |th-lemma| bv) (or $x41 $x295)) @x61 $x295)))
+(let ((@x32 (|true-axiom| true)))
+(let (($x310 (or $x298 false false false false false false false false $x72 $x73 $x74 $x75 $x76 $x77 $x78 $x79)))
+(let ((@x312 (|unit-resolution| ((_ |th-lemma| bv) $x310) @x32 @x32 @x32 @x32 @x32 @x32 @x32 @x32 (|unit-resolution| (|def-axiom| (or $x93 (not $x72))) @x301 (not $x72)) (|unit-resolution| (|def-axiom| (or $x93 (not $x73))) @x301 (not $x73)) (|unit-resolution| (|def-axiom| (or $x93 (not $x74))) @x301 (not $x74)) (|unit-resolution| (|def-axiom| (or $x93 (not $x75))) @x301 (not $x75)) (|unit-resolution| (|def-axiom| (or $x93 (not $x76))) @x301 (not $x76)) (|unit-resolution| (|def-axiom| (or $x93 (not $x77))) @x301 (not $x77)) (|unit-resolution| (|def-axiom| (or $x93 (not $x78))) @x301 (not $x78)) (|unit-resolution| (|def-axiom| (or $x93 $x262)) @x301 $x262) $x298)))
+(|unit-resolution| @x312 @x320 false)))))))))))))))))))))))))))))))))))))))))))))))))
+
+39d6b3ac211187a764a365cb2d10eb3330116060 29 0
+unsat
+((set-logic <null>)
+(proof
+(let ((?x6 (|bv2int$| (_ bv0 2))))
+(let (($x181 (<= ?x6 0)))
+(let (($x182 (not $x181)))
+(let (($x173 (forall ((?v0 (_ BitVec 2)) )(!(let ((?x22 (|bv2int$| ?v0)))
+(let (($x59 (<= ?x22 0)))
+(not $x59))) :pattern ( (|bv2int$| ?v0) )))
 ))
-(let (($x45 (forall ((?v0 (_ BitVec 2)) )(not (<= (|bv2int$| ?v0) 0)))
+(let (($x63 (forall ((?v0 (_ BitVec 2)) )(let ((?x22 (|bv2int$| ?v0)))
+(let (($x59 (<= ?x22 0)))
+(not $x59))))
 ))
-(let ((@x602 (refl (= (not (<= (|bv2int$| ?0) 0)) (not (<= (|bv2int$| ?0) 0))))))
-(let ((@x126 (refl (|~| (not (<= (|bv2int$| ?0) 0)) (not (<= (|bv2int$| ?0) 0))))))
+(let ((@x175 (refl (= (not (<= (|bv2int$| ?0) 0)) (not (<= (|bv2int$| ?0) 0))))))
+(let ((@x110 (refl (|~| (not (<= (|bv2int$| ?0) 0)) (not (<= (|bv2int$| ?0) 0))))))
 (let (($x24 (forall ((?v0 (_ BitVec 2)) )(let ((?x22 (|bv2int$| ?v0)))
 (< 0 ?x22)))
 ))
-(let ((@x44 (rewrite (= (< 0 (|bv2int$| ?0)) (not (<= (|bv2int$| ?0) 0))))))
-(let ((@x98 (|mp~| (mp (asserted $x24) (|quant-intro| @x44 (= $x24 $x45)) $x45) (|nnf-pos| @x126 (|~| $x45 $x45)) $x45)))
-(let ((@x597 (|unit-resolution| ((_ |quant-inst| (_ bv0 2)) (or (not $x600) (not (<= (|bv2int$| (_ bv0 2)) 0)))) (mp @x98 (|quant-intro| @x602 (= $x45 $x600)) $x600) (not (<= (|bv2int$| (_ bv0 2)) 0)))))
-(let ((@x589 ((_ |th-lemma| arith triangle-eq) (or (not (= (|bv2int$| (_ bv0 2)) 0)) (<= (|bv2int$| (_ bv0 2)) 0)))))
-(|unit-resolution| @x589 (asserted (= (|bv2int$| (_ bv0 2)) 0)) @x597 false))))))))))))
+(let ((@x62 (rewrite (= (< 0 (|bv2int$| ?0)) (not (<= (|bv2int$| ?0) 0))))))
+(let ((@x113 (|mp~| (mp (asserted $x24) (|quant-intro| @x62 (= $x24 $x63)) $x63) (|nnf-pos| @x110 (|~| $x63 $x63)) $x63)))
+(let ((@x178 (mp @x113 (|quant-intro| @x175 (= $x63 $x173)) $x173)))
+(let (($x185 (not $x173)))
+(let (($x186 (or $x185 $x182)))
+(let ((@x187 ((_ |quant-inst| (_ bv0 2)) $x186)))
+(let (($x8 (= ?x6 0)))
+(let ((@x52 (asserted $x8)))
+(|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x8) $x181)) @x52 (|unit-resolution| @x187 @x178 $x182) false)))))))))))))))))))
 
-0bbf788c7118a79d51655cce7af0be1af048387d 13 0
+f7db43c56c17d090679f2e9727e9eaa7cf84ab8d 16 0
 unsat
 ((set-logic <null>)
 (proof
 (let ((?x10 (|p$| true)))
-(let (($x11 (= (|p$| (ite (bvule (_ bv0 4) |a$|) true false)) ?x10)))
+(let (($x7 (bvule (_ bv0 4) |a$|)))
+(let (($x8 (ite $x7 true false)))
+(let ((?x9 (|p$| $x8)))
+(let (($x11 (= ?x9 ?x10)))
 (let (($x12 (not $x11)))
-(let (($x8 (ite (bvule (_ bv0 4) |a$|) true false)))
-(let ((@x20 (monotonicity (rewrite (= (bvule (_ bv0 4) |a$|) true)) (= $x8 (ite true true false)))))
-(let ((@x24 (trans @x20 (rewrite (= (ite true true false) true)) (= $x8 true))))
-(let ((@x32 (trans (monotonicity (monotonicity @x24 $x11) (= $x11 (= ?x10 ?x10))) (rewrite (= (= ?x10 ?x10) true)) (= $x11 true))))
-(let ((@x39 (trans (monotonicity @x32 (= $x12 (not true))) (rewrite (= (not true) false)) (= $x12 false))))
-(mp (asserted $x12) @x39 false)))))))))))
+(let ((@x50 (monotonicity (monotonicity (rewrite (= $x7 true)) (= (|p$| $x7) ?x10)) (= (= (|p$| $x7) ?x10) (= ?x10 ?x10)))))
+(let ((@x54 (trans @x50 (rewrite (= (= ?x10 ?x10) true)) (= (= (|p$| $x7) ?x10) true))))
+(let ((@x61 (trans (monotonicity @x54 (= (not (= (|p$| $x7) ?x10)) (not true))) (rewrite (= (not true) false)) (= (not (= (|p$| $x7) ?x10)) false))))
+(let ((@x41 (monotonicity (monotonicity (rewrite (= $x8 $x7)) (= ?x9 (|p$| $x7))) (= $x11 (= (|p$| $x7) ?x10)))))
+(let ((@x44 (monotonicity @x41 (= $x12 (not (= (|p$| $x7) ?x10))))))
+(mp (asserted $x12) (trans @x44 @x61 (= $x12 false)) false))))))))))))))