src/HOL/SMT_Examples/SMT_Examples.certs

tuned;

3aa17d1c77bc1a92bca05df291d11d81c645a931 6 0
unsat
((set-logic AUFLIA)
(proof
(let ((@x30 (rewrite (= (not true) false))))
(mp (asserted (not true)) @x30 false))))

572677daa32981bf8212986300f1362edf42a0c1 7 0
unsat
((set-logic AUFLIA)
(proof
(let ((@x36 (monotonicity (rewrite (= (or p$ (not p$)) true)) (= (not (or p$ (not p$))) (not true)))))
(let ((@x40 (trans @x36 (rewrite (= (not true) false)) (= (not (or p$ (not p$))) false))))
(mp (asserted (not (or p$ (not p$)))) @x40 false)))))

dfd95b23f80baacb2acdc442487bd8121f072035 9 0
unsat
((set-logic AUFLIA)
(proof
(let ((@x36 (monotonicity (rewrite (= (and p$ true) p$)) (= (= (and p$ true) p$) (= p$ p$)))))
(let ((@x40 (trans @x36 (rewrite (= (= p$ p$) true)) (= (= (and p$ true) p$) true))))
(let ((@x43 (monotonicity @x40 (= (not (= (and p$ true) p$)) (not true)))))
(let ((@x47 (trans @x43 (rewrite (= (not true) false)) (= (not (= (and p$ true) p$)) false))))
(mp (asserted (not (= (and p$ true) p$))) @x47 false)))))))

8d6b87f1242925c8eefb2ec3e8ab8eefcd64e572 13 0
unsat
((set-logic AUFLIA)
(proof
(let (($x33 (not (=> (and (or p$ q$) (not p$)) q$))))
(let (($x37 (= (=> (and (or p$ q$) (not p$)) q$) (or (not (and (or p$ q$) (not p$))) q$))))
(let ((@x41 (monotonicity (rewrite $x37) (= $x33 (not (or (not (and (or p$ q$) (not p$))) q$))))))
(let ((@x44 (mp (asserted $x33) @x41 (not (or (not (and (or p$ q$) (not p$))) q$)))))
(let ((@x45 (and-elim (not-or-elim @x44 (and (or p$ q$) (not p$))) (not p$))))
(let ((@x54 (monotonicity (iff-false @x45 (= p$ false)) (iff-false (not-or-elim @x44 (not q$)) (= q$ false)) (= (or p$ q$) (or false false)))))
(let ((@x58 (trans @x54 (rewrite (= (or false false) false)) (= (or p$ q$) false))))
(let (($x29 (or p$ q$)))
(mp (and-elim (not-or-elim @x44 (and $x29 (not p$))) $x29) @x58 false)))))))))))

a021a5fec5486f23204e54770f9c04c64baf7e25 11 0
unsat
((set-logic AUFLIA)
(proof
(let (($x32 (and c$ d$)))
(let (($x29 (and a$ b$)))
(let (($x33 (or $x29 $x32)))
(let (($x34 (=> $x33 $x33)))
(let (($x35 (not $x34)))
(let ((@x45 (trans (monotonicity (rewrite (= $x34 true)) (= $x35 (not true))) (rewrite (= (not true) false)) (= $x35 false))))
(mp (asserted $x35) @x45 false)))))))))

dfb7aeab4f33cdf91b335d72ad619dbd0d65fb62 23 0
unsat
((set-logic AUFLIA)
(proof
(let (($x33 (and p1$ p3$)))
(let (($x32 (and p3$ p2$)))
(let (($x34 (or $x32 $x33)))
(let (($x35 (=> p1$ $x34)))
(let (($x36 (or $x35 p1$)))
(let (($x29 (and p1$ p2$)))
(let (($x31 (or $x29 p3$)))
(let (($x37 (=> $x31 $x36)))
(let (($x38 (not $x37)))
(let (($x40 (not p1$)))
(let (($x41 (or $x40 $x34)))
(let (($x44 (or $x41 p1$)))
(let (($x50 (not $x31)))
(let (($x51 (or $x50 $x44)))
(let (($x56 (not $x51)))
(let ((@x67 (trans (monotonicity (rewrite (= $x51 true)) (= $x56 (not true))) (rewrite (= (not true) false)) (= $x56 false))))
(let ((@x49 (monotonicity (monotonicity (rewrite (= $x35 $x41)) (= $x36 $x44)) (= $x37 (=> $x31 $x44)))))
(let ((@x58 (monotonicity (trans @x49 (rewrite (= (=> $x31 $x44) $x51)) (= $x37 $x51)) (= $x38 $x56))))
(mp (asserted $x38) (trans @x58 @x67 (= $x38 false)) false)))))))))))))))))))))

3efca8956be216e9acda1b32436ba8f01358d35e 24 0
unsat
((set-logic AUFLIA)
(proof
(let (($x28 (= p$ p$)))
(let (($x29 (= $x28 p$)))
(let (($x30 (= $x29 p$)))
(let (($x31 (= $x30 p$)))
(let (($x32 (= $x31 p$)))
(let (($x33 (= $x32 p$)))
(let (($x34 (= $x33 p$)))
(let (($x35 (= $x34 p$)))
(let (($x36 (= $x35 p$)))
(let (($x37 (not $x36)))
(let ((@x40 (rewrite (= $x28 true))))
(let ((@x45 (rewrite (= (= true p$) p$))))
(let ((@x47 (trans (monotonicity @x40 (= $x29 (= true p$))) @x45 (= $x29 p$))))
(let ((@x53 (monotonicity (trans (monotonicity @x47 (= $x30 $x28)) @x40 (= $x30 true)) (= $x31 (= true p$)))))
(let ((@x59 (trans (monotonicity (trans @x53 @x45 (= $x31 p$)) (= $x32 $x28)) @x40 (= $x32 true))))
(let ((@x63 (trans (monotonicity @x59 (= $x33 (= true p$))) @x45 (= $x33 p$))))
(let ((@x69 (monotonicity (trans (monotonicity @x63 (= $x34 $x28)) @x40 (= $x34 true)) (= $x35 (= true p$)))))
(let ((@x75 (trans (monotonicity (trans @x69 @x45 (= $x35 p$)) (= $x36 $x28)) @x40 (= $x36 true))))
(let ((@x82 (trans (monotonicity @x75 (= $x37 (not true))) (rewrite (= (not true) false)) (= $x37 false))))
(mp (asserted $x37) @x82 false))))))))))))))))))))))

d600888ef4325a32ff87997035fed7a7c01e4767 39 0
unsat
((set-logic AUFLIA)
(proof
(let (($x100 (not d$)))
(let (($x45 (not c$)))
(let (($x112 (or p$ (and q$ (not q$)))))
(let (($x113 (and (not p$) $x112)))
(let (($x114 (or c$ $x113)))
(let (($x115 (not $x114)))
(let ((@x121 (monotonicity (rewrite (= (and q$ (not q$)) false)) (= $x112 (or p$ false)))))
(let ((@x128 (monotonicity (trans @x121 (rewrite (= (or p$ false) p$)) (= $x112 p$)) (= $x113 (and (not p$) p$)))))
(let ((@x132 (trans @x128 (rewrite (= (and (not p$) p$) false)) (= $x113 false))))
(let ((@x139 (trans (monotonicity @x132 (= $x114 (or c$ false))) (rewrite (= (or c$ false) c$)) (= $x114 c$))))
(let ((@x153 (iff-false (mp (asserted $x115) (monotonicity @x139 (= $x115 $x45)) $x45) (= c$ false))))
(let ((@x147 (trans (monotonicity @x153 (= (or $x100 c$) (or $x100 false))) (rewrite (= (or $x100 false) $x100)) (= (or $x100 c$) $x100))))
(let (($x103 (or $x100 c$)))
(let ((@x102 (monotonicity (rewrite (= (or d$ false) d$)) (= (not (or d$ false)) $x100))))
(let ((@x108 (mp (asserted (or (not (or d$ false)) c$)) (monotonicity @x102 (= (or (not (or d$ false)) c$) $x103)) $x103)))
(let (($x87 (not b$)))
(let ((@x164 (trans (monotonicity @x153 (= (or $x87 c$) (or $x87 false))) (rewrite (= (or $x87 false) $x87)) (= (or $x87 c$) $x87))))
(let (($x90 (or $x87 c$)))
(let ((@x82 (monotonicity (rewrite (= (or x$ (not x$)) true)) (= (and b$ (or x$ (not x$))) (and b$ true)))))
(let ((@x86 (trans @x82 (rewrite (= (and b$ true) b$)) (= (and b$ (or x$ (not x$))) b$))))
(let ((@x92 (monotonicity (monotonicity @x86 (= (not (and b$ (or x$ (not x$)))) $x87)) (= (or (not (and b$ (or x$ (not x$)))) c$) $x90))))
(let ((@x95 (mp (asserted (or (not (and b$ (or x$ (not x$)))) c$)) @x92 $x90)))
(let (($x64 (not a$)))
(let ((@x170 (monotonicity (iff-false (mp @x95 @x164 $x87) (= b$ false)) (= (or $x64 b$) (or $x64 false)))))
(let ((@x174 (trans @x170 (rewrite (= (or $x64 false) $x64)) (= (or $x64 b$) $x64))))
(let (($x67 (or $x64 b$)))
(let ((@x59 (monotonicity (rewrite (= (and c$ $x45) false)) (= (or a$ (and c$ $x45)) (or a$ false)))))
(let ((@x63 (trans @x59 (rewrite (= (or a$ false) a$)) (= (or a$ (and c$ $x45)) a$))))
(let ((@x69 (monotonicity (monotonicity @x63 (= (not (or a$ (and c$ $x45))) $x64)) (= (or (not (or a$ (and c$ $x45))) b$) $x67))))
(let ((@x175 (mp (mp (asserted (or (not (or a$ (and c$ $x45))) b$)) @x69 $x67) @x174 $x64)))
(let ((@x198 (monotonicity (iff-false @x175 (= a$ false)) (iff-false (mp @x95 @x164 $x87) (= b$ false)) @x153 (iff-false (mp @x108 @x147 $x100) (= d$ false)) (= (or a$ b$ c$ d$) (or false false false false)))))
(let ((@x202 (trans @x198 (rewrite (= (or false false false false) false)) (= (or a$ b$ c$ d$) false))))
(let (($x37 (or a$ b$ c$ d$)))
(let ((@x40 (mp (asserted (or a$ (or b$ (or c$ d$)))) (rewrite (= (or a$ (or b$ (or c$ d$))) $x37)) $x37)))
(mp @x40 @x202 false)))))))))))))))))))))))))))))))))))))

143f46ba7acb4b0a8f67b0de474b0a249f30985b 27 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x38 (symm_f$ b$ a$)))
(let ((?x37 (symm_f$ a$ b$)))
(let (($x39 (= ?x37 ?x38)))
(let (($x52 (not $x39)))
(let ((@x47 (monotonicity (rewrite (= (= a$ a$) true)) (= (and (= a$ a$) $x39) (and true $x39)))))
(let ((@x51 (trans @x47 (rewrite (= (and true $x39) $x39)) (= (and (= a$ a$) $x39) $x39))))
(let ((@x57 (mp (asserted (not (and (= a$ a$) $x39))) (monotonicity @x51 (= (not (and (= a$ a$) $x39)) $x52)) $x52)))
(let (($x480 (forall ((?v0 A$) (?v1 A$) )(! (let ((?x30 (symm_f$ ?v1 ?v0)))
(let ((?x29 (symm_f$ ?v0 ?v1)))
(= ?x29 ?x30))) :pattern ( (symm_f$ ?v0 ?v1) ) :pattern ( (symm_f$ ?v1 ?v0) ) :qid k!8))
))
(let (($x32 (forall ((?v0 A$) (?v1 A$) )(! (let ((?x30 (symm_f$ ?v1 ?v0)))
(let ((?x29 (symm_f$ ?v0 ?v1)))
(= ?x29 ?x30))) :qid k!8))
))
(let ((?x30 (symm_f$ ?0 ?1)))
(let ((?x29 (symm_f$ ?1 ?0)))
(let (($x31 (= ?x29 ?x30)))
(let ((@x60 (mp~ (asserted $x32) (nnf-pos (refl (~ $x31 $x31)) (~ $x32 $x32)) $x32)))
(let ((@x485 (mp @x60 (quant-intro (refl (= $x31 $x31)) (= $x32 $x480)) $x480)))
(let (($x149 (or (not $x480) $x39)))
(let ((@x61 ((_ quant-inst a$ b$) $x149)))
(unit-resolution @x61 @x485 @x57 false)))))))))))))))))))

a6dd135a0c109f49b36d7266dc7a6becc640e496 637 0
unsat
((set-logic AUFLIA)
(proof
(let (($x397 (not x38$)))
(let (($x553 (not x51$)))
(let (($x657 (not x25$)))
(let (($x610 (not x56$)))
(let (($x538 (not x17$)))
(let ((@x897 (hypothesis $x538)))
(let (($x482 (not x45$)))
(let (($x609 (not x22$)))
(let (($x453 (not x11$)))
(let ((@x815 (hypothesis $x453)))
(let (($x667 (not x27$)))
(let (($x638 (not x58$)))
(let (($x567 (not x52$)))
(let ((@x756 (hypothesis $x567)))
(let (($x509 (not x47$)))
(let (($x637 (not x24$)))
(let (($x566 (not x19$)))
(let (($x294 (or x24$ x53$)))
(let ((@x774 (monotonicity (iff-false (asserted (not x59$)) (= x59$ false)) (= (or x59$ x24$ x53$) (or false x24$ x53$)))))
(let ((@x778 (trans @x774 (rewrite (= (or false x24$ x53$) $x294)) (= (or x59$ x24$ x53$) $x294))))
(let (($x303 (or x59$ x24$ x53$)))
(let ((@x306 (mp (asserted (or x59$ $x294)) (rewrite (= (or x59$ $x294) $x303)) $x303)))
(let ((@x779 (mp @x306 @x778 $x294)))
(let ((@x1181 (unit-resolution @x779 (unit-resolution (asserted (or $x637 $x638)) (hypothesis x58$) $x637) x53$)))
(let (($x580 (not x53$)))
(let (($x581 (or $x580 $x566)))
(let ((@x582 (asserted $x581)))
(let ((@x1182 (unit-resolution @x582 @x1181 $x566)))
(let (($x496 (not x46$)))
(let (($x583 (or $x580 $x509)))
(let ((@x584 (asserted $x583)))
(let ((@x1183 (unit-resolution @x584 @x1181 $x509)))
(let (($x438 (not x41$)))
(let (($x363 (not x4$)))
(let (($x347 (not x2$)))
(let (($x336 (not x31$)))
(let (($x623 (not x23$)))
(let (($x645 (or $x638 $x623)))
(let ((@x646 (asserted $x645)))
(let ((@x974 (hypothesis $x509)))
(let ((@x757 (hypothesis $x566)))
(let ((@x853 (hypothesis $x397)))
(let (($x410 (not x8$)))
(let (($x355 (not x3$)))
(let (($x467 (not x12$)))
(let ((@x882 (hypothesis $x467)))
(let ((@x845 (hypothesis $x347)))
(let (($x356 (not x33$)))
(let (($x481 (not x13$)))
(let (($x424 (not x9$)))
(let ((@x728 (hypothesis x41$)))
(let (($x439 (or $x438 $x424)))
(let ((@x440 (asserted $x439)))
(let ((@x922 (unit-resolution @x440 @x728 $x424)))
(let (($x364 (not x34$)))
(let (($x72 (or x35$ x4$)))
(let ((@x77 (asserted $x72)))
(let ((@x994 (unit-resolution @x77 (unit-resolution (asserted (or $x438 (not x35$))) @x728 (not x35$)) x4$)))
(let (($x365 (or $x363 $x364)))
(let ((@x366 (asserted $x365)))
(let ((@x999 (unit-resolution @x366 @x994 $x364)))
(let (($x396 (not x7$)))
(let (($x414 (or $x410 $x396)))
(let ((@x415 (asserted $x414)))
(let (($x348 (not x32$)))
(let ((@x942 (hypothesis $x355)))
(let (($x64 (or x3$ x33$ x2$)))
(let ((@x67 (mp (asserted (or x3$ (or x33$ x2$))) (rewrite (= (or x3$ (or x33$ x2$)) $x64)) $x64)))
(let ((@x1048 (unit-resolution @x67 (unit-resolution (asserted (or $x410 $x356)) (hypothesis x8$) $x356) @x942 x2$)))
(let (($x349 (or $x347 $x348)))
(let ((@x350 (asserted $x349)))
(let (($x105 (or x7$ x38$ x6$ x32$)))
(let ((@x108 (mp (asserted (or x7$ (or x38$ (or x6$ x32$)))) (rewrite (= (or x7$ (or x38$ (or x6$ x32$))) $x105)) $x105)))
(let ((@x842 (unit-resolution @x108 (unit-resolution @x350 @x1048 $x348) (unit-resolution @x415 (hypothesis x8$) $x396) @x853 x6$)))
(let (($x701 (or x1$ x31$)))
(let ((@x700 (monotonicity (iff-false (asserted (not x0$)) (= x0$ false)) (= (or x1$ x31$ x0$) (or x1$ x31$ false)))))
(let ((@x705 (trans @x700 (rewrite (= (or x1$ x31$ false) $x701)) (= (or x1$ x31$ x0$) $x701))))
(let (($x46 (or x1$ x31$ x0$)))
(let ((@x49 (mp (asserted (or x1$ (or x31$ x0$))) (rewrite (= (or x1$ (or x31$ x0$)) $x46)) $x46)))
(let ((@x706 (mp @x49 @x705 $x701)))
(let ((@x1002 (unit-resolution @x706 (unit-resolution (asserted (or $x347 (not x1$))) @x1048 (not x1$)) x31$)))
(let (($x382 (not x6$)))
(let (($x388 (or $x382 $x336)))
(let ((@x389 (asserted $x388)))
(let ((@x1011 (lemma (unit-resolution @x389 @x1002 @x842 false) (or $x410 x38$ x3$))))
(let ((@x952 (unit-resolution @x1011 (unit-resolution (asserted (or $x363 $x355)) @x994 $x355) @x853 $x410)))
(let (($x125 (or x9$ x40$ x8$ x34$)))
(let ((@x128 (mp (asserted (or x9$ (or x40$ (or x8$ x34$)))) (rewrite (= (or x9$ (or x40$ (or x8$ x34$))) $x125)) $x125)))
(let (($x425 (not x40$)))
(let (($x505 (or $x496 $x425)))
(let ((@x506 (asserted $x505)))
(let ((@x868 (unit-resolution @x506 (unit-resolution @x128 @x952 @x999 @x922 x40$) $x496)))
(let (($x239 (or x19$ x52$ x18$ x46$)))
(let ((@x242 (mp (asserted (or x19$ (or x52$ (or x18$ x46$)))) (rewrite (= (or x19$ (or x52$ (or x18$ x46$))) $x239)) $x239)))
(let (($x411 (not x39$)))
(let ((@x992 (unit-resolution @x67 (unit-resolution (asserted (or $x363 $x355)) @x994 $x355) @x845 x33$)))
(let (($x420 (or $x411 $x356)))
(let ((@x421 (asserted $x420)))
(let (($x507 (or $x481 $x425)))
(let ((@x508 (asserted $x507)))
(let ((@x1036 (unit-resolution @x508 (unit-resolution @x128 @x952 @x999 @x922 x40$) $x481)))
(let (($x172 (or x13$ x45$ x12$ x39$)))
(let ((@x175 (mp (asserted (or x13$ (or x45$ (or x12$ x39$)))) (rewrite (= (or x13$ (or x45$ (or x12$ x39$))) $x172)) $x172)))
(let ((@x1037 (unit-resolution @x175 @x1036 @x882 (unit-resolution @x421 @x992 $x411) x45$)))
(let (($x552 (not x18$)))
(let (($x558 (or $x552 $x482)))
(let ((@x559 (asserted $x558)))
(let ((@x1080 (unit-resolution @x559 @x1037 (unit-resolution @x242 @x868 @x757 @x756 x18$) false)))
(let ((@x1051 (unit-resolution (lemma @x1080 (or $x438 x12$ x19$ x52$ x2$ x38$)) @x845 @x757 @x756 @x882 @x853 $x438)))
(let (($x190 (or x47$ x14$ x41$)))
(let ((@x193 (mp (asserted (or x47$ (or x14$ x41$))) (rewrite (= (or x47$ (or x14$ x41$)) $x190)) $x190)))
(let ((@x732 (unit-resolution @x193 @x1051 @x974 x14$)))
(let (($x495 (not x14$)))
(let (($x499 (or $x495 $x481)))
(let ((@x500 (asserted $x499)))
(let ((@x941 (unit-resolution @x242 (unit-resolution (asserted (or $x495 $x496)) @x732 $x496) @x757 @x756 x18$)))
(let ((@x991 (unit-resolution @x175 (unit-resolution @x559 @x941 $x482) @x882 (unit-resolution @x500 @x732 $x481) x39$)))
(let (($x367 (or $x363 $x355)))
(let ((@x368 (asserted $x367)))
(let ((@x980 (unit-resolution @x368 (unit-resolution @x67 (unit-resolution @x421 @x991 $x356) @x845 x3$) $x363)))
(let (($x369 (or $x364 $x355)))
(let ((@x370 (asserted $x369)))
(let ((@x878 (unit-resolution @x370 (unit-resolution @x67 (unit-resolution @x421 @x991 $x356) @x845 x3$) $x364)))
(let ((@x879 (unit-resolution @x128 @x878 (unit-resolution (asserted (or $x495 $x425)) @x732 $x425) (unit-resolution (asserted (or $x410 $x411)) @x991 $x410) x9$)))
(let (($x371 (not x35$)))
(let (($x443 (or $x424 $x371)))
(let ((@x444 (asserted $x443)))
(let ((@x912 (lemma (unit-resolution @x444 @x879 (unit-resolution @x77 @x980 x35$) false) (or x2$ x12$ x19$ x52$ x47$ x38$))))
(let ((@x1091 (unit-resolution @x912 @x882 @x757 @x756 @x974 @x853 x2$)))
(let (($x359 (or $x355 $x347)))
(let ((@x360 (asserted $x359)))
(let ((@x784 (unit-resolution @x706 (unit-resolution (asserted (or $x347 (not x1$))) @x1091 (not x1$)) x31$)))
(let ((@x808 (unit-resolution @x108 (unit-resolution @x389 @x784 $x382) (unit-resolution @x350 @x1091 $x348) @x853 x7$)))
(let (($x418 (or $x411 $x396)))
(let ((@x419 (asserted $x418)))
(let ((@x913 (hypothesis $x410)))
(let ((@x931 (unit-resolution @x193 (unit-resolution @x500 (hypothesis x13$) $x495) @x974 x41$)))
(let ((@x867 (unit-resolution @x128 (unit-resolution @x440 @x931 $x424) (unit-resolution @x508 (hypothesis x13$) $x425) @x913 x34$)))
(let ((@x917 (unit-resolution @x77 (unit-resolution (asserted (or $x438 $x371)) @x931 $x371) x4$)))
(let ((@x1090 (lemma (unit-resolution @x366 @x917 @x867 false) (or $x481 x8$ x47$))))
(let ((@x1056 (unit-resolution @x1090 (unit-resolution @x1011 (unit-resolution @x360 @x1091 $x355) @x853 $x410) @x974 $x481)))
(let ((@x1057 (unit-resolution @x175 @x1056 @x882 (unit-resolution @x419 @x808 $x411) x45$)))
(let ((@x937 (unit-resolution @x242 (unit-resolution @x559 @x1057 $x552) @x757 @x756 x46$)))
(let ((@x884 (unit-resolution @x193 (unit-resolution (asserted (or $x495 $x496)) @x937 $x495) @x974 x41$)))
(let ((@x800 (unit-resolution @x128 (unit-resolution @x440 @x884 $x424) (unit-resolution @x506 @x937 $x425) (unit-resolution @x1011 (unit-resolution @x360 @x1091 $x355) @x853 $x410) x34$)))
(let ((@x864 (unit-resolution @x77 (unit-resolution (asserted (or $x438 $x371)) @x884 $x371) x4$)))
(let ((@x1089 (lemma (unit-resolution @x366 @x864 @x800 false) (or x12$ x47$ x19$ x52$ x38$))))
(let ((@x1116 (unit-resolution @x1089 @x853 @x757 @x756 @x974 x12$)))
(let (($x489 (or $x482 $x467)))
(let ((@x490 (asserted $x489)))
(let (($x539 (not x50$)))
(let (($x619 (or $x610 $x539)))
(let ((@x620 (asserted $x619)))
(let ((@x1058 (unit-resolution @x620 (hypothesis x56$) $x539)))
(let (($x524 (not x16$)))
(let (($x587 (not x20$)))
(let ((@x896 (hypothesis $x539)))
(let (($x517 (not x48$)))
(let ((@x841 (hypothesis $x517)))
(let ((@x989 (unit-resolution @x193 (unit-resolution (asserted (or $x495 $x496)) (hypothesis x46$) $x495) @x974 x41$)))
(let (($x441 (or $x438 $x371)))
(let ((@x442 (asserted $x441)))
(let ((@x838 (unit-resolution @x368 (unit-resolution @x77 (unit-resolution @x442 @x989 $x371) x4$) $x355)))
(let ((@x1053 (unit-resolution @x366 (unit-resolution @x77 (unit-resolution @x442 @x989 $x371) x4$) $x364)))
(let ((@x862 (unit-resolution @x128 @x1053 (unit-resolution @x440 @x989 $x424) (unit-resolution @x506 (hypothesis x46$) $x425) x8$)))
(let (($x416 (or $x410 $x356)))
(let ((@x417 (asserted $x416)))
(let ((@x987 (unit-resolution @x350 (unit-resolution @x67 (unit-resolution @x417 @x862 $x356) @x838 x2$) $x348)))
(let (($x335 (not x1$)))
(let (($x351 (or $x347 $x335)))
(let ((@x352 (asserted $x351)))
(let ((@x935 (unit-resolution @x352 (unit-resolution @x67 (unit-resolution @x417 @x862 $x356) @x838 x2$) $x335)))
(let ((@x746 (unit-resolution @x706 @x935 x31$)))
(let ((@x1060 (unit-resolution @x108 (unit-resolution @x389 @x746 $x382) (unit-resolution @x415 @x862 $x396) @x987 x38$)))
(let (($x479 (or $x453 $x397)))
(let ((@x480 (asserted $x479)))
(let (($x445 (not x10$)))
(let (($x720 (or x5$ x36$)))
(let ((@x719 (monotonicity (iff-false (asserted (not x30$)) (= x30$ false)) (= (or x5$ x36$ x30$) (or x5$ x36$ false)))))
(let ((@x724 (trans @x719 (rewrite (= (or x5$ x36$ false) $x720)) (= (or x5$ x36$ x30$) $x720))))
(let (($x85 (or x5$ x36$ x30$)))
(let ((@x88 (mp (asserted (or x5$ (or x36$ x30$))) (rewrite (= (or x5$ (or x36$ x30$)) $x85)) $x85)))
(let ((@x725 (mp @x88 @x724 $x720)))
(let ((@x810 (unit-resolution @x725 (unit-resolution (asserted (or (not x5$) $x336)) @x746 (not x5$)) x36$)))
(let (($x375 (not x36$)))
(let (($x449 (or $x445 $x375)))
(let ((@x450 (asserted $x449)))
(let (($x152 (or x11$ x43$ x10$ x37$)))
(let ((@x155 (mp (asserted (or x11$ (or x43$ (or x10$ x37$)))) (rewrite (= (or x11$ (or x43$ (or x10$ x37$))) $x152)) $x152)))
(let ((@x840 (unit-resolution @x155 (unit-resolution @x450 @x810 $x445) (unit-resolution (asserted (or (not x37$) $x336)) @x746 (not x37$)) (unit-resolution @x480 @x1060 $x453) x43$)))
(let (($x199 (or x15$ x48$ x42$)))
(let ((@x202 (mp (asserted (or x15$ (or x48$ x42$))) (rewrite (= (or x15$ (or x48$ x42$)) $x199)) $x199)))
(let ((@x712 (unit-resolution @x202 (unit-resolution (asserted (or (not x42$) $x375)) @x810 (not x42$)) @x841 x15$)))
(let (($x454 (not x43$)))
(let (($x516 (not x15$)))
(let (($x536 (or $x516 $x454)))
(let ((@x537 (asserted $x536)))
(let ((@x844 (lemma (unit-resolution @x537 @x712 @x840 false) (or $x496 x48$ x47$))))
(let ((@x893 (unit-resolution @x242 (unit-resolution @x844 @x841 @x974 $x496) @x757 @x756 x18$)))
(let (($x556 (or $x552 $x538)))
(let ((@x557 (asserted $x556)))
(let (($x446 (not x42$)))
(let ((@x1023 (unit-resolution @x559 @x893 $x482)))
(let (($x468 (not x44$)))
(let ((@x738 (unit-resolution @x725 (unit-resolution (asserted (or $x446 $x375)) (hypothesis x42$) $x375) x5$)))
(let (($x374 (not x5$)))
(let (($x394 (or $x374 $x336)))
(let ((@x395 (asserted $x394)))
(let (($x353 (or $x348 $x335)))
(let ((@x354 (asserted $x353)))
(let ((@x1005 (unit-resolution @x354 (unit-resolution @x706 (unit-resolution @x395 @x738 $x336) x1$) $x348)))
(let ((@x983 (unit-resolution @x352 (unit-resolution @x706 (unit-resolution @x395 @x738 $x336) x1$) $x347)))
(let ((@x998 (hypothesis $x482)))
(let ((@x932 (unit-resolution @x128 (unit-resolution @x417 @x992 $x410) @x922 @x999 x40$)))
(let ((@x1030 (hypothesis $x348)))
(let ((@x1031 (hypothesis $x382)))
(let ((@x1039 (unit-resolution @x108 (unit-resolution (asserted (or $x396 $x356)) @x992 $x396) @x1031 @x1030 x38$)))
(let (($x473 (or $x467 $x397)))
(let ((@x474 (asserted $x473)))
(let ((@x971 (unit-resolution @x175 (unit-resolution @x474 @x1039 $x467) (unit-resolution @x508 @x932 $x481) @x998 (unit-resolution @x421 @x992 $x411) false)))
(let ((@x1013 (lemma @x971 (or $x438 x45$ x6$ x32$ x2$))))
(let ((@x1040 (unit-resolution @x1013 (unit-resolution (asserted (or $x382 $x374)) @x738 $x382) @x998 @x1005 @x983 $x438)))
(let (($x447 (or $x445 $x446)))
(let ((@x448 (asserted $x447)))
(let ((@x830 (unit-resolution @x448 (hypothesis x42$) $x445)))
(let ((@x1020 (hypothesis x12$)))
(let (($x469 (or $x467 $x468)))
(let ((@x470 (asserted $x469)))
(let ((@x1021 (unit-resolution @x470 @x1020 $x468)))
(let (($x219 (or x17$ x50$ x16$ x44$)))
(let ((@x222 (mp (asserted (or x17$ (or x50$ (or x16$ x44$)))) (rewrite (= (or x17$ (or x50$ (or x16$ x44$))) $x219)) $x219)))
(let (($x471 (or $x467 $x453)))
(let ((@x472 (asserted $x471)))
(let ((@x889 (unit-resolution @x472 @x1020 $x453)))
(let ((@x924 (unit-resolution @x155 @x889 (hypothesis $x445) (hypothesis (not x37$)) x43$)))
(let (($x530 (or $x524 $x454)))
(let ((@x531 (asserted $x530)))
(let ((@x925 (unit-resolution @x531 @x924 (unit-resolution @x222 @x1021 @x897 @x896 x16$) false)))
(let ((@x1075 (lemma @x925 (or $x467 x10$ x37$ x17$ x50$))))
(let ((@x831 (unit-resolution @x1075 @x830 (unit-resolution (asserted (or (not x37$) $x374)) @x738 (not x37$)) @x897 @x896 $x467)))
(let ((@x856 (unit-resolution @x175 @x831 @x998 (unit-resolution @x500 (unit-resolution @x193 @x1040 @x974 x14$) $x481) x39$)))
(let ((@x715 (unit-resolution @x108 (unit-resolution @x419 @x856 $x396) (unit-resolution (asserted (or $x382 $x374)) @x738 $x382) @x1005 x38$)))
(let (($x477 (or $x468 $x397)))
(let ((@x478 (asserted $x477)))
(let ((@x850 (unit-resolution @x222 (unit-resolution @x478 @x715 $x468) @x897 @x896 x16$)))
(let ((@x828 (unit-resolution @x155 (unit-resolution @x480 @x715 $x453) @x830 (unit-resolution (asserted (or (not x37$) $x374)) @x738 (not x37$)) x43$)))
(let ((@x1001 (lemma (unit-resolution @x531 @x828 @x850 false) (or $x446 x17$ x50$ x45$ x47$))))
(let ((@x762 (unit-resolution @x1001 (unit-resolution @x557 @x893 $x538) @x896 @x1023 @x974 $x446)))
(let (($x528 (or $x524 $x516)))
(let ((@x529 (asserted $x528)))
(let ((@x1017 (unit-resolution @x222 (unit-resolution @x529 (unit-resolution @x202 @x762 @x841 x15$) $x524) (unit-resolution @x557 @x893 $x538) @x896 x44$)))
(let ((@x901 (unit-resolution @x706 (unit-resolution @x395 (hypothesis x5$) $x336) x1$)))
(let ((@x823 (unit-resolution @x108 (unit-resolution @x354 @x901 $x348) @x853 (unit-resolution (asserted (or $x382 $x374)) (hypothesis x5$) $x382) x7$)))
(let ((@x740 (unit-resolution @x1013 (unit-resolution @x354 @x901 $x348) @x998 (unit-resolution (asserted (or $x382 $x374)) (hypothesis x5$) $x382) (unit-resolution @x352 @x901 $x347) $x438)))
(let ((@x835 (unit-resolution @x175 (unit-resolution @x500 (unit-resolution @x193 @x740 @x974 x14$) $x481) (unit-resolution @x419 @x823 $x411) @x998 @x882 false)))
(let ((@x769 (lemma @x835 (or $x374 x45$ x12$ x47$ x38$))))
(let ((@x898 (unit-resolution @x769 @x1023 (unit-resolution @x470 @x1017 $x467) @x974 (unit-resolution @x478 @x1017 $x397) $x374)))
(let ((@x735 (unit-resolution @x155 (unit-resolution @x450 (unit-resolution @x725 @x898 x36$) $x445) (unit-resolution @x537 (unit-resolution @x202 @x762 @x841 x15$) $x454) (unit-resolution (asserted (or $x468 $x453)) @x1017 $x453) x37$)))
(let (($x383 (not x37$)))
(let (($x384 (or $x382 $x383)))
(let ((@x385 (asserted $x384)))
(let ((@x946 (unit-resolution @x706 (unit-resolution (asserted (or $x383 $x336)) @x735 $x336) x1$)))
(let ((@x836 (unit-resolution @x108 (unit-resolution @x354 @x946 $x348) (unit-resolution @x478 @x1017 $x397) (unit-resolution @x385 @x735 $x382) x7$)))
(let ((@x1025 (unit-resolution @x1013 (unit-resolution @x354 @x946 $x348) @x1023 (unit-resolution @x385 @x735 $x382) (unit-resolution @x352 @x946 $x347) $x438)))
(let ((@x886 (unit-resolution @x175 (unit-resolution @x500 (unit-resolution @x193 @x1025 @x974 x14$) $x481) (unit-resolution @x419 @x836 $x411) @x1023 (unit-resolution @x470 @x1017 $x467) false)))
(let ((@x1059 (unit-resolution (lemma @x886 (or x48$ x47$ x50$ x19$ x52$)) @x1058 @x974 @x757 @x756 x48$)))
(let (($x591 (or $x587 $x517)))
(let ((@x592 (asserted $x591)))
(let (($x595 (not x21$)))
(let (($x617 (or $x610 $x595)))
(let ((@x618 (asserted $x617)))
(let (($x596 (not x55$)))
(let (($x302 (or x25$ x54$)))
(let ((@x307 (asserted $x302)))
(let ((@x855 (unit-resolution @x307 (unit-resolution (asserted (or (not x54$) $x517)) @x1059 (not x54$)) x25$)))
(let (($x665 (or $x657 $x596)))
(let ((@x666 (asserted $x665)))
(let (($x266 (or x21$ x55$ x20$ x49$)))
(let ((@x269 (mp (asserted (or x21$ (or x55$ (or x20$ x49$)))) (rewrite (= (or x21$ (or x55$ (or x20$ x49$))) $x266)) $x266)))
(let ((@x911 (unit-resolution @x269 (unit-resolution @x666 @x855 $x596) (unit-resolution @x618 (hypothesis x56$) $x595) (unit-resolution @x592 @x1059 $x587) x49$)))
(let (($x525 (not x49$)))
(let (($x526 (or $x524 $x525)))
(let ((@x527 (asserted $x526)))
(let ((@x1006 (unit-resolution @x242 (unit-resolution @x557 (hypothesis x17$) $x552) @x757 @x756 x46$)))
(let (($x503 (or $x496 $x481)))
(let ((@x504 (asserted $x503)))
(let ((@x752 (unit-resolution @x175 (unit-resolution @x504 @x1006 $x481) (unit-resolution (asserted (or $x538 $x482)) (hypothesis x17$) $x482) @x882 x39$)))
(let (($x412 (or $x410 $x411)))
(let ((@x413 (asserted $x412)))
(let ((@x806 (unit-resolution @x193 (unit-resolution (asserted (or $x495 $x496)) @x1006 $x495) @x974 x41$)))
(let ((@x954 (unit-resolution @x128 (unit-resolution @x440 @x806 $x424) (unit-resolution @x506 @x1006 $x425) (unit-resolution @x413 @x752 $x410) x34$)))
(let ((@x745 (unit-resolution @x366 (unit-resolution @x77 (unit-resolution @x442 @x806 $x371) x4$) @x954 false)))
(let ((@x771 (lemma @x745 (or $x538 x12$ x47$ x19$ x52$))))
(let ((@x928 (unit-resolution @x222 (unit-resolution @x771 @x882 @x974 @x757 @x756 $x538) (hypothesis $x524) @x896 x44$)))
(let ((@x929 (unit-resolution @x478 @x928 $x397)))
(let ((@x832 (hypothesis $x454)))
(let ((@x859 (unit-resolution @x242 (unit-resolution (asserted (or $x495 $x496)) (hypothesis x14$) $x496) @x757 @x756 x18$)))
(let ((@x951 (unit-resolution @x175 (unit-resolution @x559 @x859 $x482) (unit-resolution @x500 (hypothesis x14$) $x481) @x882 x39$)))
(let ((@x833 (unit-resolution @x769 (unit-resolution @x559 @x859 $x482) @x882 @x974 @x853 $x374)))
(let ((@x1076 (unit-resolution @x155 (unit-resolution @x450 (unit-resolution @x725 @x833 x36$) $x445) @x832 @x815 x37$)))
(let ((@x872 (unit-resolution @x108 (unit-resolution @x385 @x1076 $x382) (unit-resolution @x419 @x951 $x396) @x853 x32$)))
(let ((@x962 (unit-resolution @x706 (unit-resolution (asserted (or $x383 $x336)) @x1076 $x336) x1$)))
(let ((@x861 (lemma (unit-resolution @x354 @x962 @x872 false) (or $x495 x38$ x43$ x11$ x12$ x47$ x19$ x52$))))
(let ((@x1079 (unit-resolution @x861 @x929 @x832 (unit-resolution (asserted (or $x468 $x453)) @x928 $x453) @x882 @x974 @x757 @x756 $x495)))
(let ((@x709 (unit-resolution @x77 (unit-resolution @x442 (unit-resolution @x193 @x1079 @x974 x41$) $x371) x4$)))
(let ((@x939 (unit-resolution @x128 (unit-resolution @x1011 @x929 (unit-resolution @x368 @x709 $x355) $x410) (unit-resolution @x440 (unit-resolution @x193 @x1079 @x974 x41$) $x424) (unit-resolution @x366 @x709 $x364) x40$)))
(let ((@x754 (unit-resolution @x242 (unit-resolution @x506 @x939 $x496) @x757 @x756 x18$)))
(let ((@x904 (unit-resolution @x175 (unit-resolution @x559 @x754 $x482) (unit-resolution @x508 @x939 $x481) @x882 x39$)))
(let ((@x877 (unit-resolution @x67 (unit-resolution @x421 @x904 $x356) (unit-resolution @x368 @x709 $x355) x2$)))
(let ((@x927 (unit-resolution @x769 (unit-resolution @x559 @x754 $x482) @x882 @x974 @x929 $x374)))
(let ((@x880 (unit-resolution @x155 (unit-resolution @x450 (unit-resolution @x725 @x927 x36$) $x445) @x832 (unit-resolution (asserted (or $x468 $x453)) @x928 $x453) x37$)))
(let ((@x812 (unit-resolution @x108 (unit-resolution @x385 @x880 $x382) (unit-resolution @x350 @x877 $x348) (unit-resolution @x419 @x904 $x396) @x929 false)))
(let ((@x713 (unit-resolution (lemma @x812 (or x12$ x43$ x47$ x19$ x52$ x16$ x50$)) (unit-resolution (asserted (or $x525 $x454)) @x911 $x454) @x974 @x757 @x756 (unit-resolution @x527 @x911 $x524) @x1058 x12$)))
(let ((@x817 (unit-resolution @x222 (unit-resolution @x470 @x713 $x468) (unit-resolution @x527 @x911 $x524) @x1058 x17$)))
(let ((@x903 (unit-resolution @x242 (unit-resolution @x557 @x817 $x552) @x757 @x756 x46$)))
(let (($x497 (or $x495 $x496)))
(let ((@x498 (asserted $x497)))
(let ((@x748 (unit-resolution @x442 (unit-resolution @x193 (unit-resolution @x498 @x903 $x495) @x974 x41$) $x371)))
(let ((@x1027 (unit-resolution @x440 (unit-resolution @x193 (unit-resolution @x498 @x903 $x495) @x974 x41$) $x424)))
(let ((@x890 (unit-resolution @x128 (unit-resolution @x366 (unit-resolution @x77 @x748 x4$) $x364) (unit-resolution @x506 @x903 $x425) @x1027 x8$)))
(let ((@x891 (unit-resolution @x1011 @x890 (unit-resolution @x368 (unit-resolution @x77 @x748 x4$) $x355) (unit-resolution @x474 @x713 $x397) false)))
(let ((@x1118 (unit-resolution (lemma @x891 (or $x610 x47$ x19$ x52$)) @x974 @x757 @x756 $x610)))
(let ((@x802 (hypothesis $x623)))
(let ((@x914 (hypothesis $x610)))
(let (($x392 (or $x383 $x336)))
(let ((@x393 (asserted $x392)))
(let ((@x969 (unit-resolution @x393 (hypothesis x31$) $x383)))
(let ((@x1047 (unit-resolution @x725 (unit-resolution @x395 (hypothesis x31$) $x374) x36$)))
(let ((@x966 (unit-resolution @x450 @x1047 $x445)))
(let (($x615 (or $x609 $x539)))
(let ((@x616 (asserted $x615)))
(let ((@x730 (unit-resolution @x616 (unit-resolution @x1075 @x966 @x1020 @x897 @x969 x50$) $x609)))
(let (($x286 (or x23$ x57$ x22$ x51$)))
(let ((@x289 (mp (asserted (or x23$ (or x57$ (or x22$ x51$)))) (rewrite (= (or x23$ (or x57$ (or x22$ x51$))) $x286)) $x286)))
(let (($x624 (not x57$)))
(let (($x679 (or $x667 $x624)))
(let ((@x680 (asserted $x679)))
(let ((@x948 (unit-resolution @x680 (unit-resolution @x289 @x730 @x802 (hypothesis $x553) x57$) $x667)))
(let (($x322 (or x27$ x26$ x56$)))
(let ((@x325 (mp (asserted (or x27$ (or x26$ x56$))) (rewrite (= (or x27$ (or x26$ x56$)) $x322)) $x322)))
(let (($x588 (not x54$)))
(let ((@x798 (unit-resolution @x537 (unit-resolution @x155 @x966 @x889 @x969 x43$) $x516)))
(let ((@x799 (unit-resolution @x202 @x798 (unit-resolution (asserted (or $x446 $x375)) @x1047 $x446) x48$)))
(let (($x593 (or $x588 $x517)))
(let ((@x594 (asserted $x593)))
(let (($x660 (not x26$)))
(let (($x661 (or $x660 $x657)))
(let ((@x662 (asserted $x661)))
(let ((@x1094 (unit-resolution @x662 (unit-resolution @x307 (unit-resolution @x594 @x799 $x588) x25$) (unit-resolution @x325 @x948 @x914 x26$) false)))
(let ((@x1096 (lemma @x1094 (or $x336 x56$ x23$ x51$ $x467 x17$))))
(let ((@x1099 (unit-resolution @x1096 (unit-resolution (asserted (or $x552 $x553)) @x859 $x553) @x802 @x914 @x1020 (unit-resolution @x557 @x859 $x538) $x336)))
(let ((@x804 (unit-resolution @x725 (unit-resolution (asserted (or $x382 $x374)) (hypothesis x6$) $x374) x36$)))
(let ((@x1008 (unit-resolution @x1075 (unit-resolution @x450 @x804 $x445) @x1020 @x897 (unit-resolution @x385 (hypothesis x6$) $x383) x50$)))
(let ((@x874 (unit-resolution @x289 (unit-resolution @x616 @x1008 $x609) @x802 (hypothesis $x553) x57$)))
(let ((@x766 (unit-resolution @x155 (unit-resolution @x450 @x804 $x445) @x889 (unit-resolution @x385 (hypothesis x6$) $x383) x43$)))
(let ((@x818 (unit-resolution @x202 (unit-resolution @x537 @x766 $x516) (unit-resolution (asserted (or $x446 $x375)) @x804 $x446) x48$)))
(let ((@x783 (unit-resolution @x662 (unit-resolution @x307 (unit-resolution @x594 @x818 $x588) x25$) (unit-resolution @x325 (unit-resolution @x680 @x874 $x667) @x914 x26$) false)))
(let ((@x737 (lemma @x783 (or $x382 x56$ x23$ x51$ $x467 x17$))))
(let ((@x1102 (unit-resolution @x737 (unit-resolution (asserted (or $x552 $x553)) @x859 $x553) @x802 @x914 @x1020 (unit-resolution @x557 @x859 $x538) $x382)))
(let ((@x1104 (unit-resolution @x108 (unit-resolution @x354 (unit-resolution @x706 @x1099 x1$) $x348) @x1102 @x853 x7$)))
(let (($x422 (or $x396 $x356)))
(let ((@x423 (asserted $x422)))
(let ((@x1106 (unit-resolution @x67 (unit-resolution @x423 @x1104 $x356) (unit-resolution @x352 (unit-resolution @x706 @x1099 x1$) $x347) x3$)))
(let ((@x1112 (unit-resolution @x128 (unit-resolution @x370 @x1106 $x364) (unit-resolution (asserted (or $x495 $x425)) (hypothesis x14$) $x425) (unit-resolution @x415 @x1104 $x410) x9$)))
(let ((@x1113 (unit-resolution @x444 @x1112 (unit-resolution @x77 (unit-resolution @x368 @x1106 $x363) x35$) false)))
(let ((@x1119 (unit-resolution (lemma @x1113 (or $x495 x38$ x23$ x56$ $x467 x19$ x52$)) @x853 @x802 @x1118 @x1116 @x757 @x756 $x495)))
(let ((@x1120 (unit-resolution @x193 @x1119 @x974 x41$)))
(let ((@x1123 (unit-resolution @x366 (unit-resolution @x77 (unit-resolution @x442 @x1120 $x371) x4$) $x364)))
(let ((@x1125 (unit-resolution @x368 (unit-resolution @x77 (unit-resolution @x442 @x1120 $x371) x4$) $x355)))
(let ((@x1127 (unit-resolution @x128 (unit-resolution @x1011 @x1125 @x853 $x410) (unit-resolution @x440 @x1120 $x424) @x1123 x40$)))
(let ((@x1129 (unit-resolution @x242 (unit-resolution @x506 @x1127 $x496) @x757 @x756 x18$)))
(let ((@x1132 (unit-resolution @x737 (unit-resolution (asserted (or $x552 $x553)) @x1129 $x553) @x802 @x1118 @x1116 (unit-resolution @x557 @x1129 $x538) $x382)))
(let ((@x1133 (unit-resolution @x1096 (unit-resolution (asserted (or $x552 $x553)) @x1129 $x553) @x802 @x1118 @x1116 (unit-resolution @x557 @x1129 $x538) $x336)))
(let ((@x1137 (unit-resolution @x1013 (unit-resolution @x354 (unit-resolution @x706 @x1133 x1$) $x348) (unit-resolution @x352 (unit-resolution @x706 @x1133 x1$) $x347) @x1120 @x1132 (unit-resolution @x490 @x1116 $x482) false)))
(let ((@x1185 (unit-resolution (lemma @x1137 (or x38$ x23$ x19$ x52$ x47$)) (unit-resolution @x646 (hypothesis x58$) $x623) @x1182 @x756 @x1183 x38$)))
(let ((@x1188 (unit-resolution @x474 @x1185 $x467)))
(let ((@x1140 (unit-resolution @x155 @x966 @x815 @x969 x43$)))
(let (($x534 (or $x525 $x454)))
(let ((@x535 (asserted $x534)))
(let ((@x1142 (hypothesis $x468)))
(let ((@x1144 (unit-resolution @x222 (unit-resolution @x531 @x1140 $x524) @x897 @x1142 x50$)))
(let (($x621 (or $x595 $x539)))
(let ((@x622 (asserted $x621)))
(let ((@x1147 (unit-resolution @x202 (unit-resolution @x537 @x1140 $x516) (unit-resolution (asserted (or $x446 $x375)) @x1047 $x446) x48$)))
(let ((@x1149 (unit-resolution @x269 (unit-resolution @x592 @x1147 $x587) (unit-resolution @x622 @x1144 $x595) (unit-resolution @x535 @x1140 $x525) x55$)))
(let ((@x1152 (unit-resolution @x666 (unit-resolution @x307 (unit-resolution @x594 @x1147 $x588) x25$) @x1149 false)))
(let ((@x1154 (lemma @x1152 (or $x336 x17$ x44$ x11$))))
(let ((@x1190 (unit-resolution @x1154 (unit-resolution @x771 @x1188 @x1183 @x1182 @x756 $x538) (unit-resolution @x478 @x1185 $x468) (unit-resolution @x480 @x1185 $x453) $x336)))
(let ((@x1156 (unit-resolution @x559 (unit-resolution @x1013 @x728 @x1030 @x1031 @x845 x45$) $x552)))
(let ((@x1159 (unit-resolution @x506 (unit-resolution @x128 @x999 @x913 @x922 x40$) (unit-resolution @x242 @x1156 @x757 @x756 x46$) false)))
(let ((@x1163 (unit-resolution (lemma @x1159 (or $x438 x8$ x19$ x52$ x32$ x6$ x2$)) @x913 @x757 @x756 @x1030 @x1031 @x845 $x438)))
(let ((@x1166 (unit-resolution @x242 (unit-resolution @x498 (unit-resolution @x193 @x1163 @x974 x14$) $x496) @x757 @x756 x18$)))
(let ((@x1168 (unit-resolution @x175 (unit-resolution @x559 @x1166 $x482) @x882 (unit-resolution @x1090 @x913 @x974 $x481) x39$)))
(let ((@x1171 (unit-resolution @x368 (unit-resolution @x67 (unit-resolution @x421 @x1168 $x356) @x845 x3$) $x363)))
(let (($x501 (or $x495 $x425)))
(let ((@x502 (asserted $x501)))
(let ((@x1174 (unit-resolution @x370 (unit-resolution @x67 (unit-resolution @x421 @x1168 $x356) @x845 x3$) $x364)))
(let ((@x1175 (unit-resolution @x128 @x1174 @x913 (unit-resolution @x502 (unit-resolution @x193 @x1163 @x974 x14$) $x425) x9$)))
(let ((@x1178 (lemma (unit-resolution @x444 @x1175 (unit-resolution @x77 @x1171 x35$) false) (or x8$ x2$ x12$ x19$ x52$ x47$ x32$ x6$))))
(let ((@x1195 (unit-resolution @x1178 (unit-resolution @x352 (unit-resolution @x706 @x1190 x1$) $x347) @x1188 @x1182 @x756 @x1183 (unit-resolution (asserted (or $x397 $x348)) @x1185 $x348) (unit-resolution (asserted (or $x397 $x382)) @x1185 $x382) x8$)))
(let ((@x1197 (unit-resolution @x67 (unit-resolution @x417 @x1195 $x356) (unit-resolution @x352 (unit-resolution @x706 @x1190 x1$) $x347) x3$)))
(let ((@x1200 (unit-resolution @x442 (unit-resolution @x77 (unit-resolution @x368 @x1197 $x363) x35$) $x438)))
(let ((@x1203 (unit-resolution @x242 (unit-resolution @x498 (unit-resolution @x193 @x1200 @x1183 x14$) $x496) @x1182 @x756 x18$)))
(let ((@x1206 (unit-resolution @x175 (unit-resolution @x500 (unit-resolution @x193 @x1200 @x1183 x14$) $x481) @x1188 (unit-resolution @x413 @x1195 $x411) x45$)))
(let ((@x1215 (unit-resolution (lemma (unit-resolution @x559 @x1206 @x1203 false) (or $x638 x52$)) @x756 $x638)))
(let (($x328 (or x28$ x58$)))
(let ((@x792 (monotonicity (iff-false (asserted (not x29$)) (= x29$ false)) (= (or x29$ x28$ x58$) (or false x28$ x58$)))))
(let ((@x796 (trans @x792 (rewrite (= (or false x28$ x58$) $x328)) (= (or x29$ x28$ x58$) $x328))))
(let (($x337 (or x29$ x28$ x58$)))
(let ((@x340 (mp (asserted (or x29$ $x328)) (rewrite (= (or x29$ $x328) $x337)) $x337)))
(let ((@x797 (mp @x340 @x796 $x328)))
(let (($x674 (not x28$)))
(let (($x675 (or $x674 $x667)))
(let ((@x676 (asserted $x675)))
(let ((@x1224 (unit-resolution @x676 (unit-resolution @x797 @x1215 x28$) $x667)))
(let ((@x1285 (hypothesis $x438)))
(let ((@x708 (hypothesis $x411)))
(let ((@x1210 (hypothesis $x496)))
(let ((@x1213 (unit-resolution @x242 (unit-resolution (asserted (or $x566 $x509)) (hypothesis x47$) $x566) @x1210 @x756 x18$)))
(let (($x554 (or $x552 $x553)))
(let ((@x555 (asserted $x554)))
(let (($x677 (or $x674 $x624)))
(let ((@x678 (asserted $x677)))
(let ((@x1217 (unit-resolution @x678 (unit-resolution @x797 @x1215 x28$) $x624)))
(let ((@x1219 (unit-resolution @x779 (unit-resolution @x584 (hypothesis x47$) $x580) x24$)))
(let (($x641 (or $x637 $x623)))
(let ((@x642 (asserted $x641)))
(let ((@x1221 (unit-resolution @x289 (unit-resolution @x642 @x1219 $x623) @x1217 (unit-resolution @x555 @x1213 $x553) x22$)))
(let ((@x1226 (unit-resolution @x325 (unit-resolution (asserted (or $x609 $x610)) @x1221 $x610) @x1224 x26$)))
(let (($x663 (or $x660 $x596)))
(let ((@x664 (asserted $x663)))
(let (($x589 (or $x587 $x588)))
(let ((@x590 (asserted $x589)))
(let ((@x1231 (unit-resolution @x590 (unit-resolution @x307 (unit-resolution @x662 @x1226 $x657) x54$) $x587)))
(let ((@x1232 (unit-resolution @x269 @x1231 (unit-resolution (asserted (or $x609 $x595)) @x1221 $x595) (unit-resolution @x664 @x1226 $x596) x49$)))
(let ((@x1234 (unit-resolution @x222 (unit-resolution @x527 @x1232 $x524) (unit-resolution @x557 @x1213 $x538) (unit-resolution @x616 @x1221 $x539) x44$)))
(let (($x475 (or $x468 $x453)))
(let ((@x476 (asserted $x475)))
(let ((@x1237 (unit-resolution @x594 (unit-resolution @x307 (unit-resolution @x662 @x1226 $x657) x54$) $x517)))
(let ((@x1239 (unit-resolution @x202 (unit-resolution (asserted (or $x525 $x516)) @x1232 $x516) @x1237 x42$)))
(let ((@x1241 (unit-resolution @x155 (unit-resolution @x448 @x1239 $x445) (unit-resolution @x535 @x1232 $x454) (unit-resolution @x476 @x1234 $x453) x37$)))
(let ((@x1243 (unit-resolution @x725 (unit-resolution (asserted (or $x446 $x375)) @x1239 $x375) x5$)))
(let (($x390 (or $x383 $x374)))
(let ((@x391 (asserted $x390)))
(let ((@x1246 (lemma (unit-resolution @x391 @x1243 @x1241 false) (or $x509 x46$ x52$))))
(let ((@x1247 (unit-resolution @x1246 @x1210 @x756 $x509)))
(let ((@x1249 (unit-resolution @x175 (unit-resolution @x1090 @x1247 @x913 $x481) @x882 @x708 x45$)))
(let (($x562 (or $x553 $x482)))
(let ((@x563 (asserted $x562)))
(let ((@x1252 (unit-resolution @x242 (unit-resolution @x559 @x1249 $x552) @x1210 @x756 x19$)))
(let ((@x1255 (unit-resolution @x642 (unit-resolution @x779 (unit-resolution @x582 @x1252 $x580) x24$) $x623)))
(let ((@x1256 (unit-resolution @x289 @x1255 @x1217 (unit-resolution @x563 @x1249 $x553) x22$)))
(let ((@x1260 (unit-resolution @x325 (unit-resolution (asserted (or $x609 $x610)) @x1256 $x610) @x1224 x26$)))
(let ((@x1265 (unit-resolution @x590 (unit-resolution @x307 (unit-resolution @x662 @x1260 $x657) x54$) $x587)))
(let ((@x1266 (unit-resolution @x269 @x1265 (unit-resolution (asserted (or $x609 $x595)) @x1256 $x595) (unit-resolution @x664 @x1260 $x596) x49$)))
(let ((@x1268 (unit-resolution @x222 (unit-resolution @x527 @x1266 $x524) (unit-resolution (asserted (or $x538 $x482)) @x1249 $x538) (unit-resolution @x616 @x1256 $x539) x44$)))
(let ((@x1271 (unit-resolution @x594 (unit-resolution @x307 (unit-resolution @x662 @x1260 $x657) x54$) $x517)))
(let ((@x1273 (unit-resolution @x202 (unit-resolution (asserted (or $x525 $x516)) @x1266 $x516) @x1271 x42$)))
(let ((@x1275 (unit-resolution @x155 (unit-resolution @x448 @x1273 $x445) (unit-resolution @x535 @x1266 $x454) (unit-resolution @x476 @x1268 $x453) x37$)))
(let ((@x1277 (unit-resolution @x725 (unit-resolution (asserted (or $x446 $x375)) @x1273 $x375) x5$)))
(let ((@x1280 (lemma (unit-resolution @x391 @x1277 @x1275 false) (or x46$ x52$ x12$ x39$ x8$))))
(let ((@x1282 (unit-resolution @x504 (unit-resolution @x1280 @x708 @x882 @x756 @x913 x46$) $x481)))
(let ((@x1284 (unit-resolution @x563 (unit-resolution @x175 @x1282 @x882 @x708 x45$) $x553)))
(let ((@x1286 (unit-resolution @x498 (unit-resolution @x1280 @x708 @x882 @x756 @x913 x46$) $x495)))
(let ((@x1289 (unit-resolution @x779 (unit-resolution @x584 (unit-resolution @x193 @x1286 @x1285 x47$) $x580) x24$)))
(let ((@x1291 (unit-resolution @x289 (unit-resolution @x642 @x1289 $x623) @x1217 @x1284 x22$)))
(let (($x564 (or $x538 $x482)))
(let ((@x565 (asserted $x564)))
(let ((@x1293 (unit-resolution @x565 (unit-resolution @x175 @x1282 @x882 @x708 x45$) $x538)))
(let ((@x1295 (unit-resolution @x325 (unit-resolution (asserted (or $x609 $x610)) @x1291 $x610) @x1224 x26$)))
(let ((@x1300 (unit-resolution @x590 (unit-resolution @x307 (unit-resolution @x662 @x1295 $x657) x54$) $x587)))
(let ((@x1301 (unit-resolution @x269 @x1300 (unit-resolution (asserted (or $x609 $x595)) @x1291 $x595) (unit-resolution @x664 @x1295 $x596) x49$)))
(let ((@x1303 (unit-resolution @x222 (unit-resolution @x527 @x1301 $x524) @x1293 (unit-resolution @x616 @x1291 $x539) x44$)))
(let ((@x1306 (unit-resolution @x594 (unit-resolution @x307 (unit-resolution @x662 @x1295 $x657) x54$) $x517)))
(let ((@x1308 (unit-resolution @x202 (unit-resolution (asserted (or $x525 $x516)) @x1301 $x516) @x1306 x42$)))
(let ((@x1310 (unit-resolution @x155 (unit-resolution @x448 @x1308 $x445) (unit-resolution @x535 @x1301 $x454) (unit-resolution @x476 @x1303 $x453) x37$)))
(let ((@x1312 (unit-resolution @x725 (unit-resolution (asserted (or $x446 $x375)) @x1308 $x375) x5$)))
(let ((@x1315 (lemma (unit-resolution @x391 @x1312 @x1310 false) (or x39$ x12$ x41$ x52$ x8$))))
(let ((@x1317 (unit-resolution @x421 (unit-resolution @x1315 @x1285 @x882 @x756 @x913 x39$) $x356)))
(let ((@x1321 (unit-resolution @x77 (unit-resolution @x368 (unit-resolution @x67 @x1317 @x845 x3$) $x363) x35$)))
(let ((@x1323 (unit-resolution @x128 (unit-resolution @x444 @x1321 $x424) @x913 (unit-resolution @x370 (unit-resolution @x67 @x1317 @x845 x3$) $x364) x40$)))
(let ((@x1327 (unit-resolution @x1246 (unit-resolution @x193 (unit-resolution @x502 @x1323 $x495) @x1285 x47$) (unit-resolution @x506 @x1323 $x496) @x756 false)))
(let ((@x1330 (unit-resolution (lemma @x1327 (or x41$ x52$ x8$ x2$ x12$)) @x845 @x913 @x756 @x882 x41$)))
(let ((@x1334 (unit-resolution @x366 (unit-resolution @x77 (unit-resolution @x442 @x1330 $x371) x4$) $x364)))
(let ((@x1335 (unit-resolution @x128 @x1334 @x913 (unit-resolution @x440 @x1330 $x424) x40$)))
(let ((@x1337 (unit-resolution @x368 (unit-resolution @x77 (unit-resolution @x442 @x1330 $x371) x4$) $x355)))
(let ((@x1340 (unit-resolution @x1280 (unit-resolution @x421 (unit-resolution @x67 @x1337 @x845 x33$) $x411) (unit-resolution @x506 @x1335 $x496) @x882 @x756 @x913 false)))
(let ((@x1343 (unit-resolution (lemma @x1340 (or x2$ x12$ x52$ x8$)) @x913 @x756 @x882 x2$)))
(let ((@x1345 (unit-resolution @x706 (unit-resolution @x352 @x1343 $x335) x31$)))
(let (($x451 (or $x446 $x375)))
(let ((@x452 (asserted $x451)))
(let ((@x1348 (unit-resolution @x452 (unit-resolution @x725 (unit-resolution @x395 @x1345 $x374) x36$) $x446)))
(let ((@x1349 (unit-resolution @x450 (unit-resolution @x725 (unit-resolution @x395 @x1345 $x374) x36$) $x445)))
(let ((@x1354 (unit-resolution @x419 (unit-resolution @x1280 @x1210 @x882 @x756 @x913 x39$) $x396)))
(let ((@x1355 (unit-resolution @x108 @x1354 (unit-resolution @x350 @x1343 $x348) (unit-resolution @x389 @x1345 $x382) x38$)))
(let ((@x1357 (unit-resolution @x155 (unit-resolution @x480 @x1355 $x453) (unit-resolution @x393 @x1345 $x383) @x1349 x43$)))
(let ((@x1360 (unit-resolution @x594 (unit-resolution @x202 (unit-resolution @x537 @x1357 $x516) @x1348 x48$) $x588)))
(let ((@x1364 (unit-resolution @x1154 (unit-resolution @x478 @x1355 $x468) @x1345 (unit-resolution @x480 @x1355 $x453) x17$)))
(let (($x560 (or $x553 $x538)))
(let ((@x561 (asserted $x560)))
(let ((@x1367 (unit-resolution @x582 (unit-resolution @x771 @x1364 @x882 @x1247 @x756 x19$) $x580)))
(let ((@x1370 (unit-resolution @x289 (unit-resolution @x642 (unit-resolution @x779 @x1367 x24$) $x623) @x1217 (unit-resolution @x561 @x1364 $x553) x22$)))
(let (($x611 (or $x609 $x610)))
(let ((@x612 (asserted $x611)))
(let ((@x1372 (unit-resolution @x325 (unit-resolution @x612 @x1370 $x610) (unit-resolution @x662 (unit-resolution @x307 @x1360 x25$) $x660) @x1224 false)))
(let ((@x1384 (unit-resolution (lemma @x1372 (or x46$ x12$ x52$ x8$)) @x913 @x756 @x882 x46$)))
(let ((@x1376 (unit-resolution (lemma @x891 (or $x610 x47$ x19$ x52$)) @x974 (unit-resolution (asserted (or $x566 $x496)) (hypothesis x46$) $x566) @x756 $x610)))
(let ((@x1379 (unit-resolution @x594 (unit-resolution @x844 @x974 (hypothesis x46$) x48$) $x588)))
(let ((@x1381 (unit-resolution @x662 (unit-resolution @x307 @x1379 x25$) (unit-resolution @x325 @x1376 @x1224 x26$) false)))
(let ((@x1383 (lemma @x1381 (or x47$ x52$ $x496))))
(let (($x512 (or $x509 $x438)))
(let ((@x513 (asserted $x512)))
(let ((@x1387 (unit-resolution @x1315 (unit-resolution @x513 (unit-resolution @x1383 @x1384 @x756 x47$) $x438) @x882 @x756 @x913 x39$)))
(let ((@x1389 (unit-resolution @x108 (unit-resolution @x419 @x1387 $x396) (unit-resolution @x350 @x1343 $x348) (unit-resolution @x389 @x1345 $x382) x38$)))
(let ((@x1391 (unit-resolution @x155 (unit-resolution @x480 @x1389 $x453) (unit-resolution @x393 @x1345 $x383) @x1349 x43$)))
(let ((@x1394 (unit-resolution @x594 (unit-resolution @x202 (unit-resolution @x537 @x1391 $x516) @x1348 x48$) $x588)))
(let ((@x1397 (unit-resolution @x779 (unit-resolution @x584 (unit-resolution @x1383 @x1384 @x756 x47$) $x580) x24$)))
(let ((@x1400 (unit-resolution @x1154 (unit-resolution @x480 @x1389 $x453) @x1345 (unit-resolution @x478 @x1389 $x468) x17$)))
(let ((@x1402 (unit-resolution @x289 (unit-resolution @x561 @x1400 $x553) @x1217 (unit-resolution @x642 @x1397 $x623) x22$)))
(let ((@x1405 (unit-resolution @x662 (unit-resolution @x325 (unit-resolution @x612 @x1402 $x610) @x1224 x26$) (unit-resolution @x307 @x1394 x25$) false)))
(let ((@x1440 (unit-resolution (lemma @x1405 (or x8$ x12$ x52$)) @x882 @x756 x8$)))
(let ((@x1411 (unit-resolution @x242 (unit-resolution @x559 (hypothesis x45$) $x552) @x1210 @x756 x19$)))
(let ((@x1414 (unit-resolution @x642 (unit-resolution @x779 (unit-resolution @x582 @x1411 $x580) x24$) $x623)))
(let ((@x1415 (unit-resolution @x289 @x1414 @x1217 (unit-resolution @x563 (hypothesis x45$) $x553) x22$)))
(let ((@x1418 (unit-resolution @x662 (unit-resolution @x325 (unit-resolution @x612 @x1415 $x610) @x1224 x26$) $x657)))
(let ((@x1421 (unit-resolution @x664 (unit-resolution @x325 (unit-resolution @x612 @x1415 $x610) @x1224 x26$) $x596)))
(let ((@x1424 (unit-resolution @x269 (unit-resolution @x590 (unit-resolution @x307 @x1418 x54$) $x587) (unit-resolution (asserted (or $x609 $x595)) @x1415 $x595) @x1421 x49$)))
(let (($x532 (or $x525 $x516)))
(let ((@x533 (asserted $x532)))
(let ((@x1426 (unit-resolution @x202 (unit-resolution @x533 @x1424 $x516) (unit-resolution @x594 (unit-resolution @x307 @x1418 x54$) $x517) x42$)))
(let ((@x1432 (unit-resolution @x222 (unit-resolution @x527 @x1424 $x524) (unit-resolution @x565 (hypothesis x45$) $x538) (unit-resolution @x616 @x1415 $x539) x44$)))
(let ((@x1434 (unit-resolution @x155 (unit-resolution @x476 @x1432 $x453) (unit-resolution @x535 @x1424 $x454) (unit-resolution @x448 @x1426 $x445) x37$)))
(let ((@x1437 (unit-resolution @x391 (unit-resolution @x725 (unit-resolution @x452 @x1426 $x375) x5$) @x1434 false)))
(let ((@x1444 (unit-resolution @x175 (unit-resolution (lemma @x1437 (or $x482 x46$ x52$)) @x1210 @x756 $x482) @x882 (unit-resolution @x413 @x1440 $x411) x13$)))
(let ((@x1447 (unit-resolution @x442 (unit-resolution @x193 (unit-resolution @x500 @x1444 $x495) @x1247 x41$) $x371)))
(let ((@x1450 (unit-resolution @x67 (unit-resolution @x368 (unit-resolution @x77 @x1447 x4$) $x355) (unit-resolution @x417 @x1440 $x356) x2$)))
(let ((@x1452 (unit-resolution @x706 (unit-resolution @x352 @x1450 $x335) x31$)))
(let ((@x1455 (unit-resolution @x452 (unit-resolution @x725 (unit-resolution @x395 @x1452 $x374) x36$) $x446)))
(let ((@x1457 (unit-resolution @x1011 (unit-resolution @x368 (unit-resolution @x77 @x1447 x4$) $x355) @x1440 x38$)))
(let ((@x1459 (unit-resolution @x450 (unit-resolution @x725 (unit-resolution @x395 @x1452 $x374) x36$) $x445)))
(let ((@x1460 (unit-resolution @x155 @x1459 (unit-resolution @x480 @x1457 $x453) (unit-resolution @x393 @x1452 $x383) x43$)))
(let ((@x1463 (unit-resolution @x594 (unit-resolution @x202 (unit-resolution @x537 @x1460 $x516) @x1455 x48$) $x588)))
(let ((@x1466 (unit-resolution @x1154 @x1452 (unit-resolution @x478 @x1457 $x468) (unit-resolution @x480 @x1457 $x453) x17$)))
(let ((@x1469 (unit-resolution @x582 (unit-resolution @x771 @x1466 @x882 @x1247 @x756 x19$) $x580)))
(let ((@x1472 (unit-resolution @x289 (unit-resolution @x642 (unit-resolution @x779 @x1469 x24$) $x623) @x1217 (unit-resolution @x561 @x1466 $x553) x22$)))
(let ((@x1475 (unit-resolution @x662 (unit-resolution @x325 (unit-resolution @x612 @x1472 $x610) @x1224 x26$) (unit-resolution @x307 @x1463 x25$) false)))
(let ((@x1478 (unit-resolution (lemma @x1475 (or x46$ x12$ x52$)) @x882 @x756 x46$)))
(let ((@x1480 (unit-resolution @x175 (unit-resolution @x504 @x1478 $x481) @x882 (unit-resolution @x413 @x1440 $x411) x45$)))
(let ((@x1484 (unit-resolution @x779 (unit-resolution @x584 (unit-resolution @x1383 @x1478 @x756 x47$) $x580) x24$)))
(let ((@x1486 (unit-resolution @x289 (unit-resolution @x642 @x1484 $x623) @x1217 (unit-resolution @x563 @x1480 $x553) x22$)))
(let ((@x1491 (unit-resolution @x664 (unit-resolution @x325 (unit-resolution @x612 @x1486 $x610) @x1224 x26$) $x596)))
(let ((@x1493 (unit-resolution @x662 (unit-resolution @x325 (unit-resolution @x612 @x1486 $x610) @x1224 x26$) $x657)))
(let ((@x1496 (unit-resolution @x269 (unit-resolution @x590 (unit-resolution @x307 @x1493 x54$) $x587) (unit-resolution (asserted (or $x609 $x595)) @x1486 $x595) @x1491 x49$)))
(let ((@x1498 (unit-resolution @x222 (unit-resolution @x527 @x1496 $x524) (unit-resolution @x565 @x1480 $x538) (unit-resolution @x616 @x1486 $x539) x44$)))
(let ((@x1503 (unit-resolution @x202 (unit-resolution @x533 @x1496 $x516) (unit-resolution @x594 (unit-resolution @x307 @x1493 x54$) $x517) x42$)))
(let ((@x1505 (unit-resolution @x155 (unit-resolution @x448 @x1503 $x445) (unit-resolution @x535 @x1496 $x454) (unit-resolution @x476 @x1498 $x453) x37$)))
(let ((@x1508 (unit-resolution @x391 (unit-resolution @x725 (unit-resolution @x452 @x1503 $x375) x5$) @x1505 false)))
(let ((@x1576 (unit-resolution @x472 (unit-resolution (lemma @x1508 (or x12$ x52$)) @x756 x12$) $x453)))
(let ((@x1547 (hypothesis $x667)))
(let ((@x1557 (unit-resolution @x325 (unit-resolution @x612 (hypothesis x22$) $x610) @x1547 x26$)))
(let ((@x1561 (unit-resolution @x590 (unit-resolution @x307 (unit-resolution @x662 @x1557 $x657) x54$) $x587)))
(let ((@x1562 (unit-resolution @x269 @x1561 (unit-resolution @x664 @x1557 $x596) (unit-resolution (asserted (or $x609 $x595)) (hypothesis x22$) $x595) x49$)))
(let ((@x1564 (unit-resolution @x594 (unit-resolution @x307 (unit-resolution @x662 @x1557 $x657) x54$) $x517)))
(let ((@x1512 (unit-resolution @x391 @x738 (unit-resolution @x155 @x830 @x832 @x815 x37$) false)))
(let ((@x1514 (lemma @x1512 (or $x446 x43$ x11$))))
(let ((@x1567 (unit-resolution @x1514 (unit-resolution @x202 (unit-resolution @x533 @x1562 $x516) @x1564 x42$) (unit-resolution @x535 @x1562 $x454) @x815 false)))
(let ((@x1569 (lemma @x1567 (or $x609 x11$ x27$))))
(let ((@x1584 (hypothesis $x446)))
(let ((@x1587 (unit-resolution @x307 (unit-resolution @x662 (hypothesis x26$) $x657) x54$)))
(let ((@x1590 (unit-resolution @x529 (unit-resolution @x202 (unit-resolution @x594 @x1587 $x517) @x1584 x15$) $x524)))
(let ((@x1594 (unit-resolution @x533 (unit-resolution @x202 (unit-resolution @x594 @x1587 $x517) @x1584 x15$) $x525)))
(let ((@x1595 (unit-resolution @x269 @x1594 (unit-resolution @x664 (hypothesis x26$) $x596) (unit-resolution @x590 @x1587 $x587) x21$)))
(let ((@x1596 (unit-resolution @x622 @x1595 (unit-resolution @x222 @x1590 @x1142 @x897 x50$) false)))
(let ((@x1599 (unit-resolution (lemma @x1596 (or $x660 x44$ x17$ x42$)) @x1584 @x897 @x1142 $x660)))
(let ((@x1602 (unit-resolution @x222 (unit-resolution @x620 (unit-resolution @x325 @x1599 @x1547 x56$) $x539) @x1142 @x897 x16$)))
(let ((@x1607 (unit-resolution @x592 (unit-resolution @x202 (unit-resolution @x529 @x1602 $x516) @x1584 x48$) $x587)))
(let ((@x1608 (unit-resolution @x269 @x1607 (unit-resolution @x618 (unit-resolution @x325 @x1599 @x1547 x56$) $x595) (unit-resolution @x527 @x1602 $x525) x55$)))
(let ((@x1609 (unit-resolution @x594 (unit-resolution @x202 (unit-resolution @x529 @x1602 $x516) @x1584 x48$) $x588)))
(let ((@x1613 (lemma (unit-resolution @x666 (unit-resolution @x307 @x1609 x25$) @x1608 false) (or x42$ x44$ x17$ x27$))))
(let ((@x1615 (unit-resolution @x448 (unit-resolution @x1613 @x897 @x1021 @x1547 x42$) $x445)))
(let ((@x1616 (unit-resolution @x1514 (unit-resolution @x1613 @x897 @x1021 @x1547 x42$) @x889 x43$)))
(let (($x463 (or $x454 $x383)))
(let ((@x464 (asserted $x463)))
(let ((@x1618 (unit-resolution @x1075 (unit-resolution @x464 @x1616 $x383) @x1020 @x897 @x1615 x50$)))
(let ((@x1621 (unit-resolution @x662 (unit-resolution @x325 (unit-resolution @x620 @x1618 $x610) @x1547 x26$) $x657)))
(let ((@x1625 (unit-resolution @x664 (unit-resolution @x325 (unit-resolution @x620 @x1618 $x610) @x1547 x26$) $x596)))
(let ((@x1626 (unit-resolution @x269 @x1625 (unit-resolution @x622 @x1618 $x595) (unit-resolution @x535 @x1616 $x525) x20$)))
(let ((@x1629 (lemma (unit-resolution @x590 @x1626 (unit-resolution @x307 @x1621 x54$) false) (or x17$ x27$ $x467))))
(let ((@x1630 (unit-resolution @x1629 @x1224 (unit-resolution (lemma @x1508 (or x12$ x52$)) @x756 x12$) x17$)))
(let ((@x1632 (unit-resolution @x289 (unit-resolution @x561 @x1630 $x553) @x1217 (unit-resolution @x1569 @x1576 @x1224 $x609) x23$)))
(let ((@x1635 (unit-resolution @x584 (unit-resolution @x779 (unit-resolution @x642 @x1632 $x637) x53$) $x509)))
(let ((@x1637 (unit-resolution @x582 (unit-resolution @x779 (unit-resolution @x642 @x1632 $x637) x53$) $x566)))
(let ((@x1638 (unit-resolution @x242 @x1637 (unit-resolution @x557 @x1630 $x552) @x756 x46$)))
(let ((@x1640 (lemma (unit-resolution @x1383 @x1638 @x1635 @x756 false) x52$)))
(let (($x647 (or $x638 $x567)))
(let ((@x648 (asserted $x647)))
(let ((@x1665 (unit-resolution @x676 (unit-resolution @x797 (unit-resolution @x648 @x1640 $x638) x28$) $x667)))
(let ((@x1668 (unit-resolution (unit-resolution @x1569 @x1665 (or $x609 x11$)) @x815 $x609)))
(let ((@x1669 (unit-resolution @x678 (unit-resolution @x797 (unit-resolution @x648 @x1640 $x638) x28$) $x624)))
(let ((@x1671 (unit-resolution @x289 (unit-resolution (asserted (or $x623 $x567)) @x1640 $x623) @x1669 (or x22$ x51$))))
(let ((@x1673 (unit-resolution @x563 (unit-resolution @x1671 @x1668 x51$) $x482)))
(let ((@x1676 (unit-resolution (unit-resolution @x1629 @x1665 (or x17$ $x467)) @x897 $x467)))
(let ((@x1650 (unit-resolution @x77 (unit-resolution @x368 (hypothesis x3$) $x363) x35$)))
(let ((@x1579 (unit-resolution @x779 (unit-resolution (asserted (or $x637 $x567)) @x1640 $x637) x53$)))
(let ((@x1580 (unit-resolution @x584 @x1579 $x509)))
(let ((@x1653 (unit-resolution (unit-resolution @x193 @x1580 (or x14$ x41$)) (unit-resolution @x442 @x1650 $x438) x14$)))
(let ((@x1655 (unit-resolution @x175 (unit-resolution @x500 @x1653 $x481) @x882 @x998 x39$)))
(let ((@x1659 (unit-resolution @x128 (unit-resolution @x502 @x1653 $x425) (unit-resolution @x444 @x1650 $x424) (unit-resolution @x370 (hypothesis x3$) $x364) x8$)))
(let ((@x1662 (lemma (unit-resolution @x413 @x1659 @x1655 false) (or $x355 x12$ x45$))))
(let ((@x1574 (unit-resolution (unit-resolution @x1090 @x1580 (or $x481 x8$)) (unit-resolution @x1011 @x942 @x853 $x410) $x481)))
(let ((@x1581 (unit-resolution @x419 (unit-resolution @x175 @x1574 @x882 @x998 x39$) $x396)))
(let ((@x1582 (unit-resolution @x421 (unit-resolution @x175 @x1574 @x882 @x998 x39$) $x356)))
(let ((@x1642 (unit-resolution @x108 (unit-resolution @x350 (unit-resolution @x67 @x1582 @x942 x2$) $x348) @x1581 @x853 x6$)))
(let ((@x1644 (unit-resolution @x706 (unit-resolution @x352 (unit-resolution @x67 @x1582 @x942 x2$) $x335) x31$)))
(let ((@x1647 (lemma (unit-resolution @x389 @x1644 @x1642 false) (or x3$ x38$ x12$ x45$))))
(let ((@x1678 (unit-resolution @x1647 (unit-resolution @x1662 @x1673 @x1676 $x355) @x1676 @x1673 x38$)))
(let ((@x1681 (unit-resolution @x706 (unit-resolution @x1154 (unit-resolution @x478 @x1678 $x468) @x897 @x815 $x336) x1$)))
(let ((@x1683 (unit-resolution @x67 (unit-resolution @x352 @x1681 $x347) (unit-resolution @x1662 @x1673 @x1676 $x355) x33$)))
(let ((@x1686 (unit-resolution (unit-resolution @x1090 @x1580 (or $x481 x8$)) (unit-resolution @x417 @x1683 $x410) $x481)))
(let ((@x1687 (unit-resolution @x175 @x1686 (unit-resolution @x421 @x1683 $x411) @x1676 @x1673 false)))
(let ((@x1691 (unit-resolution @x480 (unit-resolution (lemma @x1687 (or x11$ x17$)) @x897 x11$) $x397)))
(let ((@x1692 (unit-resolution @x476 (unit-resolution (lemma @x1687 (or x11$ x17$)) @x897 x11$) $x468)))
(let ((@x1695 (unit-resolution (unit-resolution @x1613 @x1665 (or x42$ x44$ x17$)) @x1692 @x897 x42$)))
(let ((@x1700 (unit-resolution (unit-resolution @x769 @x1580 (or $x374 x45$ x12$ x38$)) (unit-resolution @x725 (unit-resolution @x452 @x1695 $x375) x5$) @x1676 @x1691 x45$)))
(let ((@x1702 (unit-resolution @x1671 (unit-resolution @x563 @x1700 $x553) x22$)))
(let ((@x1705 (unit-resolution (unit-resolution @x325 @x1665 (or x26$ x56$)) (unit-resolution @x612 @x1702 $x610) x26$)))
(let ((@x1709 (unit-resolution @x222 (unit-resolution @x616 @x1702 $x539) @x897 @x1692 x16$)))
(let ((@x1713 (unit-resolution @x269 (unit-resolution @x664 @x1705 $x596) (unit-resolution (asserted (or $x609 $x595)) @x1702 $x595) (unit-resolution @x527 @x1709 $x525) x20$)))
(let ((@x1714 (unit-resolution @x590 @x1713 (unit-resolution @x307 (unit-resolution @x662 @x1705 $x657) x54$) false)))
(let ((@x1715 (lemma @x1714 x17$)))
(let ((@x1718 (unit-resolution (unit-resolution @x1569 @x1665 (or $x609 x11$)) (unit-resolution @x1671 (unit-resolution @x561 @x1715 $x553) x22$) x11$)))
(let ((@x1722 (unit-resolution @x1662 (unit-resolution @x472 @x1718 $x467) (unit-resolution @x565 @x1715 $x482) $x355)))
(unit-resolution @x1647 @x1722 (unit-resolution @x472 @x1718 $x467) (unit-resolution @x565 @x1715 $x482) (unit-resolution @x480 @x1718 $x397) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

cc18a32517b61d11530e29950c780e58afa4da51 38 0
unsat
((set-logic AUFLIA)
(declare-fun ?v0!0 () Int)
(declare-fun ?v1!1 () Int)
(proof
(let (($x48 (p$ ?v0!0)))
(let (($x50 (not $x48)))
(let (($x63 (not (or $x48 (p$ ?v1!1)))))
(let ((@x77 (monotonicity (rewrite (= (not $x50) $x48)) (= (and (not $x50) $x63) (and $x48 $x63)))))
(let (($x57 (not $x50)))
(let (($x67 (and $x57 $x63)))
(let (($x41 (forall ((?v0 Int) )(! (let (($x32 (forall ((?v1 Int) )(! (let (($x28 (p$ ?v1)))
(or (p$ ?v0) $x28)) :qid k!5))
))
(or (not (p$ ?v0)) $x32)) :qid k!5))
))
(let (($x44 (not $x41)))
(let (($x52 (forall ((?v1 Int) )(! (let (($x28 (p$ ?v1)))
(let (($x48 (p$ ?v0!0)))
(or $x48 $x28))) :qid k!5))
))
(let ((@x69 (nnf-neg (refl (~ $x57 $x57)) (sk (~ (not $x52) $x63)) (~ (not (or $x50 $x52)) $x67))))
(let (($x34 (forall ((?v0 Int) )(! (let (($x32 (forall ((?v1 Int) )(! (let (($x28 (p$ ?v1)))
(or (p$ ?v0) $x28)) :qid k!5))
))
(let (($x28 (p$ ?v0)))
(=> $x28 $x32))) :qid k!5))
))
(let (($x35 (not $x34)))
(let (($x32 (forall ((?v1 Int) )(! (let (($x28 (p$ ?v1)))
(or (p$ ?0) $x28)) :qid k!5))
))
(let ((@x43 (quant-intro (rewrite (= (=> (p$ ?0) $x32) (or (not (p$ ?0)) $x32))) (= $x34 $x41))))
(let ((@x72 (mp~ (mp (asserted $x35) (monotonicity @x43 (= $x35 $x44)) $x44) (trans (sk (~ $x44 (not (or $x50 $x52)))) @x69 (~ $x44 $x67)) $x67)))
(let ((@x81 (not-or-elim (and-elim (mp @x72 @x77 (and $x48 $x63)) $x63) $x50)))
(let ((@x79 (and-elim (mp @x72 @x77 (and $x48 $x63)) $x48)))
(unit-resolution @x79 @x81 false))))))))))))))))))))

f69da5e318af2ccb1aaa30033e9780c0075e7706 53 0
unsat
((set-logic AUFLIA)
(declare-fun ?v0!0 () A$)
(proof
(let (($x517 (forall ((?v0 A$) )(! (let (($x40 (p$ x$ ?v0)))
(not $x40)) :pattern ( (p$ x$ ?v0) ) :qid k!9))
))
(let (($x44 (p$ x$ c$)))
(let (($x91 (= $x44 x$)))
(let (($x510 (forall ((?v0 Bool) (?v1 A$) )(! (let (($x29 (p$ ?v0 ?v1)))
(= $x29 ?v0)) :pattern ( (p$ ?v0 ?v1) ) :qid k!8))
))
(let (($x36 (forall ((?v0 Bool) (?v1 A$) )(! (let (($x29 (p$ ?v0 ?v1)))
(= $x29 ?v0)) :qid k!8))
))
(let ((@x514 (quant-intro (refl (= (= (p$ ?1 ?0) ?1) (= (p$ ?1 ?0) ?1))) (= $x36 $x510))))
(let ((@x64 (nnf-pos (refl (~ (= (p$ ?1 ?0) ?1) (= (p$ ?1 ?0) ?1))) (~ $x36 $x36))))
(let (($x31 (forall ((?v0 Bool) (?v1 A$) )(! (let (($x29 (p$ ?v0 ?v1)))
(= $x29 ?v0)) :qid k!8))
))
(let ((@x38 (quant-intro (rewrite (= (= (p$ ?1 ?0) ?1) (= (p$ ?1 ?0) ?1))) (= $x31 $x36))))
(let ((@x515 (mp (mp~ (mp (asserted $x31) @x38 $x36) @x64 $x36) @x514 $x510)))
(let (($x170 (or (not $x510) $x91)))
(let ((@x503 ((_ quant-inst x$ c$) $x170)))
(let (($x73 (p$ x$ ?v0!0)))
(let (($x179 (= $x73 x$)))
(let (($x85 (or $x73 $x44)))
(let (($x81 (not $x44)))
(let (($x69 (forall ((?v0 A$) )(! (let (($x40 (p$ x$ ?v0)))
(not $x40)) :qid k!9))
))
(let (($x84 (or $x69 $x81)))
(let (($x42 (exists ((?v0 A$) )(! (p$ x$ ?v0) :qid k!9))
))
(let (($x54 (not $x42)))
(let (($x55 (= $x54 $x44)))
(let ((@x71 (nnf-neg (refl (~ (not (p$ x$ ?0)) (not (p$ x$ ?0)))) (~ $x54 $x69))))
(let ((@x88 (nnf-pos @x71 (nnf-neg (sk (~ $x42 $x73)) (~ (not $x54) $x73)) (refl (~ $x44 $x44)) (refl (~ $x81 $x81)) (~ $x55 (and $x85 $x84)))))
(let ((@x53 (monotonicity (rewrite (= (= $x42 $x44) (= $x42 $x44))) (= (not (= $x42 $x44)) (not (= $x42 $x44))))))
(let ((@x59 (trans @x53 (rewrite (= (not (= $x42 $x44)) $x55)) (= (not (= $x42 $x44)) $x55))))
(let ((@x89 (mp~ (mp (asserted (not (= $x42 $x44))) @x59 $x55) @x88 (and $x85 $x84))))
(let ((@x92 (and-elim @x89 $x85)))
(let ((@x484 (unit-resolution (def-axiom (or (not $x179) (not $x73) x$)) (unit-resolution @x92 (hypothesis $x81) $x73) (or (not $x179) x$))))
(let ((@x145 (unit-resolution @x484 (unit-resolution ((_ quant-inst x$ ?v0!0) (or (not $x510) $x179)) @x515 $x179) x$)))
(let ((@x147 (unit-resolution (def-axiom (or (not $x91) $x44 (not x$))) (hypothesis $x81) (or (not $x91) (not x$)))))
(let ((@x485 (lemma (unit-resolution @x147 @x145 (unit-resolution @x503 @x515 $x91) false) $x44)))
(let (($x522 (or $x517 $x81)))
(let ((@x521 (quant-intro (refl (= (not (p$ x$ ?0)) (not (p$ x$ ?0)))) (= $x69 $x517))))
(let ((@x525 (mp (and-elim @x89 $x84) (monotonicity @x521 (= $x84 $x522)) $x522)))
(let (($x160 (or (not $x517) $x81)))
(let ((@x161 ((_ quant-inst c$) $x160)))
(unit-resolution @x161 @x485 (unit-resolution @x525 @x485 $x517) false)))))))))))))))))))))))))))))))))))))))

853b35db7beb7a5b039f102f0403b2d296edcda0 53 0
unsat
((set-logic AUFLIA)
(declare-fun ?v0!3 () A$)
(proof
(let (($x584 (forall ((?v0 A$) )(! (let (($x52 (p$ x$ ?v0)))
(not $x52)) :pattern ( (p$ x$ ?v0) ) :qid k!10))
))
(let (($x55 (p$ x$ c$)))
(let (($x230 (= $x55 x$)))
(let (($x561 (forall ((?v0 Bool) (?v1 A$) )(! (let (($x29 (p$ ?v0 ?v1)))
(= $x29 ?v0)) :pattern ( (p$ ?v0 ?v1) ) :qid k!8))
))
(let (($x36 (forall ((?v0 Bool) (?v1 A$) )(! (let (($x29 (p$ ?v0 ?v1)))
(= $x29 ?v0)) :qid k!8))
))
(let ((@x565 (quant-intro (refl (= (= (p$ ?1 ?0) ?1) (= (p$ ?1 ?0) ?1))) (= $x36 $x561))))
(let ((@x75 (nnf-pos (refl (~ (= (p$ ?1 ?0) ?1) (= (p$ ?1 ?0) ?1))) (~ $x36 $x36))))
(let (($x31 (forall ((?v0 Bool) (?v1 A$) )(! (let (($x29 (p$ ?v0 ?v1)))
(= $x29 ?v0)) :qid k!8))
))
(let ((@x38 (quant-intro (rewrite (= (= (p$ ?1 ?0) ?1) (= (p$ ?1 ?0) ?1))) (= $x31 $x36))))
(let ((@x566 (mp (mp~ (mp (asserted $x31) @x38 $x36) @x75 $x36) @x565 $x561)))
(let (($x220 (or (not $x561) $x230)))
(let ((@x221 ((_ quant-inst x$ c$) $x220)))
(let (($x124 (p$ x$ ?v0!3)))
(let (($x141 (= $x124 x$)))
(let (($x136 (or $x124 $x55)))
(let (($x132 (not $x55)))
(let (($x120 (forall ((?v0 A$) )(! (let (($x52 (p$ x$ ?v0)))
(not $x52)) :qid k!10))
))
(let (($x135 (or $x120 $x132)))
(let (($x54 (exists ((?v0 A$) )(! (p$ x$ ?v0) :qid k!10))
))
(let (($x65 (not $x54)))
(let (($x66 (= $x65 $x55)))
(let ((@x122 (nnf-neg (refl (~ (not (p$ x$ ?0)) (not (p$ x$ ?0)))) (~ $x65 $x120))))
(let ((@x139 (nnf-pos @x122 (nnf-neg (sk (~ $x54 $x124)) (~ (not $x65) $x124)) (refl (~ $x55 $x55)) (refl (~ $x132 $x132)) (~ $x66 (and $x136 $x135)))))
(let ((@x64 (monotonicity (rewrite (= (= $x54 $x55) (= $x54 $x55))) (= (not (= $x54 $x55)) (not (= $x54 $x55))))))
(let ((@x70 (trans @x64 (rewrite (= (not (= $x54 $x55)) $x66)) (= (not (= $x54 $x55)) $x66))))
(let ((@x140 (mp~ (mp (asserted (not (= $x54 $x55))) @x70 $x66) @x139 (and $x136 $x135))))
(let ((@x143 (and-elim @x140 $x136)))
(let ((@x193 (unit-resolution (def-axiom (or (not $x141) (not $x124) x$)) (unit-resolution @x143 (hypothesis $x132) $x124) (or (not $x141) x$))))
(let ((@x535 (unit-resolution @x193 (unit-resolution ((_ quant-inst x$ ?v0!3) (or (not $x561) $x141)) @x566 $x141) x$)))
(let ((@x197 (unit-resolution (def-axiom (or (not $x230) $x55 (not x$))) (hypothesis $x132) (or (not $x230) (not x$)))))
(let ((@x199 (lemma (unit-resolution @x197 @x535 (unit-resolution @x221 @x566 $x230) false) $x55)))
(let (($x589 (or $x584 $x132)))
(let ((@x588 (quant-intro (refl (= (not (p$ x$ ?0)) (not (p$ x$ ?0)))) (= $x120 $x584))))
(let ((@x592 (mp (and-elim @x140 $x135) (monotonicity @x588 (= $x135 $x589)) $x589)))
(let (($x549 (or (not $x584) $x132)))
(let ((@x211 ((_ quant-inst c$) $x549)))
(unit-resolution @x211 @x199 (unit-resolution @x592 @x199 $x584) false)))))))))))))))))))))))))))))))))))))))

ee1b9a27124d1797593a214fc9b1585b73aca864 26 0
unsat
((set-logic AUFLIA)
(proof
(let (($x28 (p$ x$)))
(let ((@x48 (monotonicity (rewrite (= (=> $x28 (p$ y$)) (or (not $x28) (p$ y$)))) (= (not (=> $x28 (p$ y$))) (not (or (not $x28) (p$ y$)))))))
(let ((@x51 (mp (asserted (not (=> $x28 (p$ y$)))) @x48 (not (or (not $x28) (p$ y$))))))
(let ((@x49 (not-or-elim @x51 $x28)))
(let (($x486 (forall ((?v0 A$) )(! (let (($x30 (p$ ?v0)))
(not $x30)) :pattern ( (p$ ?v0) ) :qid k!8))
))
(let (($x34 (forall ((?v0 A$) )(! (let (($x30 (p$ ?v0)))
(not $x30)) :qid k!8))
))
(let ((@x490 (quant-intro (refl (= (not (p$ ?0)) (not (p$ ?0)))) (= $x34 $x486))))
(let (($x31 (exists ((?v0 A$) )(! (p$ ?v0) :qid k!8))
))
(let (($x32 (not $x31)))
(let ((@x59 (monotonicity (iff-true @x49 (= $x28 true)) (= (ite $x28 $x32 $x34) (ite true $x32 $x34)))))
(let ((@x63 (trans @x59 (rewrite (= (ite true $x32 $x34) $x32)) (= (ite $x28 $x32 $x34) $x32))))
(let ((@x67 (mp~ (mp (asserted (ite $x28 $x32 $x34)) @x63 $x32) (nnf-neg (refl (~ (not (p$ ?0)) (not (p$ ?0)))) (~ $x32 $x34)) $x34)))
(let ((@x491 (mp @x67 @x490 $x486)))
(let (($x42 (not $x28)))
(let (($x156 (or (not $x486) $x42)))
(let ((@x70 ((_ quant-inst x$) $x156)))
(unit-resolution @x70 @x491 @x49 false)))))))))))))))))))

1b3bdde0d609ebf7ad7472d1510134c9c367d283 7 0
unsat
((set-logic AUFLIA)
(proof
(let ((@x35 (monotonicity (rewrite (= (= 3 3) true)) (= (not (= 3 3)) (not true)))))
(let ((@x39 (trans @x35 (rewrite (= (not true) false)) (= (not (= 3 3)) false))))
(mp (asserted (not (= 3 3))) @x39 false)))))

a90c5a0ce94c691b0e4756f87e5d5fdbfd876893 7 0
unsat
((set-logic AUFLIRA)
(proof
(let ((@x35 (monotonicity (rewrite (= (= 3.0 3.0) true)) (= (not (= 3.0 3.0)) (not true)))))
(let ((@x39 (trans @x35 (rewrite (= (not true) false)) (= (not (= 3.0 3.0)) false))))
(mp (asserted (not (= 3.0 3.0))) @x39 false)))))

16d237209133b15bdc9c24699c793f8bdc748cd0 9 0
unsat
((set-logic AUFLIA)
(proof
(let ((@x37 (monotonicity (rewrite (= (+ 3 1) 4)) (= (= (+ 3 1) 4) (= 4 4)))))
(let ((@x41 (trans @x37 (rewrite (= (= 4 4) true)) (= (= (+ 3 1) 4) true))))
(let ((@x44 (monotonicity @x41 (= (not (= (+ 3 1) 4)) (not true)))))
(let ((@x48 (trans @x44 (rewrite (= (not true) false)) (= (not (= (+ 3 1) 4)) false))))
(mp (asserted (not (= (+ 3 1) 4))) @x48 false)))))))

bc021898e31cb7c6419a072d70191b97605bee76 16 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x32 (+ z$ x$)))
(let ((?x33 (+ y$ ?x32)))
(let ((?x30 (+ y$ z$)))
(let ((?x31 (+ x$ ?x30)))
(let (($x34 (= ?x31 ?x33)))
(let (($x35 (not $x34)))
(let ((@x45 (monotonicity (rewrite (= ?x32 (+ x$ z$))) (= ?x33 (+ y$ (+ x$ z$))))))
(let ((@x49 (trans @x45 (rewrite (= (+ y$ (+ x$ z$)) (+ x$ y$ z$))) (= ?x33 (+ x$ y$ z$)))))
(let ((@x52 (monotonicity (rewrite (= ?x31 (+ x$ y$ z$))) @x49 (= $x34 (= (+ x$ y$ z$) (+ x$ y$ z$))))))
(let ((@x56 (trans @x52 (rewrite (= (= (+ x$ y$ z$) (+ x$ y$ z$)) true)) (= $x34 true))))
(let ((@x63 (trans (monotonicity @x56 (= $x35 (not true))) (rewrite (= (not true) false)) (= $x35 false))))
(mp (asserted $x35) @x63 false))))))))))))))

31045f736583ed0b58ba51e123c31f8bb6c0267d 11 0
unsat
((set-logic AUFLIA)
(proof
(let ((@x41 (monotonicity (rewrite (= (<= 3 8) true)) (= (ite (<= 3 8) 8 3) (ite true 8 3)))))
(let ((@x45 (trans @x41 (rewrite (= (ite true 8 3) 8)) (= (ite (<= 3 8) 8 3) 8))))
(let ((@x48 (monotonicity @x45 (= (< 5 (ite (<= 3 8) 8 3)) (< 5 8)))))
(let ((@x52 (trans @x48 (rewrite (= (< 5 8) true)) (= (< 5 (ite (<= 3 8) 8 3)) true))))
(let ((@x55 (monotonicity @x52 (= (not (< 5 (ite (<= 3 8) 8 3))) (not true)))))
(let ((@x59 (trans @x55 (rewrite (= (not true) false)) (= (not (< 5 (ite (<= 3 8) 8 3))) false))))
(mp (asserted (not (< 5 (ite (<= 3 8) 8 3)))) @x59 false)))))))))

6b0b089fbe179e8a27509c818f9a5e6847ac6bf2 88 0
unsat
((set-logic AUFLIRA)
(proof
(let ((?x44 (* (- 1.0) x$)))
(let (($x83 (>= x$ 0.0)))
(let ((?x90 (ite $x83 x$ ?x44)))
(let ((?x113 (* (- 1.0) ?x90)))
(let ((?x148 (+ x$ ?x113)))
(let (($x149 (<= ?x148 0.0)))
(let (($x133 (= x$ ?x90)))
(let ((?x45 (* (- 1.0) y$)))
(let ((?x46 (+ ?x44 ?x45)))
(let ((?x29 (+ x$ y$)))
(let (($x71 (>= ?x29 0.0)))
(let ((?x78 (ite $x71 ?x29 ?x46)))
(let ((?x151 (* (- 1.0) ?x78)))
(let ((?x179 (+ ?x46 ?x151)))
(let (($x181 (>= ?x179 0.0)))
(let (($x130 (= ?x46 ?x78)))
(let (($x72 (not $x71)))
(let (($x95 (>= y$ 0.0)))
(let (($x96 (not $x95)))
(let (($x154 (>= (+ ?x29 ?x151) 0.0)))
(let (($x129 (= ?x29 ?x78)))
(let (($x190 (not $x181)))
(let ((@x161 (hypothesis $x95)))
(let ((?x102 (ite $x95 y$ ?x45)))
(let ((?x114 (* (- 1.0) ?x102)))
(let ((?x115 (+ ?x78 ?x113 ?x114)))
(let (($x116 (<= ?x115 0.0)))
(let (($x121 (not $x116)))
(let ((?x39 (+ (ite (< x$ 0.0) (- x$) x$) (ite (< y$ 0.0) (- y$) y$))))
(let (($x41 (not (<= (ite (< ?x29 0.0) (- ?x29) ?x29) ?x39))))
(let (($x36 (< y$ 0.0)))
(let ((?x59 (ite $x36 ?x45 y$)))
(let (($x33 (< x$ 0.0)))
(let ((?x54 (ite $x33 ?x44 x$)))
(let ((?x62 (+ ?x54 ?x59)))
(let (($x30 (< ?x29 0.0)))
(let ((?x49 (ite $x30 ?x46 ?x29)))
(let (($x65 (<= ?x49 ?x62)))
(let ((@x106 (trans (monotonicity (rewrite (= $x36 $x96)) (= ?x59 (ite $x96 ?x45 y$))) (rewrite (= (ite $x96 ?x45 y$) ?x102)) (= ?x59 ?x102))))
(let ((@x89 (monotonicity (rewrite (= $x33 (not $x83))) (= ?x54 (ite (not $x83) ?x44 x$)))))
(let ((@x94 (trans @x89 (rewrite (= (ite (not $x83) ?x44 x$) ?x90)) (= ?x54 ?x90))))
(let ((@x82 (trans (monotonicity (rewrite (= $x30 $x72)) (= ?x49 (ite $x72 ?x46 ?x29))) (rewrite (= (ite $x72 ?x46 ?x29) ?x78)) (= ?x49 ?x78))))
(let ((@x112 (monotonicity @x82 (monotonicity @x94 @x106 (= ?x62 (+ ?x90 ?x102))) (= $x65 (<= ?x78 (+ ?x90 ?x102))))))
(let ((@x120 (trans @x112 (rewrite (= (<= ?x78 (+ ?x90 ?x102)) $x116)) (= $x65 $x116))))
(let ((@x61 (monotonicity (rewrite (= (- y$) ?x45)) (= (ite $x36 (- y$) y$) ?x59))))
(let ((@x56 (monotonicity (rewrite (= (- x$) ?x44)) (= (ite $x33 (- x$) x$) ?x54))))
(let ((@x51 (monotonicity (rewrite (= (- ?x29) ?x46)) (= (ite $x30 (- ?x29) ?x29) ?x49))))
(let ((@x67 (monotonicity @x51 (monotonicity @x56 @x61 (= ?x39 ?x62)) (= (<= (ite $x30 (- ?x29) ?x29) ?x39) $x65))))
(let ((@x125 (trans (monotonicity @x67 (= $x41 (not $x65))) (monotonicity @x120 (= (not $x65) $x121)) (= $x41 $x121))))
(let ((@x126 (mp (asserted $x41) @x125 $x121)))
(let (($x139 (= y$ ?x102)))
(let ((@x174 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x139) (<= (+ y$ ?x114) 0.0))) (unit-resolution (def-axiom (or $x96 $x139)) @x161 $x139) (<= (+ y$ ?x114) 0.0))))
(let ((?x150 (+ ?x44 ?x113)))
(let (($x153 (<= ?x150 0.0)))
(let (($x134 (= ?x44 ?x90)))
(let (($x84 (not $x83)))
(let ((@x159 ((_ th-lemma arith triangle-eq) (or (not $x133) $x149))))
(let ((@x160 (unit-resolution @x159 (unit-resolution (def-axiom (or $x84 $x133)) (hypothesis $x83) $x133) $x149)))
(let ((@x164 (unit-resolution ((_ th-lemma arith assign-bounds -1 -1) (or $x71 $x84 $x96)) (hypothesis $x83) @x161 $x71)))
(let ((@x128 (def-axiom (or $x72 $x129))))
(let ((@x168 ((_ th-lemma arith triangle-eq) (or (not $x129) $x154))))
(let ((@x175 ((_ th-lemma arith farkas 1 -1 -1 1) @x174 (unit-resolution @x168 (unit-resolution @x128 @x164 $x129) $x154) @x126 @x160 false)))
(let ((@x138 (def-axiom (or $x83 $x134))))
(let ((@x184 (unit-resolution @x138 (unit-resolution (lemma @x175 (or $x84 $x96)) @x161 $x84) $x134)))
(let ((@x189 ((_ th-lemma arith farkas 2 -1 -1 1 1) @x161 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x134) $x153)) @x184 $x153) @x174 @x126 (hypothesis $x181) false)))
(let ((@x198 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x130) $x181)) (hypothesis $x130) (hypothesis $x190) false)))
(let ((@x199 (lemma @x198 (or (not $x130) $x181))))
(let ((@x201 (unit-resolution @x199 (unit-resolution (lemma @x189 (or $x190 $x96)) @x161 $x190) (not $x130))))
(let ((@x132 (def-axiom (or $x71 $x130))))
(let ((@x204 (unit-resolution @x168 (unit-resolution @x128 (unit-resolution @x132 @x201 $x71) $x129) $x154)))
(let ((@x205 ((_ th-lemma arith farkas 2 1 1 1 1) (unit-resolution (lemma @x175 (or $x84 $x96)) @x161 $x84) (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x134) $x153)) @x184 $x153) @x174 @x126 @x204 false)))
(let ((@x206 (lemma @x205 $x96)))
(let ((@x212 (unit-resolution ((_ th-lemma arith assign-bounds 1 1) (or $x83 $x95 $x72)) (hypothesis $x71) @x206 $x83)))
(let ((@x136 (def-axiom (or $x84 $x133))))
(let ((@x216 (unit-resolution @x168 (unit-resolution @x128 (hypothesis $x71) $x129) $x154)))
(let ((?x147 (+ ?x45 ?x114)))
(let (($x178 (<= ?x147 0.0)))
(let (($x140 (= ?x45 ?x102)))
(let ((@x221 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x140) $x178)) (unit-resolution (def-axiom (or $x95 $x140)) @x206 $x140) $x178)))
(let ((@x222 ((_ th-lemma arith farkas 2 1 1 1 1) @x206 @x221 @x126 @x216 (unit-resolution @x159 (unit-resolution @x136 @x212 $x133) $x149) false)))
(let ((@x226 (unit-resolution @x199 (unit-resolution @x132 (lemma @x222 $x72) $x130) $x181)))
(let ((@x231 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x134) $x153)) (hypothesis $x134) (lemma ((_ th-lemma arith farkas 1 -1 -1 1) @x221 @x126 @x226 (hypothesis $x153) false) (not $x153)) false)))
(let ((@x234 (unit-resolution @x136 (unit-resolution @x138 (lemma @x231 (not $x134)) $x83) $x133)))
((_ th-lemma arith farkas -2 1 -1 -1 1) (unit-resolution @x138 (lemma @x231 (not $x134)) $x83) @x221 @x126 @x226 (unit-resolution @x159 @x234 $x149) false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

bc11d479eb44aa63c2efc812af856ec331477415 16 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x32 (p$ true)))
(let (($x29 (< 2 3)))
(let (($x30 (ite $x29 true false)))
(let ((?x31 (p$ $x30)))
(let (($x33 (= ?x31 ?x32)))
(let (($x34 (not $x33)))
(let ((@x52 (monotonicity (monotonicity (rewrite (= $x29 true)) (= (p$ $x29) ?x32)) (= (= (p$ $x29) ?x32) (= ?x32 ?x32)))))
(let ((@x56 (trans @x52 (rewrite (= (= ?x32 ?x32) true)) (= (= (p$ $x29) ?x32) true))))
(let ((@x63 (trans (monotonicity @x56 (= (not (= (p$ $x29) ?x32)) (not true))) (rewrite (= (not true) false)) (= (not (= (p$ $x29) ?x32)) false))))
(let ((@x43 (monotonicity (monotonicity (rewrite (= $x30 $x29)) (= ?x31 (p$ $x29))) (= $x33 (= (p$ $x29) ?x32)))))
(let ((@x46 (monotonicity @x43 (= $x34 (not (= (p$ $x29) ?x32))))))
(mp (asserted $x34) (trans @x46 @x63 (= $x34 false)) false))))))))))))))

d63ee5062f9a1d0a0bd17f51adaa0ac5e8f9ec16 16 0
unsat
((set-logic AUFLIA)
(proof
(let (($x33 (< x$ 1)))
(let ((?x37 (+ 3 x$)))
(let (($x40 (<= 4 ?x37)))
(let (($x43 (or $x40 $x33)))
(let (($x46 (not $x43)))
(let ((@x57 (monotonicity (rewrite (= $x40 (>= x$ 1))) (rewrite (= $x33 (not (>= x$ 1)))) (= $x43 (or (>= x$ 1) (not (>= x$ 1)))))))
(let ((@x61 (trans @x57 (rewrite (= (or (>= x$ 1) (not (>= x$ 1))) true)) (= $x43 true))))
(let ((@x68 (trans (monotonicity @x61 (= $x46 (not true))) (rewrite (= (not true) false)) (= $x46 false))))
(let ((@x42 (monotonicity (rewrite (= (+ x$ 3) ?x37)) (= (<= 4 (+ x$ 3)) $x40))))
(let ((@x48 (monotonicity (monotonicity @x42 (= (or (<= 4 (+ x$ 3)) $x33) $x43)) (= (not (or (<= 4 (+ x$ 3)) $x33)) $x46))))
(let ((@x70 (trans @x48 @x68 (= (not (or (<= 4 (+ x$ 3)) $x33)) false))))
(mp (asserted (not (or (<= 4 (+ x$ 3)) $x33))) @x70 false))))))))))))))

ea0e16fa50db2870878476eccdef4f64568acd55 18 0
unsat
((set-logic AUFLIA)
(proof
(let (($x51 (= (+ x$ (* (- 1) y$)) (- 4))))
(let ((@x45 (monotonicity (rewrite (= (+ x$ 4) (+ 4 x$))) (= (= y$ (+ x$ 4)) (= y$ (+ 4 x$))))))
(let ((@x54 (trans @x45 (rewrite (= (= y$ (+ 4 x$)) $x51)) (= (= y$ (+ x$ 4)) $x51))))
(let ((@x88 (monotonicity (mp (asserted (= y$ (+ x$ 4))) @x54 $x51) (= (>= (+ x$ (* (- 1) y$)) 0) (>= (- 4) 0)))))
(let ((@x90 (trans @x88 (rewrite (= (>= (- 4) 0) false)) (= (>= (+ x$ (* (- 1) y$)) 0) false))))
(let (($x70 (>= (+ x$ (* (- 1) y$)) 0)))
(let ((@x76 (monotonicity (rewrite (= (< 0 (+ (* (- 1) x$) y$)) (not $x70))) (= (not (< 0 (+ (* (- 1) x$) y$))) (not (not $x70))))))
(let ((@x80 (trans @x76 (rewrite (= (not (not $x70)) $x70)) (= (not (< 0 (+ (* (- 1) x$) y$))) $x70))))
(let (($x64 (< 0 (+ (* (- 1) x$) y$))))
(let (($x67 (not $x64)))
(let (($x58 (not (< 0 (- y$ x$)))))
(let ((@x66 (monotonicity (rewrite (= (- y$ x$) (+ (* (- 1) x$) y$))) (= (< 0 (- y$ x$)) $x64))))
(let ((@x83 (mp (asserted $x58) (trans (monotonicity @x66 (= $x58 $x67)) @x80 (= $x58 $x70)) $x70)))
(mp @x83 @x90 false))))))))))))))))

2389277f3547499e520f2b3ac28991b30ac7c1a8 11 0
unsat
((set-logic AUFLIA)
(proof
(let ((@x39 (monotonicity (rewrite (= (+ 2 2) 4)) (= (= (+ 2 2) 5) (= 4 5)))))
(let ((@x43 (trans @x39 (rewrite (= (= 4 5) false)) (= (= (+ 2 2) 5) false))))
(let ((@x46 (monotonicity @x43 (= (not (= (+ 2 2) 5)) (not false)))))
(let ((@x50 (trans @x46 (rewrite (= (not false) true)) (= (not (= (+ 2 2) 5)) true))))
(let ((@x53 (monotonicity @x50 (= (not (not (= (+ 2 2) 5))) (not true)))))
(let ((@x57 (trans @x53 (rewrite (= (not true) false)) (= (not (not (= (+ 2 2) 5))) false))))
(mp (asserted (not (not (= (+ 2 2) 5)))) @x57 false)))))))))

3a6df2b095b936aac9a1d533e306f2d31b4fb44e 22 0
unsat
((set-logic AUFLIA)
(proof
(let (($x38 (not false)))
(let (($x34 (<= 0 x$)))
(let (($x35 (not $x34)))
(let (($x36 (or $x35 $x34)))
(let ((?x29 (- 1)))
(let ((?x31 (* ?x29 x$)))
(let ((?x32 (+ y$ ?x31)))
(let (($x33 (<= 0 ?x32)))
(let (($x37 (or $x33 $x36)))
(let (($x39 (= $x37 $x38)))
(let (($x40 (not $x39)))
(let ((@x60 (rewrite (= (or (<= 0 (+ y$ (* (- 1) x$))) true) true))))
(let ((@x50 (monotonicity (monotonicity (rewrite (= ?x29 (- 1))) (= ?x31 (* (- 1) x$))) (= ?x32 (+ y$ (* (- 1) x$))))))
(let ((@x58 (monotonicity (monotonicity @x50 (= $x33 (<= 0 (+ y$ (* (- 1) x$))))) (rewrite (= $x36 true)) (= $x37 (or (<= 0 (+ y$ (* (- 1) x$))) true)))))
(let ((@x67 (monotonicity (trans @x58 @x60 (= $x37 true)) (rewrite (= $x38 true)) (= $x39 (= true true)))))
(let ((@x71 (trans @x67 (rewrite (= (= true true) true)) (= $x39 true))))
(let ((@x78 (trans (monotonicity @x71 (= $x40 (not true))) (rewrite (= (not true) false)) (= $x40 false))))
(mp (asserted $x40) @x78 false))))))))))))))))))))

dfbbe6f3879b3c49e6d5f7ecff4f8f81ed746bd4 19 0
unsat
((set-logic AUFLIRA)
(proof
(let ((?x32 (* 7.0 a$)))
(let ((?x29 (* 3.0 x$)))
(let ((?x33 (+ ?x29 ?x32)))
(let (($x43 (>= ?x33 4.0)))
(let (($x41 (not $x43)))
(let ((@x40 (mp (asserted (< ?x33 4.0)) (rewrite (= (< ?x33 4.0) $x41)) $x41)))
(let ((?x38 (* 2.0 x$)))
(let (($x48 (<= ?x38 3.0)))
(let (($x49 (not $x48)))
(let ((@x52 (mp (asserted (< 3.0 ?x38)) (rewrite (= (< 3.0 ?x38) $x49)) $x49)))
(let (($x58 (>= a$ 0.0)))
(let ((@x62 (monotonicity (rewrite (= (< a$ 0.0) (not $x58))) (= (not (< a$ 0.0)) (not (not $x58))))))
(let ((@x66 (trans @x62 (rewrite (= (not (not $x58)) $x58)) (= (not (< a$ 0.0)) $x58))))
(let ((@x67 (mp (asserted (not (< a$ 0.0))) @x66 $x58)))
((_ th-lemma arith farkas 7 3/2 1) @x67 @x52 @x40 false)))))))))))))))))

7d3773a9d63ce2ada82ac001b84291cdc85d7ab8 159 0
unsat
((set-logic AUFLIA)
(proof
(let (($x44 (= m$ n$)))
(let ((@x480 (symm (commutativity (= $x44 (= n$ m$))) (= (= n$ m$) $x44))))
(let (($x40 (= n$ m$)))
(let ((?x102 (* (- 1) m$)))
(let ((?x103 (+ n$ ?x102)))
(let (($x118 (>= ?x103 0)))
(let ((?x78 (* (- 1) n$a)))
(let ((?x96 (+ m$ ?x78)))
(let (($x127 (<= ?x96 0)))
(let ((?x79 (+ n$ ?x78)))
(let (($x88 (>= ?x79 0)))
(let (($x239 (or $x88 $x127)))
(let ((@x251 (monotonicity (rewrite (= (and (not $x88) (not $x127)) (not $x239))) (= (not (and (not $x88) (not $x127))) (not (not $x239))))))
(let ((@x271 (trans @x251 (rewrite (= (not (not $x239)) $x239)) (= (not (and (not $x88) (not $x127))) $x239))))
(let (($x128 (not $x127)))
(let (($x87 (not $x88)))
(let (($x143 (and $x87 $x128)))
(let (($x210 (not $x143)))
(let (($x50 (= n$a m$)))
(let (($x57 (and $x50 $x44)))
(let (($x80 (<= ?x79 0)))
(let (($x81 (not $x80)))
(let (($x33 (= m$ n$a)))
(let (($x84 (and $x33 $x81)))
(let (($x91 (and $x44 $x87)))
(let (($x95 (>= ?x96 0)))
(let (($x94 (not $x95)))
(let (($x99 (and $x94 $x81)))
(let (($x48 (= n$a n$)))
(let (($x104 (<= ?x103 0)))
(let (($x105 (not $x104)))
(let (($x108 (and $x105 $x48)))
(let (($x111 (and $x105 $x87)))
(let (($x114 (and $x50 $x105)))
(let (($x117 (not $x118)))
(let (($x121 (and $x48 $x117)))
(let (($x124 (and $x81 $x117)))
(let (($x131 (and $x128 $x44)))
(let (($x134 (and $x128 $x105)))
(let (($x137 (and $x40 $x94)))
(let (($x38 (= n$ n$a)))
(let (($x140 (and $x38 $x128)))
(let (($x146 (and $x117 $x33)))
(let (($x149 (and $x117 $x94)))
(let (($x197 (or $x149 $x146 $x143 $x140 $x137 $x134 $x131 $x124 $x121 $x114 $x111 $x108 $x99 $x91 $x84 $x57)))
(let (($x60 (or (and (< m$ n$a) (< n$a n$)) (or (and $x44 (< n$ n$a)) (or (and $x33 (< n$a n$)) $x57)))))
(let (($x62 (or (and (< m$ n$) (< n$ n$a)) (or (and (< m$ n$) $x48) $x60))))
(let (($x65 (or (and (< n$a n$) (< n$ m$)) (or (and $x48 (< n$ m$)) (or (and $x50 (< m$ n$)) $x62)))))
(let (($x67 (or (and (< n$a m$) (< m$ n$)) (or (and (< n$a m$) $x44) $x65))))
(let (($x70 (or (and (< n$ n$a) (< n$a m$)) (or (and $x38 (< n$a m$)) (or (and $x40 (< m$ n$a)) $x67)))))
(let (($x72 (or (and (< n$ m$) (< m$ n$a)) (or (and (< n$ m$) $x33) $x70))))
(let (($x73 (not $x72)))
(let (($x170 (or $x121 (or $x114 (or $x111 (or $x108 (or $x99 (or $x91 (or $x84 $x57)))))))))
(let (($x191 (or $x146 (or $x143 (or $x140 (or $x137 (or $x134 (or $x131 (or $x124 $x170)))))))))
(let (($x189 (= $x70 (or $x143 (or $x140 (or $x137 (or $x134 (or $x131 (or $x124 $x170)))))))))
(let (($x186 (= (or (and $x38 (< n$a m$)) (or (and $x40 (< m$ n$a)) $x67)) (or $x140 (or $x137 (or $x134 (or $x131 (or $x124 $x170))))))))
(let (($x183 (= (or (and $x40 (< m$ n$a)) $x67) (or $x137 (or $x134 (or $x131 (or $x124 $x170)))))))
(let (($x171 (= (or (and $x48 (< n$ m$)) (or (and $x50 (< m$ n$)) $x62)) $x170)))
(let (($x168 (= (or (and $x50 (< m$ n$)) $x62) (or $x114 (or $x111 (or $x108 (or $x99 (or $x91 (or $x84 $x57)))))))))
(let (($x162 (= (or (and (< m$ n$) $x48) $x60) (or $x108 (or $x99 (or $x91 (or $x84 $x57)))))))
(let (($x156 (= (or (and $x44 (< n$ n$a)) (or (and $x33 (< n$a n$)) $x57)) (or $x91 (or $x84 $x57)))))
(let ((@x83 (rewrite (= (< n$a n$) $x81))))
(let ((@x154 (monotonicity (monotonicity @x83 (= (and $x33 (< n$a n$)) $x84)) (= (or (and $x33 (< n$a n$)) $x57) (or $x84 $x57)))))
(let ((@x90 (rewrite (= (< n$ n$a) $x87))))
(let ((@x157 (monotonicity (monotonicity @x90 (= (and $x44 (< n$ n$a)) $x91)) @x154 $x156)))
(let ((@x98 (rewrite (= (< m$ n$a) $x94))))
(let ((@x101 (monotonicity @x98 @x83 (= (and (< m$ n$a) (< n$a n$)) $x99))))
(let ((@x160 (monotonicity @x101 @x157 (= $x60 (or $x99 (or $x91 (or $x84 $x57)))))))
(let ((@x107 (rewrite (= (< m$ n$) $x105))))
(let ((@x163 (monotonicity (monotonicity @x107 (= (and (< m$ n$) $x48) $x108)) @x160 $x162)))
(let ((@x113 (monotonicity @x107 @x90 (= (and (< m$ n$) (< n$ n$a)) $x111))))
(let ((@x166 (monotonicity @x113 @x163 (= $x62 (or $x111 (or $x108 (or $x99 (or $x91 (or $x84 $x57)))))))))
(let ((@x169 (monotonicity (monotonicity @x107 (= (and $x50 (< m$ n$)) $x114)) @x166 $x168)))
(let ((@x120 (rewrite (= (< n$ m$) $x117))))
(let ((@x172 (monotonicity (monotonicity @x120 (= (and $x48 (< n$ m$)) $x121)) @x169 $x171)))
(let ((@x126 (monotonicity @x83 @x120 (= (and (< n$a n$) (< n$ m$)) $x124))))
(let ((@x130 (rewrite (= (< n$a m$) $x128))))
(let ((@x178 (monotonicity (monotonicity @x130 (= (and (< n$a m$) $x44) $x131)) (monotonicity @x126 @x172 (= $x65 (or $x124 $x170))) (= (or (and (< n$a m$) $x44) $x65) (or $x131 (or $x124 $x170))))))
(let ((@x136 (monotonicity @x130 @x107 (= (and (< n$a m$) (< m$ n$)) $x134))))
(let ((@x181 (monotonicity @x136 @x178 (= $x67 (or $x134 (or $x131 (or $x124 $x170)))))))
(let ((@x184 (monotonicity (monotonicity @x98 (= (and $x40 (< m$ n$a)) $x137)) @x181 $x183)))
(let ((@x187 (monotonicity (monotonicity @x130 (= (and $x38 (< n$a m$)) $x140)) @x184 $x186)))
(let ((@x145 (monotonicity @x90 @x130 (= (and (< n$ n$a) (< n$a m$)) $x143))))
(let ((@x193 (monotonicity (monotonicity @x120 (= (and (< n$ m$) $x33) $x146)) (monotonicity @x145 @x187 $x189) (= (or (and (< n$ m$) $x33) $x70) $x191))))
(let ((@x151 (monotonicity @x120 @x98 (= (and (< n$ m$) (< m$ n$a)) $x149))))
(let ((@x201 (trans (monotonicity @x151 @x193 (= $x72 (or $x149 $x191))) (rewrite (= (or $x149 $x191) $x197)) (= $x72 $x197))))
(let ((@x205 (mp (asserted $x73) (monotonicity @x201 (= $x73 (not $x197))) (not $x197))))
(let ((@x272 (mp (not-or-elim @x205 $x210) @x271 $x239)))
(let (($x273 (not $x38)))
(let (($x274 (or $x273 $x127)))
(let ((@x280 (monotonicity (rewrite (= $x140 (not $x274))) (= (not $x140) (not (not $x274))))))
(let ((@x284 (trans @x280 (rewrite (= (not (not $x274)) $x274)) (= (not $x140) $x274))))
(let ((@x285 (mp (not-or-elim @x205 (not $x140)) @x284 $x274)))
(let (($x286 (not $x40)))
(let (($x311 (not $x44)))
(let ((@x434 (hypothesis $x81)))
(let (($x386 (or $x95 $x80)))
(let ((@x392 (monotonicity (rewrite (= $x99 (not $x386))) (= (not $x99) (not (not $x386))))))
(let ((@x396 (trans @x392 (rewrite (= (not (not $x386)) $x386)) (= (not $x99) $x386))))
(let ((@x397 (mp (not-or-elim @x205 (not $x99)) @x396 $x386)))
(let (($x246 (not $x33)))
(let (($x410 (or $x246 $x80)))
(let ((@x416 (monotonicity (rewrite (= $x84 (not $x410))) (= (not $x84) (not (not $x410))))))
(let ((@x420 (trans @x416 (rewrite (= (not (not $x410)) $x410)) (= (not $x84) $x410))))
(let ((@x421 (mp (not-or-elim @x205 (not $x84)) @x420 $x410)))
(let ((@x439 ((_ th-lemma arith triangle-eq) (or $x33 $x128 $x94))))
(let ((@x440 (unit-resolution @x439 (unit-resolution @x421 @x434 $x246) (unit-resolution @x397 @x434 $x95) $x128)))
(let (($x312 (or $x127 $x311)))
(let ((@x318 (monotonicity (rewrite (= $x131 (not $x312))) (= (not $x131) (not (not $x312))))))
(let ((@x322 (trans @x318 (rewrite (= (not (not $x312)) $x312)) (= (not $x131) $x312))))
(let ((@x323 (mp (not-or-elim @x205 (not $x131)) @x322 $x312)))
(let ((@x450 (mp (unit-resolution @x323 @x440 $x311) (monotonicity (commutativity (= $x44 $x40)) (= $x311 $x286)) $x286)))
(let (($x324 (or $x80 $x118)))
(let ((@x330 (monotonicity (rewrite (= $x124 (not $x324))) (= (not $x124) (not (not $x324))))))
(let ((@x334 (trans @x330 (rewrite (= (not (not $x324)) $x324)) (= (not $x124) $x324))))
(let ((@x335 (mp (not-or-elim @x205 (not $x124)) @x334 $x324)))
(let (($x299 (or $x127 $x104)))
(let ((@x305 (monotonicity (rewrite (= $x134 (not $x299))) (= (not $x134) (not (not $x299))))))
(let ((@x309 (trans @x305 (rewrite (= (not (not $x299)) $x299)) (= (not $x134) $x299))))
(let ((@x310 (mp (not-or-elim @x205 (not $x134)) @x309 $x299)))
(let ((@x444 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x40 $x105 $x117)) (unit-resolution @x310 @x440 $x104) (unit-resolution @x335 @x434 $x118) $x40)))
(let ((@x459 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x38 $x81 $x87)) (lemma (unit-resolution @x444 @x450 false) $x80) (or $x38 $x87))))
(let ((@x460 (unit-resolution @x459 (unit-resolution @x285 (hypothesis $x128) $x273) (unit-resolution @x272 (hypothesis $x128) $x88) false)))
(let ((@x461 (lemma @x460 $x127)))
(let (($x254 (or $x118 $x95)))
(let ((@x262 (monotonicity (rewrite (= $x149 (not $x254))) (= (not $x149) (not (not $x254))))))
(let ((@x256 (trans @x262 (rewrite (= (not (not $x254)) $x254)) (= (not $x149) $x254))))
(let ((@x257 (mp (not-or-elim @x205 (not $x149)) @x256 $x254)))
(let (($x247 (or $x118 $x246)))
(let ((@x259 (monotonicity (rewrite (= $x146 (not $x247))) (= (not $x146) (not (not $x247))))))
(let ((@x245 (trans @x259 (rewrite (= (not (not $x247)) $x247)) (= (not $x146) $x247))))
(let ((@x238 (mp (not-or-elim @x205 (not $x146)) @x245 $x247)))
(let ((@x465 (unit-resolution @x439 (unit-resolution @x238 (hypothesis $x117) $x246) (unit-resolution @x257 (hypothesis $x117) $x95) @x461 false)))
(let (($x336 (not $x48)))
(let (($x374 (or $x104 $x336)))
(let ((@x380 (monotonicity (rewrite (= $x108 (not $x374))) (= (not $x108) (not (not $x374))))))
(let ((@x384 (trans @x380 (rewrite (= (not (not $x374)) $x374)) (= (not $x108) $x374))))
(let ((@x385 (mp (not-or-elim @x205 (not $x108)) @x384 $x374)))
(let ((@x475 (mp (unit-resolution @x385 (hypothesis $x105) $x336) (monotonicity (commutativity (= $x48 $x38)) (= $x336 $x273)) $x273)))
(let (($x362 (or $x104 $x88)))
(let ((@x368 (monotonicity (rewrite (= $x111 (not $x362))) (= (not $x111) (not (not $x362))))))
(let ((@x372 (trans @x368 (rewrite (= (not (not $x362)) $x362)) (= (not $x111) $x362))))
(let ((@x373 (mp (not-or-elim @x205 (not $x111)) @x372 $x362)))
(let ((@x469 (unit-resolution @x459 (unit-resolution @x373 (hypothesis $x105) $x88) $x38)))
(let ((@x478 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x40 $x105 $x117)) (lemma (unit-resolution @x469 @x475 false) $x104) (lemma @x465 $x118) $x40)))
(let (($x287 (or $x286 $x95)))
(let ((@x293 (monotonicity (rewrite (= $x137 (not $x287))) (= (not $x137) (not (not $x287))))))
(let ((@x297 (trans @x293 (rewrite (= (not (not $x287)) $x287)) (= (not $x137) $x287))))
(let ((@x298 (mp (not-or-elim @x205 (not $x137)) @x297 $x287)))
(let ((@x488 (mp (unit-resolution @x439 (unit-resolution @x298 @x478 $x95) @x461 $x33) (symm (commutativity (= $x50 $x33)) (= $x33 $x50)) $x50)))
(let (($x422 (or (not $x50) $x311)))
(let ((@x428 (monotonicity (rewrite (= $x57 (not $x422))) (= (not $x57) (not (not $x422))))))
(let ((@x432 (trans @x428 (rewrite (= (not (not $x422)) $x422)) (= (not $x57) $x422))))
(let ((@x433 (mp (not-or-elim @x205 (not $x57)) @x432 $x422)))
(unit-resolution @x433 @x488 (mp @x478 @x480 $x44) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

32286f9c5e71eb2b15c18f86f04c80931e2e307b 878 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x184 (* (- 1) x7$)))
(let (($x363 (>= x7$ 0)))
(let ((?x370 (ite $x363 x7$ ?x184)))
(let ((?x381 (* (- 1) ?x370)))
(let ((?x668 (+ x7$ ?x381)))
(let (($x670 (>= ?x668 0)))
(let (($x707 (not $x670)))
(let ((?x655 (* (- 1) x11$)))
(let ((?x656 (+ x2$ ?x655)))
(let (($x657 (<= ?x656 0)))
(let (($x766 (not $x657)))
(let (($x92 (= x2$ x11$)))
(let (($x583 (not $x92)))
(let (($x91 (= x1$ x10$)))
(let ((?x235 (* (- 1) x10$)))
(let ((?x652 (+ x1$ ?x235)))
(let (($x653 (<= ?x652 0)))
(let ((?x133 (* (- 1) x4$)))
(let (($x438 (>= x4$ 0)))
(let ((?x445 (ite $x438 x4$ ?x133)))
(let ((?x456 (* (- 1) ?x445)))
(let ((?x677 (+ x4$ ?x456)))
(let (($x678 (<= ?x677 0)))
(let ((?x150 (* (- 1) x5$)))
(let (($x413 (>= x5$ 0)))
(let ((?x420 (ite $x413 x5$ ?x150)))
(let ((?x431 (* (- 1) ?x420)))
(let ((?x757 (+ x5$ ?x431)))
(let (($x776 (>= ?x757 0)))
(let (($x604 (= x5$ ?x420)))
(let (($x313 (>= x10$ 0)))
(let ((?x320 (ite $x313 x10$ ?x235)))
(let ((?x331 (* (- 1) ?x320)))
(let ((?x662 (+ x10$ ?x331)))
(let (($x1381 (<= ?x662 0)))
(let (($x644 (= x10$ ?x320)))
(let (($x645 (= ?x235 ?x320)))
(let (($x1121 (not $x645)))
(let ((?x1103 (+ ?x235 ?x331)))
(let (($x1249 (<= ?x1103 0)))
(let (($x1261 (not $x1249)))
(let ((?x218 (* (- 1) x9$)))
(let (($x288 (>= x9$ 0)))
(let ((?x295 (ite $x288 x9$ ?x218)))
(let ((?x306 (* (- 1) ?x295)))
(let ((?x1356 (+ ?x218 ?x306)))
(let (($x1369 (>= ?x1356 0)))
(let (($x637 (= ?x218 ?x295)))
(let (($x289 (not $x288)))
(let (($x414 (not $x413)))
(let ((@x844 (hypothesis $x414)))
(let (($x388 (>= x6$ 0)))
(let (($x596 (= x4$ ?x445)))
(let ((@x1078 (hypothesis $x288)))
(let ((?x201 (* (- 1) x8$)))
(let (($x338 (>= x8$ 0)))
(let ((?x345 (ite $x338 x8$ ?x201)))
(let ((?x356 (* (- 1) ?x345)))
(let ((?x665 (+ x8$ ?x356)))
(let (($x667 (>= ?x665 0)))
(let (($x860 (not $x667)))
(let (($x439 (not $x438)))
(let ((@x763 (hypothesis $x439)))
(let ((?x432 (+ x4$ x6$ ?x431)))
(let (($x611 (>= ?x432 0)))
(let (($x433 (= ?x432 0)))
(let ((?x332 (+ x9$ x11$ ?x331)))
(let (($x333 (= ?x332 0)))
(let ((?x307 (+ x8$ x10$ ?x306)))
(let (($x308 (= ?x307 0)))
(let ((?x357 (+ x7$ x9$ ?x356)))
(let (($x358 (= ?x357 0)))
(let ((?x382 (+ x6$ x8$ ?x381)))
(let (($x383 (= ?x382 0)))
(let ((?x167 (* (- 1) x6$)))
(let ((?x395 (ite $x388 x6$ ?x167)))
(let ((?x406 (* (- 1) ?x395)))
(let ((?x407 (+ x5$ x7$ ?x406)))
(let (($x408 (= ?x407 0)))
(let ((?x457 (+ x3$ x5$ ?x456)))
(let (($x458 (= ?x457 0)))
(let ((?x116 (* (- 1) x3$)))
(let (($x463 (>= x3$ 0)))
(let ((?x470 (ite $x463 x3$ ?x116)))
(let ((?x481 (* (- 1) ?x470)))
(let ((?x482 (+ x2$ x4$ ?x481)))
(let (($x483 (= ?x482 0)))
(let ((?x98 (* (- 1) x2$)))
(let (($x488 (>= x2$ 0)))
(let ((?x495 (ite $x488 x2$ ?x98)))
(let ((?x506 (* (- 1) ?x495)))
(let ((?x507 (+ x3$ x1$ ?x506)))
(let (($x508 (= ?x507 0)))
(let (($x537 (and $x508 $x483 $x458 $x433 $x408 $x383 $x358 $x308 $x333)))
(let (($x548 (not (or (not $x537) (and $x91 $x92)))))
(let (($x93 (and $x91 $x92)))
(let (($x83 (and (= x10$ (- (ite (< x9$ 0) (- x9$) x9$) x8$)) (= x11$ (- (ite (< x10$ 0) (- x10$) x10$) x9$)))))
(let (($x85 (and (= x8$ (- (ite (< x7$ 0) (- x7$) x7$) x6$)) (and (= x9$ (- (ite (< x8$ 0) (- x8$) x8$) x7$)) $x83))))
(let (($x87 (and (= x6$ (- (ite (< x5$ 0) (- x5$) x5$) x4$)) (and (= x7$ (- (ite (< x6$ 0) (- x6$) x6$) x5$)) $x85))))
(let (($x89 (and (= x4$ (- (ite (< x3$ 0) (- x3$) x3$) x2$)) (and (= x5$ (- (ite (< x4$ 0) (- x4$) x4$) x3$)) $x87))))
(let (($x94 (=> (and (= x3$ (- (ite (< x2$ 0) (- x2$) x2$) x1$)) $x89) $x93)))
(let (($x95 (not $x94)))
(let (($x78 (< x10$ 0)))
(let ((?x238 (ite $x78 ?x235 x10$)))
(let ((?x244 (+ ?x218 ?x238)))
(let (($x249 (= x11$ ?x244)))
(let (($x72 (< x9$ 0)))
(let ((?x221 (ite $x72 ?x218 x9$)))
(let ((?x227 (+ ?x201 ?x221)))
(let (($x232 (= x10$ ?x227)))
(let (($x252 (and $x232 $x249)))
(let (($x66 (< x8$ 0)))
(let ((?x204 (ite $x66 ?x201 x8$)))
(let ((?x210 (+ ?x184 ?x204)))
(let (($x215 (= x9$ ?x210)))
(let (($x255 (and $x215 $x252)))
(let (($x60 (< x7$ 0)))
(let ((?x187 (ite $x60 ?x184 x7$)))
(let ((?x193 (+ ?x167 ?x187)))
(let (($x198 (= x8$ ?x193)))
(let (($x258 (and $x198 $x255)))
(let (($x54 (< x6$ 0)))
(let ((?x170 (ite $x54 ?x167 x6$)))
(let ((?x176 (+ ?x150 ?x170)))
(let (($x181 (= x7$ ?x176)))
(let (($x261 (and $x181 $x258)))
(let (($x48 (< x5$ 0)))
(let ((?x153 (ite $x48 ?x150 x5$)))
(let ((?x159 (+ ?x133 ?x153)))
(let (($x164 (= x6$ ?x159)))
(let (($x264 (and $x164 $x261)))
(let (($x42 (< x4$ 0)))
(let ((?x136 (ite $x42 ?x133 x4$)))
(let ((?x142 (+ ?x116 ?x136)))
(let (($x147 (= x5$ ?x142)))
(let (($x267 (and $x147 $x264)))
(let (($x36 (< x3$ 0)))
(let ((?x119 (ite $x36 ?x116 x3$)))
(let ((?x125 (+ ?x98 ?x119)))
(let (($x130 (= x4$ ?x125)))
(let (($x270 (and $x130 $x267)))
(let (($x29 (< x2$ 0)))
(let ((?x101 (ite $x29 ?x98 x2$)))
(let ((?x108 (+ (* (- 1) x1$) ?x101)))
(let (($x113 (= x3$ ?x108)))
(let (($x273 (and $x113 $x270)))
(let (($x280 (or (not $x273) $x93)))
(let (($x528 (and $x458 (and $x433 (and $x408 (and $x383 (and $x358 (and $x308 $x333))))))))
(let (($x526 (= $x264 (and $x433 (and $x408 (and $x383 (and $x358 (and $x308 $x333))))))))
(let ((@x319 (monotonicity (rewrite (= $x78 (not $x313))) (= ?x238 (ite (not $x313) ?x235 x10$)))))
(let ((@x324 (trans @x319 (rewrite (= (ite (not $x313) ?x235 x10$) ?x320)) (= ?x238 ?x320))))
(let ((@x330 (monotonicity (monotonicity @x324 (= ?x244 (+ ?x218 ?x320))) (= $x249 (= x11$ (+ ?x218 ?x320))))))
(let ((@x337 (trans @x330 (rewrite (= (= x11$ (+ ?x218 ?x320)) $x333)) (= $x249 $x333))))
(let ((@x294 (monotonicity (rewrite (= $x72 $x289)) (= ?x221 (ite $x289 ?x218 x9$)))))
(let ((@x302 (monotonicity (trans @x294 (rewrite (= (ite $x289 ?x218 x9$) ?x295)) (= ?x221 ?x295)) (= ?x227 (+ ?x201 ?x295)))))
(let ((@x312 (trans (monotonicity @x302 (= $x232 (= x10$ (+ ?x201 ?x295)))) (rewrite (= (= x10$ (+ ?x201 ?x295)) $x308)) (= $x232 $x308))))
(let ((@x344 (monotonicity (rewrite (= $x66 (not $x338))) (= ?x204 (ite (not $x338) ?x201 x8$)))))
(let ((@x349 (trans @x344 (rewrite (= (ite (not $x338) ?x201 x8$) ?x345)) (= ?x204 ?x345))))
(let ((@x355 (monotonicity (monotonicity @x349 (= ?x210 (+ ?x184 ?x345))) (= $x215 (= x9$ (+ ?x184 ?x345))))))
(let ((@x362 (trans @x355 (rewrite (= (= x9$ (+ ?x184 ?x345)) $x358)) (= $x215 $x358))))
(let ((@x518 (monotonicity @x362 (monotonicity @x312 @x337 (= $x252 (and $x308 $x333))) (= $x255 (and $x358 (and $x308 $x333))))))
(let ((@x369 (monotonicity (rewrite (= $x60 (not $x363))) (= ?x187 (ite (not $x363) ?x184 x7$)))))
(let ((@x374 (trans @x369 (rewrite (= (ite (not $x363) ?x184 x7$) ?x370)) (= ?x187 ?x370))))
(let ((@x380 (monotonicity (monotonicity @x374 (= ?x193 (+ ?x167 ?x370))) (= $x198 (= x8$ (+ ?x167 ?x370))))))
(let ((@x387 (trans @x380 (rewrite (= (= x8$ (+ ?x167 ?x370)) $x383)) (= $x198 $x383))))
(let ((@x521 (monotonicity @x387 @x518 (= $x258 (and $x383 (and $x358 (and $x308 $x333)))))))
(let ((@x394 (monotonicity (rewrite (= $x54 (not $x388))) (= ?x170 (ite (not $x388) ?x167 x6$)))))
(let ((@x399 (trans @x394 (rewrite (= (ite (not $x388) ?x167 x6$) ?x395)) (= ?x170 ?x395))))
(let ((@x405 (monotonicity (monotonicity @x399 (= ?x176 (+ ?x150 ?x395))) (= $x181 (= x7$ (+ ?x150 ?x395))))))
(let ((@x412 (trans @x405 (rewrite (= (= x7$ (+ ?x150 ?x395)) $x408)) (= $x181 $x408))))
(let ((@x524 (monotonicity @x412 @x521 (= $x261 (and $x408 (and $x383 (and $x358 (and $x308 $x333))))))))
(let ((@x419 (monotonicity (rewrite (= $x48 $x414)) (= ?x153 (ite $x414 ?x150 x5$)))))
(let ((@x427 (monotonicity (trans @x419 (rewrite (= (ite $x414 ?x150 x5$) ?x420)) (= ?x153 ?x420)) (= ?x159 (+ ?x133 ?x420)))))
(let ((@x437 (trans (monotonicity @x427 (= $x164 (= x6$ (+ ?x133 ?x420)))) (rewrite (= (= x6$ (+ ?x133 ?x420)) $x433)) (= $x164 $x433))))
(let ((@x444 (monotonicity (rewrite (= $x42 $x439)) (= ?x136 (ite $x439 ?x133 x4$)))))
(let ((@x452 (monotonicity (trans @x444 (rewrite (= (ite $x439 ?x133 x4$) ?x445)) (= ?x136 ?x445)) (= ?x142 (+ ?x116 ?x445)))))
(let ((@x462 (trans (monotonicity @x452 (= $x147 (= x5$ (+ ?x116 ?x445)))) (rewrite (= (= x5$ (+ ?x116 ?x445)) $x458)) (= $x147 $x458))))
(let ((@x469 (monotonicity (rewrite (= $x36 (not $x463))) (= ?x119 (ite (not $x463) ?x116 x3$)))))
(let ((@x474 (trans @x469 (rewrite (= (ite (not $x463) ?x116 x3$) ?x470)) (= ?x119 ?x470))))
(let ((@x480 (monotonicity (monotonicity @x474 (= ?x125 (+ ?x98 ?x470))) (= $x130 (= x4$ (+ ?x98 ?x470))))))
(let ((@x487 (trans @x480 (rewrite (= (= x4$ (+ ?x98 ?x470)) $x483)) (= $x130 $x483))))
(let ((@x533 (monotonicity @x487 (monotonicity @x462 (monotonicity @x437 @x524 $x526) (= $x267 $x528)) (= $x270 (and $x483 $x528)))))
(let ((@x494 (monotonicity (rewrite (= $x29 (not $x488))) (= ?x101 (ite (not $x488) ?x98 x2$)))))
(let ((@x499 (trans @x494 (rewrite (= (ite (not $x488) ?x98 x2$) ?x495)) (= ?x101 ?x495))))
(let ((@x505 (monotonicity (monotonicity @x499 (= ?x108 (+ (* (- 1) x1$) ?x495))) (= $x113 (= x3$ (+ (* (- 1) x1$) ?x495))))))
(let ((@x512 (trans @x505 (rewrite (= (= x3$ (+ (* (- 1) x1$) ?x495)) $x508)) (= $x113 $x508))))
(let ((@x541 (trans (monotonicity @x512 @x533 (= $x273 (and $x508 (and $x483 $x528)))) (rewrite (= (and $x508 (and $x483 $x528)) $x537)) (= $x273 $x537))))
(let ((@x547 (monotonicity (monotonicity @x541 (= (not $x273) (not $x537))) (= $x280 (or (not $x537) $x93)))))
(let ((@x240 (monotonicity (rewrite (= (- x10$) ?x235)) (= (ite $x78 (- x10$) x10$) ?x238))))
(let ((@x243 (monotonicity @x240 (= (- (ite $x78 (- x10$) x10$) x9$) (- ?x238 x9$)))))
(let ((@x248 (trans @x243 (rewrite (= (- ?x238 x9$) ?x244)) (= (- (ite $x78 (- x10$) x10$) x9$) ?x244))))
(let ((@x251 (monotonicity @x248 (= (= x11$ (- (ite $x78 (- x10$) x10$) x9$)) $x249))))
(let ((@x223 (monotonicity (rewrite (= (- x9$) ?x218)) (= (ite $x72 (- x9$) x9$) ?x221))))
(let ((@x226 (monotonicity @x223 (= (- (ite $x72 (- x9$) x9$) x8$) (- ?x221 x8$)))))
(let ((@x231 (trans @x226 (rewrite (= (- ?x221 x8$) ?x227)) (= (- (ite $x72 (- x9$) x9$) x8$) ?x227))))
(let ((@x234 (monotonicity @x231 (= (= x10$ (- (ite $x72 (- x9$) x9$) x8$)) $x232))))
(let ((@x206 (monotonicity (rewrite (= (- x8$) ?x201)) (= (ite $x66 (- x8$) x8$) ?x204))))
(let ((@x209 (monotonicity @x206 (= (- (ite $x66 (- x8$) x8$) x7$) (- ?x204 x7$)))))
(let ((@x214 (trans @x209 (rewrite (= (- ?x204 x7$) ?x210)) (= (- (ite $x66 (- x8$) x8$) x7$) ?x210))))
(let ((@x217 (monotonicity @x214 (= (= x9$ (- (ite $x66 (- x8$) x8$) x7$)) $x215))))
(let ((@x257 (monotonicity @x217 (monotonicity @x234 @x251 (= $x83 $x252)) (= (and (= x9$ (- (ite $x66 (- x8$) x8$) x7$)) $x83) $x255))))
(let ((@x189 (monotonicity (rewrite (= (- x7$) ?x184)) (= (ite $x60 (- x7$) x7$) ?x187))))
(let ((@x192 (monotonicity @x189 (= (- (ite $x60 (- x7$) x7$) x6$) (- ?x187 x6$)))))
(let ((@x197 (trans @x192 (rewrite (= (- ?x187 x6$) ?x193)) (= (- (ite $x60 (- x7$) x7$) x6$) ?x193))))
(let ((@x200 (monotonicity @x197 (= (= x8$ (- (ite $x60 (- x7$) x7$) x6$)) $x198))))
(let ((@x172 (monotonicity (rewrite (= (- x6$) ?x167)) (= (ite $x54 (- x6$) x6$) ?x170))))
(let ((@x175 (monotonicity @x172 (= (- (ite $x54 (- x6$) x6$) x5$) (- ?x170 x5$)))))
(let ((@x180 (trans @x175 (rewrite (= (- ?x170 x5$) ?x176)) (= (- (ite $x54 (- x6$) x6$) x5$) ?x176))))
(let ((@x183 (monotonicity @x180 (= (= x7$ (- (ite $x54 (- x6$) x6$) x5$)) $x181))))
(let ((@x263 (monotonicity @x183 (monotonicity @x200 @x257 (= $x85 $x258)) (= (and (= x7$ (- (ite $x54 (- x6$) x6$) x5$)) $x85) $x261))))
(let ((@x155 (monotonicity (rewrite (= (- x5$) ?x150)) (= (ite $x48 (- x5$) x5$) ?x153))))
(let ((@x158 (monotonicity @x155 (= (- (ite $x48 (- x5$) x5$) x4$) (- ?x153 x4$)))))
(let ((@x163 (trans @x158 (rewrite (= (- ?x153 x4$) ?x159)) (= (- (ite $x48 (- x5$) x5$) x4$) ?x159))))
(let ((@x166 (monotonicity @x163 (= (= x6$ (- (ite $x48 (- x5$) x5$) x4$)) $x164))))
(let ((@x138 (monotonicity (rewrite (= (- x4$) ?x133)) (= (ite $x42 (- x4$) x4$) ?x136))))
(let ((@x141 (monotonicity @x138 (= (- (ite $x42 (- x4$) x4$) x3$) (- ?x136 x3$)))))
(let ((@x146 (trans @x141 (rewrite (= (- ?x136 x3$) ?x142)) (= (- (ite $x42 (- x4$) x4$) x3$) ?x142))))
(let ((@x149 (monotonicity @x146 (= (= x5$ (- (ite $x42 (- x4$) x4$) x3$)) $x147))))
(let ((@x269 (monotonicity @x149 (monotonicity @x166 @x263 (= $x87 $x264)) (= (and (= x5$ (- (ite $x42 (- x4$) x4$) x3$)) $x87) $x267))))
(let ((@x121 (monotonicity (rewrite (= (- x3$) ?x116)) (= (ite $x36 (- x3$) x3$) ?x119))))
(let ((@x124 (monotonicity @x121 (= (- (ite $x36 (- x3$) x3$) x2$) (- ?x119 x2$)))))
(let ((@x129 (trans @x124 (rewrite (= (- ?x119 x2$) ?x125)) (= (- (ite $x36 (- x3$) x3$) x2$) ?x125))))
(let ((@x132 (monotonicity @x129 (= (= x4$ (- (ite $x36 (- x3$) x3$) x2$)) $x130))))
(let ((@x103 (monotonicity (rewrite (= (- x2$) ?x98)) (= (ite $x29 (- x2$) x2$) ?x101))))
(let ((@x106 (monotonicity @x103 (= (- (ite $x29 (- x2$) x2$) x1$) (- ?x101 x1$)))))
(let ((@x112 (trans @x106 (rewrite (= (- ?x101 x1$) ?x108)) (= (- (ite $x29 (- x2$) x2$) x1$) ?x108))))
(let ((@x115 (monotonicity @x112 (= (= x3$ (- (ite $x29 (- x2$) x2$) x1$)) $x113))))
(let ((@x275 (monotonicity @x115 (monotonicity @x132 @x269 (= $x89 $x270)) (= (and (= x3$ (- (ite $x29 (- x2$) x2$) x1$)) $x89) $x273))))
(let ((@x284 (trans (monotonicity @x275 (= $x94 (=> $x273 $x93))) (rewrite (= (=> $x273 $x93) $x280)) (= $x94 $x280))))
(let ((@x552 (trans (monotonicity @x284 (= $x95 (not $x280))) (monotonicity @x547 (= (not $x280) $x548)) (= $x95 $x548))))
(let ((@x554 (not-or-elim (mp (asserted $x95) @x552 $x548) $x537)))
(let ((@x558 (and-elim @x554 $x433)))
(let ((@x799 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x433) $x611)) @x558 $x611)))
(let ((?x931 (+ ?x150 ?x431)))
(let (($x933 (<= ?x931 0)))
(let (($x605 (= ?x150 ?x420)))
(let ((@x1000 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x605) $x933)) (unit-resolution (def-axiom (or $x413 $x605)) @x844 $x605) $x933)))
(let (($x634 (<= ?x357 0)))
(let ((@x561 (and-elim @x554 $x358)))
(let ((@x857 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x358) $x634)) @x561 $x634)))
(let (($x620 (= x7$ ?x370)))
(let ((?x777 (+ ?x167 ?x406)))
(let (($x780 (<= ?x777 0)))
(let (($x613 (= ?x167 ?x395)))
(let (($x389 (not $x388)))
(let (($x364 (not $x363)))
(let ((@x1027 (hypothesis $x364)))
(let ((@x1026 (hypothesis $x388)))
(let (($x619 (>= ?x407 0)))
(let ((@x559 (and-elim @x554 $x408)))
(let ((@x853 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x408) $x619)) @x559 $x619)))
(let ((?x671 (+ x6$ ?x406)))
(let (($x936 (<= ?x671 0)))
(let (($x612 (= x6$ ?x395)))
(let ((@x615 (def-axiom (or $x389 $x612))))
(let ((@x950 ((_ th-lemma arith triangle-eq) (or (not $x612) $x936))))
(let ((@x1029 (unit-resolution @x950 (unit-resolution @x615 @x1026 $x612) $x936)))
(let ((@x1032 (lemma ((_ th-lemma arith farkas 1 1 1 1 1) @x1029 @x853 @x1027 @x844 @x1026 false) (or $x363 $x413 $x389))))
(let ((@x617 (def-axiom (or $x388 $x613))))
(let ((@x1063 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x613) $x780)) (unit-resolution @x617 (unit-resolution @x1032 @x1027 @x844 $x389) $x613) $x780)))
(let ((@x1064 ((_ th-lemma arith farkas 1 1 1 1 1) (unit-resolution @x1032 @x1027 @x844 $x389) @x1027 @x853 @x844 @x1063 false)))
(let ((@x623 (def-axiom (or $x364 $x620))))
(let ((@x1087 (unit-resolution @x623 (unit-resolution (lemma @x1064 (or $x363 $x413)) @x844 $x363) $x620)))
(let ((@x926 ((_ th-lemma arith triangle-eq) (or (not $x620) $x670))))
(let ((@x1088 (unit-resolution @x926 @x1087 $x670)))
(let (($x626 (<= ?x382 0)))
(let ((@x560 (and-elim @x554 $x383)))
(let ((@x703 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x383) $x626)) @x560 $x626)))
(let ((@x858 (hypothesis $x667)))
(let ((@x1104 (lemma ((_ th-lemma arith farkas 1 1 1 1 1 1 1 1 1) @x858 @x703 @x1088 @x857 @x763 @x1000 @x844 @x799 @x1078 false) (or $x438 $x860 $x413 $x289))))
(let (($x628 (= x8$ ?x345)))
(let (($x840 (<= ?x668 0)))
(let ((@x865 ((_ th-lemma arith triangle-eq) (or (not $x620) $x840))))
(let ((@x1089 (unit-resolution @x865 @x1087 $x840)))
(let (($x627 (>= ?x382 0)))
(let ((@x835 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x383) $x627)) @x560 $x627)))
(let ((@x1241 (unit-resolution ((_ th-lemma arith assign-bounds 1 1 1 1) (or $x438 (not $x933) $x413 (not $x611) $x388)) @x763 @x799 @x1000 @x844 $x388)))
(let ((@x1094 ((_ th-lemma arith assign-bounds 1 1 1 1 1) (or $x338 (not $x627) (not $x840) (not $x936) (not $x619) $x413))))
(let ((@x1244 (unit-resolution @x1094 (unit-resolution @x950 (unit-resolution @x615 @x1241 $x612) $x936) @x835 @x844 @x1089 @x853 $x338)))
(let ((@x631 (def-axiom (or (not $x338) $x628))))
(let ((@x1117 ((_ th-lemma arith triangle-eq) (or (not $x628) $x667))))
(let ((@x1246 (unit-resolution @x1117 (unit-resolution @x631 @x1244 $x628) (unit-resolution @x1104 @x763 @x844 @x1078 $x860) false)))
(let ((@x599 (def-axiom (or $x439 $x596))))
(let ((@x1327 (unit-resolution @x599 (unit-resolution (lemma @x1246 (or $x438 $x413 $x289)) @x844 @x1078 $x438) $x596)))
(let ((@x693 ((_ th-lemma arith triangle-eq) (or (not $x596) $x678))))
(let ((?x659 (+ x9$ ?x306)))
(let (($x661 (>= ?x659 0)))
(let (($x636 (= x9$ ?x295)))
(let ((@x639 (def-axiom (or $x289 $x636))))
(let ((@x1146 ((_ th-lemma arith triangle-eq) (or (not $x636) $x661))))
(let ((@x1147 (unit-resolution @x1146 (unit-resolution @x639 @x1078 $x636) $x661)))
(let (($x660 (<= ?x659 0)))
(let ((@x1151 ((_ th-lemma arith triangle-eq) (or (not $x636) $x660))))
(let ((@x1152 (unit-resolution @x1151 (unit-resolution @x639 @x1078 $x636) $x660)))
(let (($x658 (>= ?x656 0)))
(let (($x673 (>= ?x671 0)))
(let (($x706 (not $x673)))
(let (($x663 (<= ?x665 0)))
(let (($x643 (>= ?x307 0)))
(let ((@x562 (and-elim @x554 $x308)))
(let ((@x1138 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x308) $x643)) @x562 $x643)))
(let (($x314 (not $x313)))
(let (($x1164 (not $x644)))
(let (($x664 (>= ?x662 0)))
(let (($x734 (not $x664)))
(let (($x710 (not $x658)))
(let ((@x711 (hypothesis $x710)))
(let ((@x731 (hypothesis $x661)))
(let ((@x716 (hypothesis $x664)))
(let (($x621 (= ?x184 ?x370)))
(let (($x823 (not $x621)))
(let ((?x778 (+ ?x184 ?x381)))
(let (($x779 (<= ?x778 0)))
(let (($x902 (not $x779)))
(let (($x669 (>= ?x677 0)))
(let (($x464 (not $x463)))
(let ((@x688 (hypothesis $x464)))
(let (($x847 (not $x613)))
(let (($x839 (>= ?x777 0)))
(let (($x872 (not $x839)))
(let ((?x680 (+ x3$ ?x481)))
(let (($x681 (<= ?x680 0)))
(let ((?x676 (+ ?x116 ?x481)))
(let (($x679 (<= ?x676 0)))
(let (($x589 (= ?x116 ?x470)))
(let ((@x758 (unit-resolution (def-axiom (or $x463 $x589)) @x688 $x589)))
(let ((@x762 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x589) $x679)) @x758 $x679)))
(let ((?x674 (+ ?x133 ?x456)))
(let (($x675 (<= ?x674 0)))
(let (($x597 (= ?x133 ?x445)))
(let ((@x601 (def-axiom (or $x438 $x597))))
(let ((@x941 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x597) $x675)) (unit-resolution @x601 @x763 $x597) $x675)))
(let ((@x944 (unit-resolution ((_ th-lemma arith assign-bounds 2 1) (or $x678 $x438 (not $x675))) @x941 @x763 $x678)))
(let ((@x869 (hypothesis $x681)))
(let ((@x868 (hypothesis $x678)))
(let ((@x867 (hypothesis $x839)))
(let ((@x866 (unit-resolution @x865 (unit-resolution @x623 (hypothesis $x363) $x620) $x840)))
(let ((@x841 (hypothesis $x363)))
(let (($x618 (<= ?x407 0)))
(let ((@x698 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x408) $x618)) @x559 $x618)))
(let (($x603 (>= ?x457 0)))
(let ((@x557 (and-elim @x554 $x458)))
(let ((@x687 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x458) $x603)) @x557 $x603)))
(let (($x650 (<= ?x332 0)))
(let ((@x563 (and-elim @x554 $x333)))
(let ((@x715 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x333) $x650)) @x563 $x650)))
(let (($x595 (>= ?x482 0)))
(let ((@x556 (and-elim @x554 $x483)))
(let ((@x720 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x483) $x595)) @x556 $x595)))
(let (($x642 (<= ?x307 0)))
(let ((@x730 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x308) $x642)) @x562 $x642)))
(let ((@x870 ((_ th-lemma arith farkas -1 1 -1 1 -1 -1 1 1 -1 1 1 -1 -2 1) @x835 @x869 @x731 @x730 @x720 @x716 @x715 @x711 @x687 @x868 @x698 @x867 @x841 @x866 false)))
(let ((@x874 (lemma @x870 (or $x364 (not $x681) (not $x661) $x734 $x658 (not $x678) $x872))))
(let ((@x625 (def-axiom (or $x363 $x621))))
(let ((@x880 (unit-resolution @x625 (unit-resolution @x874 @x867 @x731 @x716 @x711 @x868 @x869 $x364) $x621)))
(let ((@x882 ((_ th-lemma arith farkas -1 1 -1 1 -1 -1 1 1 -1 1 1 -1 1) @x835 @x869 @x731 @x730 @x720 @x716 @x715 @x711 @x687 @x868 @x698 @x867 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x823 $x779)) @x880 $x779) false)))
(let ((@x884 (lemma @x882 (or $x872 (not $x681) (not $x661) $x734 $x658 (not $x678)))))
(let ((@x945 (unit-resolution @x884 @x944 @x731 @x716 @x711 (unit-resolution ((_ th-lemma arith assign-bounds 1 2) (or $x681 (not $x679) $x463)) @x762 @x688 $x681) $x872)))
(let ((@x892 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x847 $x839)) (hypothesis $x613) (hypothesis $x872) false)))
(let ((@x893 (lemma @x892 (or $x847 $x839))))
(let ((@x948 (unit-resolution @x615 (unit-resolution @x617 (unit-resolution @x893 @x945 $x847) $x388) $x612)))
(let (($x775 (<= ?x757 0)))
(let ((@x954 (unit-resolution ((_ th-lemma arith assign-bounds 1 1 1 1) (or $x413 (not $x675) (not $x603) $x463 $x438)) @x763 @x687 @x688 @x941 $x413)))
(let ((@x607 (def-axiom (or $x414 $x604))))
(let ((@x794 ((_ th-lemma arith triangle-eq) (or (not $x604) $x775))))
(let ((@x960 ((_ th-lemma arith assign-bounds 1 1 1 1 1) (or $x363 (not $x936) (not $x619) $x438 (not $x775) (not $x611)))))
(let ((@x961 (unit-resolution @x960 @x763 @x853 @x799 (unit-resolution @x794 (unit-resolution @x607 @x954 $x604) $x775) (unit-resolution @x950 @x948 $x936) $x363)))
(let (($x602 (<= ?x457 0)))
(let ((@x832 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x458) $x602)) @x557 $x602)))
(let (($x932 (>= ?x674 0)))
(let ((@x966 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x597) $x932)) (unit-resolution @x601 @x763 $x597) $x932)))
(let ((@x967 ((_ th-lemma arith farkas -1 -1 1 1 -1 -1 1 1 1 -1 -1 1 1) @x835 @x731 @x730 @x762 @x720 @x716 @x715 @x711 (unit-resolution @x950 @x948 $x936) @x853 @x966 @x832 (unit-resolution @x865 (unit-resolution @x623 @x961 $x620) $x840) false)))
(let ((@x974 (unit-resolution (lemma @x967 (or $x438 (not $x661) $x734 $x658 $x463)) @x688 @x716 @x711 @x731 $x438)))
(let ((@x828 ((_ th-lemma arith triangle-eq) (or (not $x596) $x669))))
(let ((@x978 (unit-resolution ((_ th-lemma arith assign-bounds 1 1 1 1) (or $x413 (not $x603) $x463 $x439 (not $x678))) (unit-resolution @x693 (unit-resolution @x599 @x974 $x596) $x678) @x687 @x688 @x974 $x413)))
(let ((@x791 ((_ th-lemma arith triangle-eq) (or (not $x604) $x776))))
(let ((@x981 (unit-resolution @x884 (unit-resolution @x693 (unit-resolution @x599 @x974 $x596) $x678) @x731 @x716 @x711 (unit-resolution ((_ th-lemma arith assign-bounds 1 2) (or $x681 (not $x679) $x463)) @x762 @x688 $x681) $x872)))
(let ((@x984 (unit-resolution @x615 (unit-resolution @x617 (unit-resolution @x893 @x981 $x847) $x388) $x612)))
(let ((@x808 ((_ th-lemma arith triangle-eq) (or (not $x612) $x673))))
(let (($x903 (not $x669)))
(let (($x817 (not $x776)))
(let (($x813 (not $x679)))
(let (($x733 (not $x661)))
(let ((@x900 (hypothesis $x669)))
(let (($x610 (<= ?x432 0)))
(let ((@x812 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x433) $x610)) @x558 $x610)))
(let ((@x699 (hypothesis $x673)))
(let ((@x934 (hypothesis $x679)))
(let ((@x935 ((_ th-lemma arith farkas -1 -1 1 1 -1 -1 1 1 -1 1 -2 2 -1 1 1) @x835 @x731 @x730 @x934 @x720 @x716 @x715 @x711 @x699 @x698 (hypothesis $x776) @x812 @x900 @x832 (hypothesis $x779) false)))
(let ((@x986 (unit-resolution (lemma @x935 (or $x902 $x733 $x813 $x734 $x658 $x706 $x817 $x903)) @x762 @x731 @x716 @x711 (unit-resolution @x808 @x984 $x673) (unit-resolution @x791 (unit-resolution @x607 @x978 $x604) $x776) (unit-resolution @x828 (unit-resolution @x599 @x974 $x596) $x669) $x902)))
(let ((@x906 (hypothesis $x902)))
(let ((@x908 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x823 $x779)) (hypothesis $x621) @x906 false)))
(let ((@x909 (lemma @x908 (or $x823 $x779))))
(let ((@x989 (unit-resolution @x623 (unit-resolution @x625 (unit-resolution @x909 @x986 $x823) $x363) $x620)))
(let ((@x991 ((_ th-lemma arith farkas -1 -1 1 1 -1 -1 1 1 -1 1 -2 2 -2 -1 1 1) @x835 @x731 @x730 @x762 @x720 @x716 @x715 @x711 (unit-resolution @x808 @x984 $x673) @x698 (unit-resolution @x791 (unit-resolution @x607 @x978 $x604) $x776) @x812 (unit-resolution @x625 (unit-resolution @x909 @x986 $x823) $x363) (unit-resolution @x828 (unit-resolution @x599 @x974 $x596) $x669) @x832 (unit-resolution @x865 @x989 $x840) false)))
(let ((@x972 (unit-resolution (lemma @x991 (or $x463 $x733 $x734 $x658)) @x716 @x731 @x711 $x463)))
(let (($x588 (= x3$ ?x470)))
(let ((@x591 (def-axiom (or $x464 $x588))))
(let ((@x725 ((_ th-lemma arith triangle-eq) (or (not $x588) $x681))))
(let ((@x994 (unit-resolution @x725 (unit-resolution @x591 @x972 $x588) $x681)))
(let ((@x1011 (unit-resolution @x893 (unit-resolution @x884 @x944 @x731 @x716 @x711 @x994 $x872) $x847)))
(let ((@x1014 (unit-resolution @x950 (unit-resolution @x615 (unit-resolution @x617 @x1011 $x388) $x612) $x936)))
(let ((@x1001 (hypothesis $x936)))
(let ((@x1004 ((_ th-lemma arith assign-bounds 1 1 1 1 1 2) (or $x363 (not $x936) (not $x619) $x438 (not $x611) (not $x933) $x413))))
(let ((@x1006 (unit-resolution @x623 (unit-resolution @x1004 @x844 @x799 @x853 @x763 @x1001 @x1000 $x363) $x620)))
(let ((@x764 (hypothesis $x657)))
(let ((@x1008 ((_ th-lemma arith farkas 1 1 1 2 1 1 1 1 1 1 1 1 1 2 1) @x835 @x1001 @x853 @x844 @x731 @x730 @x720 @x716 @x715 @x764 @x687 @x941 @x869 @x763 (unit-resolution @x865 @x1006 $x840) false)))
(let ((@x1015 (unit-resolution (lemma @x1008 (or $x413 (not $x936) $x733 $x734 $x766 (not $x681) $x438)) @x1014 @x731 @x716 (unit-resolution ((_ th-lemma arith farkas 1 1) (or $x658 $x657)) @x711 $x657) @x994 @x763 $x413)))
(let ((@x1018 (unit-resolution @x960 (unit-resolution @x794 (unit-resolution @x607 @x1015 $x604) $x775) @x853 @x763 @x1014 @x799 $x363)))
(let ((@x1021 ((_ 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) @x832 @x966 (unit-resolution @x865 (unit-resolution @x623 @x1018 $x620) $x840) @x835 @x1014 @x853 @x731 @x730 @x720 @x716 @x715 @x711 @x994 @x972 false)))
(let ((@x1025 (unit-resolution (lemma @x1021 (or $x438 $x733 $x734 $x658)) @x716 @x731 @x711 $x438)))
(let ((@x1035 (unit-resolution @x884 (unit-resolution @x693 (unit-resolution @x599 @x1025 $x596) $x678) @x731 @x716 @x711 @x994 $x872)))
(let ((@x1037 (unit-resolution @x617 (unit-resolution @x893 @x1035 $x847) $x388)))
(let (($x1024 (>= ?x931 0)))
(let ((@x1040 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x605) $x1024)) (unit-resolution (def-axiom (or $x413 $x605)) @x844 $x605) $x1024)))
(let ((@x1043 (unit-resolution @x865 (unit-resolution @x623 (unit-resolution @x1032 @x844 @x1037 $x363) $x620) $x840)))
(let ((@x1046 ((_ th-lemma arith farkas -1 1 -1 1 1 -1 1 1 -1 -1 -1 1 -1 1 1) (unit-resolution @x950 (unit-resolution @x615 @x1037 $x612) $x936) @x853 @x1043 @x835 @x731 @x730 @x720 @x716 @x715 @x711 @x994 @x1040 @x812 @x972 @x1037 false)))
(let ((@x1051 (unit-resolution (lemma @x1046 (or $x413 $x733 $x734 $x658)) @x716 @x731 @x711 $x413)))
(let ((@x897 (unit-resolution @x725 (unit-resolution @x591 (hypothesis $x463) $x588) $x681)))
(let ((@x901 ((_ 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) @x832 @x900 (hypothesis $x776) @x812 (hypothesis $x779) @x835 @x897 @x731 @x730 @x720 @x716 @x715 @x711 @x698 @x699 (hypothesis $x463) false)))
(let ((@x1054 (unit-resolution (lemma @x901 (or $x902 $x903 $x817 $x733 $x734 $x658 $x706 $x464)) (unit-resolution @x791 (unit-resolution @x607 @x1051 $x604) $x776) @x972 @x731 @x716 @x711 (unit-resolution @x828 (unit-resolution @x599 @x1025 $x596) $x669) (unit-resolution @x808 (unit-resolution @x615 @x1037 $x612) $x673) $x902)))
(let ((@x1057 (unit-resolution @x623 (unit-resolution @x625 (unit-resolution @x909 @x1054 $x823) $x363) $x620)))
(let ((@x1059 ((_ 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 @x791 (unit-resolution @x607 @x1051 $x604) $x776) @x812 (unit-resolution @x828 (unit-resolution @x599 @x1025 $x596) $x669) @x832 (unit-resolution @x625 (unit-resolution @x909 @x1054 $x823) $x363) (unit-resolution @x808 (unit-resolution @x615 @x1037 $x612) $x673) @x698 (unit-resolution @x865 @x1057 $x840) @x835 @x731 @x730 @x720 @x716 @x715 @x711 @x994 @x972 false)))
(let ((@x1167 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x1164 $x664)) (hypothesis $x644) (hypothesis $x734) false)))
(let ((@x1168 (lemma @x1167 (or $x1164 $x664))))
(let ((@x1170 (unit-resolution @x1168 (unit-resolution (lemma @x1059 (or $x734 $x733 $x658)) @x711 @x1147 $x734) $x1164)))
(let ((@x647 (def-axiom (or $x314 $x644))))
(let ((@x1171 (unit-resolution @x647 @x1170 $x314)))
(let ((@x1193 ((_ th-lemma arith assign-bounds 1 1 1 1) (or $x338 $x313 (not $x660) (not $x643) $x289))))
(let ((@x1218 (unit-resolution @x631 (unit-resolution @x1193 @x1171 @x1138 @x1078 @x1152 $x338) $x628)))
(let ((@x1129 ((_ th-lemma arith triangle-eq) (or (not $x628) $x663))))
(let ((@x1219 (unit-resolution @x1129 @x1218 $x663)))
(let (($x784 (not $x678)))
(let (($x745 (not $x675)))
(let ((@x845 (hypothesis $x389)))
(let ((@x803 ((_ th-lemma arith assign-bounds 1 1 1 1 1) (or $x388 (not $x775) (not $x603) $x463 $x784 (not $x611)))))
(let ((@x1070 (unit-resolution @x803 @x845 @x799 (unit-resolution ((_ th-lemma arith assign-bounds 1 2) (or $x775 (not $x933) $x413)) @x1000 @x844 $x775) @x688 @x687 $x784)))
(let ((@x1073 (unit-resolution ((_ th-lemma arith assign-bounds 1 1 1 1) (or $x438 (not $x933) $x413 (not $x611) $x388)) @x845 @x799 @x844 @x1000 $x438)))
(let ((@x1077 (lemma (unit-resolution @x693 (unit-resolution @x599 @x1073 $x596) @x1070 false) (or $x388 $x463 $x413))))
(let ((@x1083 (unit-resolution ((_ th-lemma arith assign-bounds -1 1 -1 1 -1) (or $x745 (not $x603) $x463 (not $x1024) (not $x610) $x389)) (unit-resolution @x1077 @x688 @x844 $x388) @x812 @x687 @x688 @x1040 $x745)))
(let ((@x1085 (unit-resolution @x808 (unit-resolution @x615 (unit-resolution @x1077 @x688 @x844 $x388) $x612) $x673)))
(let ((@x1090 (unit-resolution @x950 (unit-resolution @x615 (unit-resolution @x1077 @x688 @x844 $x388) $x612) $x936)))
(let ((@x683 (hypothesis $x670)))
(let ((@x694 (unit-resolution @x693 (unit-resolution @x599 (hypothesis $x438) $x596) $x678)))
(let ((@x689 (hypothesis $x438)))
(let ((@x704 (hypothesis $x338)))
(let ((@x709 (lemma ((_ th-lemma arith farkas 1 -1 1 -1 1 -1 -1 1 1) @x704 @x703 @x699 @x698 @x689 @x694 @x688 @x687 @x683 false) (or $x463 (not $x338) $x706 $x439 $x707))))
(let ((@x1096 (unit-resolution @x709 (unit-resolution @x1094 @x1090 @x835 @x844 @x853 @x1089 $x338) @x1088 @x688 @x1085 $x439)))
(let ((@x1098 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x597) $x675)) (unit-resolution @x601 @x1096 $x597) @x1083 false)))
(let ((@x1132 (unit-resolution @x591 (unit-resolution (lemma @x1098 (or $x463 $x413)) @x844 $x463) $x588)))
(let ((@x1133 (unit-resolution @x725 @x1132 $x681)))
(let (($x1105 (>= ?x1103 0)))
(let ((@x1160 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x1121 $x1105)) (hypothesis $x645) (hypothesis (not $x1105)) false)))
(let ((@x1161 (lemma @x1160 (or $x1121 $x1105))))
(let ((@x1173 (unit-resolution @x1161 (unit-resolution (def-axiom (or $x313 $x645)) @x1171 $x645) $x1105)))
(let ((@x850 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x847 $x780)) (unit-resolution @x617 @x845 $x613) $x780)))
(let ((@x1112 (unit-resolution ((_ th-lemma arith farkas 1 1) (or $x936 $x673)) (unit-resolution ((_ th-lemma arith assign-bounds 1 2) (or $x706 (not $x780) $x388)) @x850 @x845 $x706) $x936)))
(let ((@x1114 (unit-resolution @x631 (unit-resolution @x1094 @x1112 @x835 @x853 @x844 @x1089 $x338) $x628)))
(let ((@x859 ((_ th-lemma arith farkas 1 1 1 1 1 1 1 1 1) @x858 @x857 @x853 @x845 @x731 @x730 @x850 @x844 (hypothesis $x313) false)))
(let ((@x1119 (unit-resolution (lemma @x859 (or $x413 $x860 $x388 $x733 $x314)) (unit-resolution @x1117 @x1114 $x667) @x844 @x731 @x845 $x314)))
(let ((@x649 (def-axiom (or $x313 $x645))))
(let ((@x1124 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x1121 $x1105)) (unit-resolution @x649 @x1119 $x645) $x1105)))
(let (($x635 (>= ?x357 0)))
(let ((@x1127 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x358) $x635)) @x561 $x635)))
(let ((@x1135 (unit-resolution @x893 (unit-resolution @x617 @x845 $x613) $x839)))
(let ((@x1139 (hypothesis $x660)))
(let ((@x1140 ((_ th-lemma arith farkas 1 -1 1 -1 -1 1 -1 -1 1 -1 1 -1 -2 2 1) @x835 @x1139 @x1138 @x1089 @x698 @x1135 @x715 @x711 @x720 (unit-resolution @x693 (unit-resolution @x599 @x1073 $x596) $x678) @x687 @x1133 (unit-resolution @x1129 @x1114 $x663) @x1127 @x1124 false)))
(let ((@x1174 (unit-resolution (lemma @x1140 (or $x388 (not $x660) $x658 $x413 $x733)) @x844 @x711 @x1152 @x1147 $x388)))
(let ((@x1154 ((_ 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) @x703 @x683 @x699 @x698 (hypothesis $x1105) @x1152 @x1138 @x715 @x711 @x720 @x868 @x687 @x869 @x1078 false)))
(let ((@x1177 (unit-resolution (lemma @x1154 (or (not $x1105) $x707 $x706 $x658 $x784 (not $x681) $x289)) (unit-resolution @x808 (unit-resolution @x615 @x1174 $x612) $x673) @x1173 @x711 @x1133 @x1088 @x1078 $x784)))
(let ((@x1179 (unit-resolution @x1094 @x1089 @x835 @x844 (unit-resolution @x950 (unit-resolution @x615 @x1174 $x612) $x936) @x853 $x338)))
(let ((@x1182 (unit-resolution @x1104 (unit-resolution @x1117 (unit-resolution @x631 @x1179 $x628) $x667) @x844 @x1078 $x438)))
(let ((@x1186 (lemma (unit-resolution @x693 (unit-resolution @x599 @x1182 $x596) @x1177 false) (or $x413 $x289 $x658))))
(let ((@x1222 (unit-resolution @x791 (unit-resolution @x607 (unit-resolution @x1186 @x711 @x1078 $x413) $x604) $x776)))
(let ((@x1189 (unit-resolution @x794 (unit-resolution @x607 (hypothesis $x413) $x604) $x775)))
(let ((@x1195 (unit-resolution @x631 (unit-resolution @x1193 (hypothesis $x314) @x1138 @x1078 @x1152 $x338) $x628)))
(let ((@x1190 (hypothesis $x314)))
(let ((@x1201 ((_ th-lemma arith assign-bounds 1 1 1 1 1) (or $x363 $x313 (not $x663) (not $x635) (not $x660) (not $x643)))))
(let ((@x1202 (unit-resolution @x1201 (unit-resolution @x1129 @x1195 $x663) @x1138 @x1190 @x1152 @x1127 $x363)))
(let ((@x1187 (hypothesis $x413)))
(let ((@x1205 ((_ th-lemma arith farkas -1 1 -1 -1 -1 1 1 -1 1) @x1187 @x703 (unit-resolution @x926 (unit-resolution @x623 @x1202 $x620) $x670) @x1078 (unit-resolution @x1117 @x1195 $x667) @x857 @x763 @x799 @x1189 false)))
(let ((@x1207 (lemma @x1205 (or $x438 $x414 $x289 $x313))))
(let ((@x1223 (unit-resolution @x1207 (unit-resolution @x1186 @x711 @x1078 $x413) @x1078 @x1171 $x438)))
(let (($x818 (not $x610)))
(let (($x1199 (not $x635)))
(let (($x1198 (not $x663)))
(let (($x1191 (not $x643)))
(let (($x1141 (not $x660)))
(let (($x743 (not $x618)))
(let ((@x1226 (unit-resolution ((_ th-lemma arith assign-bounds -1 -1 -1 1 1 -1 1 1 -1) (or $x706 $x743 $x313 $x1141 $x1191 $x817 $x1198 $x1199 $x439 $x818)) @x1171 @x698 @x1127 @x1138 @x812 @x1152 @x1223 @x1222 @x1219 $x706)))
(let ((@x1227 (unit-resolution @x794 (unit-resolution @x607 (unit-resolution @x1186 @x711 @x1078 $x413) $x604) $x775)))
(let ((@x1231 (unit-resolution @x623 (unit-resolution @x1201 @x1219 @x1138 @x1171 @x1152 @x1127 $x363) $x620)))
(let ((@x1208 (hypothesis $x840)))
(let ((@x1211 (unit-resolution @x591 (unit-resolution @x803 @x845 @x799 (hypothesis $x775) @x868 @x687 $x463) $x588)))
(let ((@x1213 (hypothesis $x663)))
(let ((@x1214 ((_ th-lemma arith farkas -1 -2 2 -1 1 1 -1 -1 1 -1 1 -1 -1 1 1) @x698 @x1213 @x1127 @x1139 @x1138 (hypothesis $x1105) @x715 @x711 @x720 (unit-resolution @x725 @x1211 $x681) @x835 @x1208 @x868 @x687 @x1135 false)))
(let ((@x1216 (lemma @x1214 (or $x388 $x1198 $x1141 (not $x1105) $x658 (not $x840) $x784 (not $x775)))))
(let ((@x1233 (unit-resolution @x1216 @x1219 @x1152 @x1173 @x711 (unit-resolution @x865 @x1231 $x840) (unit-resolution @x693 (unit-resolution @x599 @x1223 $x596) $x678) @x1227 $x388)))
(let ((@x1237 (lemma (unit-resolution @x808 (unit-resolution @x615 @x1233 $x612) @x1226 false) (or $x658 $x289))))
(let (($x582 (not $x91)))
(let ((@x1267 (unit-resolution @x631 (unit-resolution @x1094 @x1112 @x835 @x844 @x1089 @x853 $x338) $x628)))
(let (($x672 (>= ?x680 0)))
(let ((@x1270 ((_ th-lemma arith triangle-eq) (or (not $x588) $x672))))
(let ((@x1271 (unit-resolution @x1270 @x1132 $x672)))
(let ((@x1272 (unit-resolution (lemma @x859 (or $x413 $x860 $x388 $x733 $x314)) (unit-resolution @x1117 @x1267 $x667) @x844 @x731 @x845 $x314)))
(let ((@x1276 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x1121 $x1249)) (unit-resolution @x649 @x1272 $x645) $x1249)))
(let ((@x1250 (hypothesis $x780)))
(let ((@x1251 (hypothesis $x672)))
(let (($x594 (<= ?x482 0)))
(let ((@x1254 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x483) $x594)) @x556 $x594)))
(let ((@x1255 (hypothesis $x766)))
(let (($x651 (>= ?x332 0)))
(let ((@x1258 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x333) $x651)) @x563 $x651)))
(let ((@x1260 ((_ 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) @x683 @x857 @x703 (hypothesis $x1249) @x1258 @x1255 @x1254 @x1251 @x832 @x731 @x730 @x900 @x1250 @x853 @x858 false)))
(let ((@x1264 (lemma @x1260 (or $x657 $x707 $x1261 (not $x672) $x733 $x903 (not $x780) $x860))))
(let ((@x1277 (unit-resolution @x1264 @x1276 @x1088 @x1271 @x731 @x900 @x850 (unit-resolution @x1117 @x1267 $x667) $x657)))
(let ((@x1279 ((_ th-lemma arith triangle-eq) (or $x92 $x766 $x710))))
(let (($x570 (or $x582 $x583)))
(let ((@x578 (monotonicity (rewrite (= $x93 (not $x570))) (= (not $x93) (not (not $x570))))))
(let ((@x568 (trans @x578 (rewrite (= (not (not $x570)) $x570)) (= (not $x93) $x570))))
(let ((@x569 (mp (not-or-elim (mp (asserted $x95) @x552 $x548) (not $x93)) @x568 $x570)))
(let ((@x1281 (unit-resolution @x569 (unit-resolution @x1279 @x1277 (hypothesis $x658) $x92) $x582)))
(let (($x654 (>= ?x652 0)))
(let (($x587 (>= ?x507 0)))
(let ((@x555 (and-elim @x554 $x508)))
(let ((@x1286 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x508) $x587)) @x555 $x587)))
(let ((?x1144 (+ x2$ ?x506)))
(let (($x1238 (<= ?x1144 0)))
(let (($x584 (= x2$ ?x495)))
(let ((@x1288 ((_ th-lemma arith assign-bounds 1 1 1 1 1) (or $x488 (not $x595) $x413 $x784 (not $x603) (not $x681)))))
(let ((@x573 (def-axiom (or (not $x488) $x584))))
(let ((@x1290 (unit-resolution @x573 (unit-resolution @x1288 @x868 @x687 @x844 @x1133 @x720 $x488) $x584)))
(let ((@x1293 ((_ th-lemma arith triangle-eq) (or (not $x584) $x1238))))
(let ((@x1295 ((_ 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 @x1293 @x1290 $x1238) @x720 @x1133 @x1286 @x1089 @x731 @x730 @x835 @x1040 @x812 @x850 @x853 (unit-resolution @x1161 (unit-resolution @x649 @x1272 $x645) $x1105) @x715 @x1277 @x687 @x868 $x654)))
(let (($x586 (<= ?x507 0)))
(let ((@x1298 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x508) $x586)) @x555 $x586)))
(let (($x1239 (>= ?x1144 0)))
(let ((@x1300 ((_ th-lemma arith triangle-eq) (or (not $x584) $x1239))))
(let ((@x1302 ((_ 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 @x1300 @x1290 $x1239) @x1254 @x1271 @x1298 @x1088 @x1139 @x1138 @x703 @x1000 @x799 @x1135 @x698 @x1276 @x1258 (hypothesis $x658) @x832 @x900 $x653)))
(let ((@x1306 ((_ th-lemma arith triangle-eq) (or $x91 (not $x653) (not $x654)))))
(let ((@x1309 (lemma (unit-resolution @x1306 @x1302 @x1295 @x1281 false) (or $x388 $x1141 $x710 $x903 $x733 $x784 $x413))))
(let ((@x1331 (unit-resolution @x1309 (unit-resolution @x828 @x1327 $x669) (unit-resolution @x1237 @x1078 $x658) @x1152 @x1147 (unit-resolution @x693 @x1327 $x678) @x844 $x388)))
(let (($x1304 (not $x654)))
(let ((@x1333 (unit-resolution @x950 (unit-resolution @x615 @x1331 $x612) $x936)))
(let ((@x1338 (unit-resolution @x631 (unit-resolution @x1094 @x1333 @x835 @x844 @x1089 @x853 $x338) $x628)))
(let ((@x1339 (unit-resolution @x1117 @x1338 $x667)))
(let ((@x1315 (unit-resolution @x631 (unit-resolution @x1094 @x1029 @x835 @x844 @x1089 @x853 $x338) $x628)))
(let ((@x1317 ((_ th-lemma arith farkas -1 -1 -1 1 -1 1 -1 1 1) @x1026 (hypothesis $x313) @x731 @x730 @x853 @x844 (unit-resolution @x1117 @x1315 $x667) @x857 @x1029 false)))
(let ((@x1340 (unit-resolution (lemma @x1317 (or $x314 $x389 $x733 $x413)) @x1331 @x1147 @x844 $x314)))
(let ((@x1311 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x1121 $x1249)) (hypothesis $x645) (hypothesis $x1261) false)))
(let ((@x1312 (lemma @x1311 (or $x1121 $x1249))))
(let ((@x1343 (unit-resolution @x1264 (unit-resolution @x1312 (unit-resolution @x649 @x1340 $x645) $x1249) @x1339 @x1271 @x1147 (unit-resolution @x828 @x1327 $x669) (unit-resolution ((_ th-lemma arith assign-bounds 2 -1) (or $x780 $x389 (not $x936))) @x1333 @x1331 $x780) @x1088 $x657)))
(let ((@x1345 (unit-resolution @x569 (unit-resolution @x1279 @x1343 (unit-resolution @x1237 @x1078 $x658) $x92) $x582)))
(let ((@x1346 (unit-resolution @x1288 (unit-resolution @x693 @x1327 $x678) @x687 @x844 @x1133 @x720 $x488)))
(let ((@x1320 (hypothesis (not $x653))))
(let ((@x1322 ((_ 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) @x683 @x703 @x858 @x857 @x699 @x1152 @x1138 @x698 (hypothesis $x1239) @x1254 @x1251 @x1298 @x1320 (hypothesis $x933) @x799 @x1078 false)))
(let ((@x1325 (lemma @x1322 (or $x653 $x707 $x860 $x706 (not $x1239) (not $x672) (not $x933) $x289))))
(let ((@x1350 (unit-resolution @x1325 @x1088 @x1339 (unit-resolution @x808 (unit-resolution @x615 @x1331 $x612) $x673) (unit-resolution @x1300 (unit-resolution @x573 @x1346 $x584) $x1239) @x1271 @x1000 @x1078 $x653)))
(let ((@x1353 ((_ 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) @x1333 @x1147 @x730 @x853 @x1339 @x857 (unit-resolution @x1293 (unit-resolution @x573 @x1346 $x584) $x1238) @x720 @x1133 @x1286 (unit-resolution @x1306 @x1350 @x1345 $x1304) @x1040 @x812 @x1331 false)))
(let ((@x641 (def-axiom (or $x288 $x637))))
(let ((@x1399 (unit-resolution @x641 (unit-resolution (lemma @x1353 (or $x413 $x289)) @x844 $x289) $x637)))
(let ((@x1405 ((_ th-lemma arith triangle-eq) (or (not $x637) $x1369))))
(let ((@x1406 (unit-resolution @x1405 @x1399 $x1369)))
(let ((@x1370 (hypothesis $x289)))
(let ((@x1373 (unit-resolution ((_ th-lemma arith assign-bounds 1 1 1 1 1) (or $x1198 (not $x840) $x1199 $x288 (not $x627) $x388)) @x845 @x1127 @x1370 @x866 @x835 $x1198)))
(let ((@x1376 (unit-resolution ((_ th-lemma arith assign-bounds 1 1 1 1) (or $x338 $x364 (not $x840) (not $x627) $x388)) @x845 @x835 @x841 @x866 $x338)))
(let ((@x1380 (lemma (unit-resolution @x1129 (unit-resolution @x631 @x1376 $x628) @x1373 false) (or $x388 $x364 $x288))))
(let ((@x1390 (unit-resolution @x1380 (unit-resolution (lemma @x1064 (or $x363 $x413)) @x844 $x363) (unit-resolution (lemma @x1353 (or $x413 $x289)) @x844 $x289) $x388)))
(let ((@x1392 (unit-resolution @x950 (unit-resolution @x615 @x1390 $x612) $x936)))
(let ((@x1395 (unit-resolution (unit-resolution @x1094 @x835 @x853 (or $x338 (not $x840) (not $x936) $x413)) @x1392 @x844 @x1089 $x338)))
(let ((@x1397 (unit-resolution @x1117 (unit-resolution @x631 @x1395 $x628) $x667)))
(let ((@x1398 (unit-resolution @x808 (unit-resolution @x615 @x1390 $x612) $x673)))
(let (($x1360 (<= ?x1356 0)))
(let ((@x1402 ((_ th-lemma arith triangle-eq) (or (not $x637) $x1360))))
(let ((@x1403 (unit-resolution @x1402 @x1399 $x1360)))
(let ((@x1407 (unit-resolution @x1129 (unit-resolution @x631 @x1395 $x628) $x663)))
(let ((@x1411 (unit-resolution ((_ th-lemma arith assign-bounds 1 1 1 1 1 2) (or $x488 (not $x595) $x413 (not $x603) $x745 (not $x681) $x438)) @x687 @x720 (or $x488 $x413 $x745 (not $x681) $x438))))
(let ((@x1413 (unit-resolution @x573 (unit-resolution @x1411 @x941 @x1133 @x844 @x763 $x488) $x584)))
(let (($x958 (not $x619)))
(let (($x957 (not $x936)))
(let (($x1091 (not $x627)))
(let (($x1092 (not $x840)))
(let (($x814 (not $x642)))
(let (($x1386 (not $x1369)))
(let (($x1080 (not $x1024)))
(let (($x871 (not $x681)))
(let (($x1416 (not $x587)))
(let (($x815 (not $x595)))
(let (($x1415 (not $x1238)))
(let (($x1417 (or $x654 $x1415 $x815 $x1416 $x871 $x1080 $x818 $x1386 $x814 $x1092 $x1091 $x957 $x958 $x1198 $x1199)))
(let ((@x1419 (unit-resolution ((_ th-lemma arith assign-bounds 1 -1 -1 1 -1 1 -1 1 2 -2 1 -1 1 -1) $x1417) (unit-resolution @x1293 @x1413 $x1238) @x812 @x853 @x835 @x1127 @x730 @x1286 @x1133 @x1392 @x1089 @x1040 @x1407 @x1406 @x720 $x654)))
(let (($x1424 (not $x634)))
(let (($x742 (not $x626)))
(let (($x1423 (not $x1360)))
(let (($x801 (not $x611)))
(let (($x1002 (not $x933)))
(let (($x1262 (not $x672)))
(let (($x1422 (not $x586)))
(let (($x1421 (not $x594)))
(let (($x1323 (not $x1239)))
(let (($x1425 (or $x653 $x1323 $x1421 $x1422 $x1262 $x1002 $x801 $x1423 $x1191 $x707 $x742 $x706 $x743 $x860 $x1424)))
(let ((@x1426 ((_ th-lemma arith assign-bounds 1 -1 -1 1 -1 1 -1 1 2 -2 1 -1 1 -1) $x1425)))
(let ((@x1427 (unit-resolution @x1426 (unit-resolution @x1300 @x1413 $x1239) @x799 @x698 @x703 @x857 @x1138 @x1298 @x1398 @x1088 @x1397 @x1271 @x1000 @x1254 @x1403 $x653)))
(let ((@x1431 ((_ th-lemma arith assign-bounds 1 1 2 2 1 1 1 1 1 1 1) (or $x313 $x1423 $x1191 $x707 $x742 $x706 $x743 $x1002 $x801 $x438 $x860 $x1424))))
(let ((@x1432 (unit-resolution @x1431 @x763 @x698 @x703 @x857 @x1138 @x799 @x1398 @x1088 @x1397 @x1000 @x1403 $x313)))
(let ((@x1382 (hypothesis $x675)))
(let ((@x1385 ((_ th-lemma arith farkas -1 1 1 -1 1 -1 -2 2 -1 1 3 -3 1 -1 2 -2 1) @x716 @x715 @x711 @x720 @x869 @x687 (hypothesis $x1024) @x812 (hypothesis $x1369) @x730 @x1208 @x835 @x1001 @x853 @x1213 @x1127 @x1382 false)))
(let ((@x1435 (unit-resolution (lemma @x1385 (or $x658 $x734 $x871 $x1080 $x1386 $x1092 $x957 $x1198 $x745)) (unit-resolution @x1168 (unit-resolution @x647 @x1432 $x644) $x664) @x1133 @x1040 @x1406 @x1089 @x1392 @x1407 @x941 $x658)))
(let ((@x1436 (unit-resolution @x1279 @x1435 (unit-resolution @x569 (unit-resolution @x1306 @x1427 @x1419 $x91) $x583) $x766)))
(let ((@x1438 ((_ th-lemma arith triangle-eq) (or $x1164 $x1381))))
(let ((@x1440 ((_ th-lemma arith farkas -1 1 1 -1 1 -1 -2 2 -1 1 3 -3 1 -1 2 -2 1) (unit-resolution @x1438 (unit-resolution @x647 @x1432 $x644) $x1381) @x1258 @x1436 @x1254 @x1271 @x832 @x1000 @x799 @x1403 @x1138 @x1088 @x703 @x1398 @x698 @x1397 @x857 @x966 false)))
(let ((@x1453 (unit-resolution @x599 (unit-resolution (lemma @x1440 (or $x438 $x413)) @x844 $x438) $x596)))
(let ((@x1455 (unit-resolution @x693 @x1453 $x678)))
(let ((@x1458 (unit-resolution (unit-resolution @x1288 @x687 @x720 (or $x488 $x413 $x784 $x871)) @x1455 @x844 @x1133 $x488)))
(let ((@x1461 (unit-resolution ((_ th-lemma arith assign-bounds 1 -1 -1 1 -1 1 -1 1 2 -2 1 -1 1 -1) $x1417) (unit-resolution @x1293 (unit-resolution @x573 @x1458 $x584) $x1238) @x812 @x853 @x835 @x1127 @x730 @x720 @x1133 @x1392 @x1089 @x1040 @x1407 @x1406 @x1286 $x654)))
(let ((@x1463 (unit-resolution @x1426 (unit-resolution @x1300 (unit-resolution @x573 @x1458 $x584) $x1239) @x799 @x698 @x703 @x857 @x1138 @x1254 @x1398 @x1088 @x1397 @x1271 @x1000 @x1298 @x1403 $x653)))
(let ((@x1468 (unit-resolution ((_ th-lemma arith assign-bounds 2 -1) (or $x675 $x439 $x784)) @x1455 (unit-resolution (lemma @x1440 (or $x438 $x413)) @x844 $x438) $x675)))
(let ((@x1443 (unit-resolution (lemma @x1385 (or $x658 $x734 $x871 $x1080 $x1386 $x1092 $x957 $x1198 $x745)) @x711 @x869 (hypothesis $x1024) (hypothesis $x1369) @x1208 @x1001 @x1213 @x1382 $x734)))
(let ((@x1446 (unit-resolution @x649 (unit-resolution @x647 (unit-resolution @x1168 @x1443 $x1164) $x314) $x645)))
(let ((@x1449 ((_ th-lemma arith farkas -1 -1 -1 1 1 -1 1 -1 -1 1 1 -1 1) @x715 @x711 @x868 @x687 @x720 @x869 @x683 @x703 (hypothesis $x1360) @x1138 @x699 @x698 (unit-resolution @x1161 @x1446 $x1105) false)))
(let ((@x1451 (lemma @x1449 (or $x658 $x784 $x871 $x707 $x1423 $x706 $x1080 $x1386 $x1092 $x957 $x1198 $x745))))
(let ((@x1469 (unit-resolution @x1451 @x1455 @x1133 @x1088 @x1403 @x1398 @x1040 @x1406 @x1089 @x1392 @x1407 @x1468 $x658)))
(let ((@x1470 (unit-resolution @x1279 @x1469 (unit-resolution @x569 (unit-resolution @x1306 @x1463 @x1461 $x91) $x583) $x766)))
(let (($x1472 (not $x602)))
(let (($x1471 (not $x651)))
(let (($x1473 (or $x1261 $x1471 $x657 $x903 $x1472 $x1421 $x1262 $x1092 $x1091 $x1386 $x814 $x957 $x958)))
(let ((@x1475 (unit-resolution ((_ th-lemma arith assign-bounds -1 -1 -1 1 1 -1 1 -1 -1 1 1 -1) $x1473) @x1470 @x853 @x835 @x730 @x1258 @x832 (unit-resolution @x828 @x1453 $x669) @x1271 @x1392 @x1089 @x1254 @x1406 $x1261)))
(let ((@x1478 (unit-resolution @x647 (unit-resolution @x649 (unit-resolution @x1312 @x1475 $x1121) $x313) $x644)))
(let ((@x1480 ((_ th-lemma arith farkas -1 -1 -2 -1 1 1 -1 1 -1 -1 1 1 -1 1) @x1258 @x1470 (unit-resolution @x649 (unit-resolution @x1312 @x1475 $x1121) $x313) (unit-resolution @x828 @x1453 $x669) @x832 @x1254 @x1271 @x1089 @x835 @x1406 @x730 @x1392 @x853 (unit-resolution @x1438 @x1478 $x1381) false)))
(let ((@x1481 (lemma @x1480 $x413)))
(let ((@x1538 (unit-resolution @x791 (unit-resolution @x607 @x1481 $x604) $x776)))
(let ((?x666 (+ ?x201 ?x356)))
(let (($x1699 (>= ?x666 0)))
(let (($x629 (= ?x201 ?x345)))
(let (($x339 (not $x338)))
(let ((@x1701 (hypothesis $x339)))
(let ((@x633 (def-axiom (or $x338 $x629))))
(let ((@x1712 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x629) $x1699)) (unit-resolution @x633 @x1701 $x629) $x1699)))
(let (($x875 (<= ?x666 0)))
(let ((@x1635 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x629) $x875)) (hypothesis $x629) (hypothesis (not $x875)) false)))
(let ((@x1636 (lemma @x1635 (or (not $x629) $x875))))
(let ((@x1703 (unit-resolution @x1636 (unit-resolution @x633 @x1701 $x629) $x875)))
(let (($x1632 (not $x629)))
(let (($x1629 (not $x875)))
(let ((@x1517 (unit-resolution @x794 (unit-resolution @x607 @x1481 $x604) $x775)))
(let ((@x1359 (lemma ((_ th-lemma arith farkas 1 1 1 1 1) @x1187 @x799 @x763 @x845 @x1189 false) (or $x438 $x414 $x388))))
(let ((@x1520 (unit-resolution @x693 (unit-resolution @x599 (unit-resolution @x1359 @x845 @x1481 $x438) $x596) $x678)))
(let ((@x1523 (unit-resolution (unit-resolution @x803 @x799 @x687 (or $x388 (not $x775) $x463 $x784)) @x1520 @x1517 @x845 $x463)))
(let ((@x1525 (unit-resolution @x1270 (unit-resolution @x591 @x1523 $x588) $x672)))
(let ((@x1526 (unit-resolution @x828 (unit-resolution @x599 (unit-resolution @x1359 @x845 @x1481 $x438) $x596) $x669)))
(let ((@x1365 (unit-resolution ((_ th-lemma arith assign-bounds 2 -1) (or $x779 $x364 $x1092)) (unit-resolution @x625 (unit-resolution @x909 @x906 $x823) $x363) @x906 $x1092)))
(let ((@x1366 (unit-resolution @x623 (unit-resolution @x625 (unit-resolution @x909 @x906 $x823) $x363) $x620)))
(let ((@x1368 (lemma (unit-resolution @x865 @x1366 @x1365 false) $x779)))
(let ((@x1486 (unit-resolution ((_ th-lemma arith assign-bounds -1 1 -1 1 -1) (or $x902 $x1091 $x338 $x872 $x743 $x414)) @x835 @x1368 @x698 (or $x338 $x872 $x414))))
(let ((@x1489 (unit-resolution @x1129 (unit-resolution @x631 (unit-resolution @x1486 @x1135 @x1481 $x338) $x628) $x663)))
(let ((@x1491 ((_ th-lemma arith assign-bounds 1 2 2 2 2 2) (or $x872 $x957 $x1198 $x1092 $x1199 $x288 $x1091))))
(let ((@x1495 (unit-resolution ((_ th-lemma arith farkas 1 1) (or $x840 $x670)) (unit-resolution @x1491 @x1370 @x1127 @x835 @x1135 @x1112 @x1489 $x1092) $x670)))
(let ((@x1500 (unit-resolution (unit-resolution ((_ th-lemma arith assign-bounds 2 1) (or $x707 $x363 $x902)) @x1368 (or $x707 $x363)) @x1495 (unit-resolution @x1380 @x1370 @x845 $x364) false)))
(let ((@x1509 (unit-resolution @x639 (unit-resolution (lemma @x1500 (or $x288 $x388)) @x845 $x288) $x636)))
(let ((@x1510 (unit-resolution @x1151 @x1509 $x660)))
(let ((@x1508 (unit-resolution @x1237 (unit-resolution (lemma @x1500 (or $x288 $x388)) @x845 $x288) $x658)))
(let (($x585 (= ?x98 ?x495)))
(let (($x1546 (not $x585)))
(let ((?x1504 (+ ?x98 ?x506)))
(let (($x1506 (>= ?x1504 0)))
(let (($x1558 (not $x1506)))
(let ((@x1572 (unit-resolution @x1129 (unit-resolution @x631 (unit-resolution @x1486 @x867 @x1481 $x338) $x628) $x663)))
(let (($x800 (not $x775)))
(let (($x744 (not $x603)))
(let (($x1559 (or $x653 $x1558 $x784 $x744 $x815 $x871 $x1422 $x800 $x801 $x1141 $x1191 $x743 $x1198 $x1199 $x872)))
(let ((@x1573 (unit-resolution ((_ th-lemma arith assign-bounds 1 -2 2 1 -1 -1 -1 1 -1 1 -1 -1 1 1) $x1559) @x1320 @x687 @x799 @x698 @x1127 @x1138 @x720 @x1139 @x868 @x1517 @x869 @x867 @x1572 @x1298 $x1558)))
(let ((@x1568 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x1546 $x1506)) (hypothesis $x585) (hypothesis $x1558) false)))
(let ((@x1569 (lemma @x1568 (or $x1546 $x1506))))
(let ((@x575 (def-axiom (or $x488 $x585))))
(let ((@x1576 (unit-resolution @x573 (unit-resolution @x575 (unit-resolution @x1569 @x1573 $x1546) $x488) $x584)))
(let ((@x1578 ((_ 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) @x698 @x867 @x1139 @x1138 @x1572 @x1127 (unit-resolution @x1300 @x1576 $x1239) @x1298 @x1320 @x1517 @x799 @x1254 @x1251 @x1481 false)))
(let ((@x1580 (lemma @x1578 (or $x653 $x872 $x1141 $x1262 $x784 $x871))))
(let ((@x1593 (unit-resolution @x1580 @x1135 @x1510 @x1525 @x1520 (unit-resolution @x725 (unit-resolution @x591 @x1523 $x588) $x681) $x653)))
(let ((@x1537 (unit-resolution @x1117 (unit-resolution @x631 (unit-resolution @x1486 @x1135 @x1481 $x338) $x628) $x667)))
(let ((@x1539 (unit-resolution @x1146 @x1509 $x661)))
(let (($x1505 (<= ?x1504 0)))
(let (($x1550 (not $x1505)))
(let (($x1106 (not $x780)))
(let (($x1551 (or $x654 $x1550 $x903 $x1472 $x1421 $x1262 $x1416 $x817 $x818 $x733 $x814 $x958 $x860 $x1424 $x1106)))
(let ((@x1585 (unit-resolution ((_ th-lemma arith assign-bounds 1 -2 2 1 -1 -1 -1 1 -1 1 -1 -1 1 1) $x1551) (hypothesis $x1304) @x832 @x812 @x853 @x857 @x730 @x1254 @x731 @x1538 @x858 @x1250 @x900 @x1251 @x1286 $x1550)))
(let ((@x1582 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x1546 $x1505)) (hypothesis $x585) (hypothesis $x1550) false)))
(let ((@x1583 (lemma @x1582 (or $x1546 $x1505))))
(let ((@x1588 (unit-resolution @x573 (unit-resolution @x575 (unit-resolution @x1583 @x1585 $x1546) $x488) $x584)))
(let ((@x1590 ((_ 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) @x853 @x1250 @x900 @x832 @x1254 @x1251 @x731 @x730 @x858 @x857 (unit-resolution @x1293 @x1588 $x1238) @x1286 (hypothesis $x1304) @x1538 @x812 (unit-resolution @x575 (unit-resolution @x1583 @x1585 $x1546) $x488) false)))
(let ((@x1592 (lemma @x1590 (or $x654 $x1106 $x903 $x1262 $x733 $x860))))
(let ((@x1595 (unit-resolution @x1306 (unit-resolution @x1592 @x850 @x1526 @x1525 @x1539 @x1537 $x654) @x1593 $x91)))
(let ((@x1513 (unit-resolution (unit-resolution @x1201 @x1138 @x1127 (or $x363 $x313 $x1198 $x1141)) @x1027 @x1489 @x1510 $x313)))
(let (($x1503 (>= ?x778 0)))
(let ((@x1530 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x823 $x1503)) (unit-resolution @x625 @x1027 $x621) $x1503)))
(let (($x1532 (not $x1381)))
(let (($x1531 (not $x1503)))
(let (($x1533 (or $x657 $x1531 $x1532 $x1471 $x742 $x903 $x1472 $x1421 $x1262 $x1141 $x1191 $x958 $x1106)))
(let ((@x1534 ((_ th-lemma arith assign-bounds 1 -1 1 -1 1 -1 -1 1 -1 1 1 -1) $x1533)))
(let ((@x1535 (unit-resolution @x1534 @x1530 @x853 @x703 @x1138 @x1258 @x1254 @x1510 @x850 @x1526 @x1525 @x832 (unit-resolution @x1438 (unit-resolution @x647 @x1513 $x644) $x1381) $x657)))
(let (($x489 (not $x488)))
(let ((@x1543 (unit-resolution ((_ th-lemma arith assign-bounds 1 1 1 1 1 1 1 1) (or $x489 $x1262 $x1421 $x1472 $x903 $x363 $x958 $x388 $x1106)) @x832 @x853 @x1254 (or $x489 $x1262 $x903 $x363 $x388 $x1106))))
(let ((@x1545 (unit-resolution @x575 (unit-resolution @x1543 @x1027 @x845 @x850 @x1526 @x1525 $x489) $x585)))
(let ((@x1553 (unit-resolution ((_ th-lemma arith assign-bounds 1 -2 2 1 -1 -1 -1 1 -1 1 -1 -1 1 1) $x1551) (unit-resolution ((_ th-lemma arith triangle-eq) (or $x1546 $x1505)) @x1545 $x1505) @x832 @x812 @x853 @x857 @x730 @x1286 @x1539 @x1538 @x1537 @x850 @x1526 @x1525 @x1254 $x654)))
(let ((@x1561 (unit-resolution ((_ th-lemma arith assign-bounds 1 -2 2 1 -1 -1 -1 1 -1 1 -1 -1 1 1) $x1559) (unit-resolution ((_ th-lemma arith triangle-eq) (or $x1546 $x1506)) @x1545 $x1506) @x687 @x799 @x698 @x1127 @x1138 @x1298 @x1510 @x1520 @x1517 (unit-resolution @x725 (unit-resolution @x591 @x1523 $x588) $x681) @x1135 @x1489 @x720 $x653)))
(let ((@x1563 (unit-resolution @x569 (unit-resolution @x1306 @x1561 @x1553 $x91) (unit-resolution @x1279 @x1535 @x1508 $x92) false)))
(let ((@x1599 (unit-resolution @x623 (unit-resolution (lemma @x1563 (or $x363 $x388)) @x845 $x363) $x620)))
(let ((@x1601 (unit-resolution @x1264 (unit-resolution @x1279 (unit-resolution @x569 @x1595 $x583) @x1508 $x766) @x1537 @x1525 @x1539 @x1526 @x850 (unit-resolution @x926 @x1599 $x670) $x1261)))
(let ((@x1604 (unit-resolution @x647 (unit-resolution @x649 (unit-resolution @x1312 @x1601 $x1121) $x313) $x644)))
(let ((@x1608 (unit-resolution ((_ th-lemma arith assign-bounds -2 2 -2 2 -1 -2) (or $x1503 $x733 $x814 $x860 $x1424 $x707 $x314)) (unit-resolution @x649 (unit-resolution @x1312 @x1601 $x1121) $x313) @x730 @x1539 (unit-resolution @x926 @x1599 $x670) @x1537 @x857 $x1503)))
(let ((@x1609 (unit-resolution @x1534 @x1608 (unit-resolution @x1438 @x1604 $x1381) @x853 @x703 @x1138 @x1258 (unit-resolution @x1279 (unit-resolution @x569 @x1595 $x583) @x1508 $x766) @x1510 @x850 @x1526 @x1525 @x832 @x1254 false)))
(let ((@x1610 (lemma @x1609 $x388)))
(let ((@x1637 ((_ th-lemma arith assign-bounds -1 -1 1 1 -1) (or $x1629 $x1199 $x1531 $x742 $x288 $x389))))
(let ((@x1639 (unit-resolution @x1636 (unit-resolution @x1637 @x1530 @x1127 @x1370 @x1610 @x703 $x1629) $x1632)))
(let ((@x1642 (unit-resolution @x1129 (unit-resolution @x631 (unit-resolution @x633 @x1639 $x338) $x628) $x663)))
(let ((@x1643 ((_ th-lemma arith farkas 1 1 1 1 1) @x1370 @x1642 @x1127 @x1027 (unit-resolution @x633 @x1639 $x338) false)))
(let ((@x1645 (lemma @x1643 (or $x363 $x288))))
(let ((@x889 (unit-resolution @x926 (unit-resolution @x623 (unit-resolution @x1645 @x1370 $x363) $x620) $x670)))
(let ((@x890 (unit-resolution @x865 (unit-resolution @x623 (unit-resolution @x1645 @x1370 $x363) $x620) $x840)))
(let ((@x1650 (unit-resolution @x623 (unit-resolution @x1645 (unit-resolution @x1237 @x711 $x289) $x363) $x620)))
(let ((@x1672 (unit-resolution @x950 (unit-resolution @x615 @x1610 $x612) $x936)))
(let ((@x1648 (unit-resolution @x1237 @x711 $x289)))
(let ((@x1647 (hypothesis $x875)))
(let ((@x1617 (unit-resolution @x808 (unit-resolution @x615 @x1610 $x612) $x673)))
(let ((@x1651 (unit-resolution @x926 @x1650 $x670)))
(let ((@x1656 ((_ th-lemma arith assign-bounds 1 1 1 1 1 1 1 1) (or $x313 $x1191 $x1423 $x288 $x707 $x706 $x414 $x743 $x742))))
(let ((@x1657 (unit-resolution @x1656 @x1648 @x703 @x698 @x1138 @x1481 @x1617 @x1651 (unit-resolution @x1402 (unit-resolution @x641 @x1648 $x637) $x1360) $x313)))
(let ((@x1660 ((_ th-lemma arith assign-bounds -1 1 1 -1 -1 1 -1 -1 -3 3 1 1 2 -2 -2 2) (unit-resolution @x1168 (unit-resolution @x647 @x1657 $x644) $x664) @x715 @x711 @x687 @x720 @x730 (unit-resolution @x1405 (unit-resolution @x641 @x1648 $x637) $x1369) @x1651 @x1617 @x698 @x703 @x1382 @x1647 @x1127 @x1538 @x812 $x871)))
(let ((@x1662 ((_ th-lemma arith assign-bounds 1 1 1 2 2 1 1 1 1 1 1) (or $x463 $x744 $x745 $x707 $x706 $x743 $x742 $x1629 $x1199 $x288 $x817 $x818))))
(let ((@x1663 (unit-resolution @x1662 @x1647 @x812 @x698 @x703 @x1127 @x1648 @x1617 @x1651 @x1382 @x1538 @x687 $x463)))
(let ((@x1667 (lemma (unit-resolution @x725 (unit-resolution @x591 @x1663 $x588) @x1660 false) (or $x1629 $x658 $x745))))
(let ((@x1669 (unit-resolution @x633 (unit-resolution @x1636 (unit-resolution @x1667 @x941 @x711 $x1629) $x1632) $x338)))
(let ((@x1675 (unit-resolution ((_ th-lemma arith assign-bounds 1 1 1 1 1 1 1 1) (or $x463 $x707 $x339 $x742 $x706 $x743 $x744 $x745 $x438)) @x687 @x698 @x703 (or $x463 $x707 $x339 $x706 $x745 $x438))))
(let ((@x1677 (unit-resolution @x591 (unit-resolution @x1675 @x1669 @x1651 @x941 @x1617 @x763 $x463) $x588)))
(let ((@x1681 (unit-resolution ((_ th-lemma arith assign-bounds -1 -2 -2 -2 2 2) (or $x1024 $x817 $x339 $x707 $x706 $x743 $x742)) @x1669 @x703 @x1617 @x1651 @x1538 @x698 $x1024)))
(let ((@x1682 (unit-resolution @x1451 @x1681 (unit-resolution @x725 @x1677 $x681) @x711 (unit-resolution @x1402 (unit-resolution @x641 @x1648 $x637) $x1360) @x1651 @x1617 @x941 (unit-resolution @x1405 (unit-resolution @x641 @x1648 $x637) $x1369) (unit-resolution @x865 @x1650 $x840) @x1672 (unit-resolution @x1129 (unit-resolution @x631 @x1669 $x628) $x663) @x944 false)))
(let ((@x1688 (unit-resolution ((_ th-lemma arith assign-bounds -1 -2 2 -2 -2 2) (or $x1503 $x707 $x706 $x743 $x439 $x817 $x818)) @x1651 @x698 @x1617 @x812 @x1538 (unit-resolution (lemma @x1682 (or $x438 $x658)) @x711 $x438) $x1503)))
(let ((@x1690 (unit-resolution @x1636 (unit-resolution @x1637 @x1688 @x1127 @x1648 @x1610 @x703 $x1629) $x1632)))
(let ((@x1693 (unit-resolution @x1129 (unit-resolution @x631 (unit-resolution @x633 @x1690 $x338) $x628) $x663)))
(let ((@x1696 (unit-resolution ((_ th-lemma arith assign-bounds -3 -2 -2 2 2 -2 -2 2) (or $x839 $x706 $x339 $x707 $x742 $x743 $x439 $x817 $x818)) (unit-resolution @x633 @x1690 $x338) @x698 @x703 @x812 @x1617 @x1651 @x1538 (unit-resolution (lemma @x1682 (or $x438 $x658)) @x711 $x438) $x839)))
(let ((@x1697 (unit-resolution @x1491 @x1696 @x1693 @x1127 @x835 @x1648 @x1672 (unit-resolution @x865 @x1650 $x840) false)))
(let ((@x1698 (lemma @x1697 $x658)))
(let ((@x1612 (unit-resolution @x1402 (unit-resolution @x641 @x1370 $x637) $x1360)))
(let ((@x1741 (unit-resolution (unit-resolution @x960 @x853 @x799 (or $x363 $x957 $x438 $x800)) @x763 @x1672 @x1517 $x363)))
(let ((@x1743 (unit-resolution @x926 (unit-resolution @x623 @x1741 $x620) $x670)))
(let ((@x1700 (hypothesis $x932)))
(let ((@x1704 (unit-resolution @x1662 @x1703 @x812 @x698 @x703 @x1127 @x1370 @x1617 @x683 @x1382 @x1538 @x687 $x463)))
(let ((@x1708 (unit-resolution @x647 (unit-resolution @x1656 @x1612 @x703 @x698 @x1138 @x1481 @x1617 @x683 @x1370 $x313) $x644)))
(let ((@x1709 (unit-resolution @x1438 @x1708 $x1381)))
(let ((@x1713 ((_ 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) @x1712 @x857 @x1672 @x853 @x1517 @x799 @x1709 @x1258 @x832 @x1254 (unit-resolution @x1270 (unit-resolution @x591 @x1704 $x588) $x672) @x1138 @x1612 @x1208 @x835 @x1700 $x657)))
(let ((@x1718 (unit-resolution ((_ th-lemma arith assign-bounds 2 1 1 1 1 1 1) (or $x488 $x288 $x1532 $x1471 $x710 $x1191 $x1423 $x338)) @x1701 @x1370 @x1138 @x1258 @x1698 @x1612 @x1709 $x488)))
(let (($x1723 (not $x932)))
(let (($x1724 (or $x654 $x1415 $x1416 $x1532 $x1471 $x710 $x1472 $x1723 $x1092 $x957 $x958 $x1091 $x815 $x871 $x814 $x1386)))
(let ((@x1726 (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) $x1724) (unit-resolution @x725 (unit-resolution @x591 @x1704 $x588) $x681) @x832 @x853 @x835 @x730 @x1258 @x1286 @x1698 @x720 @x1672 @x1700 @x1208 (unit-resolution @x1405 (unit-resolution @x641 @x1370 $x637) $x1369) (unit-resolution @x1293 (unit-resolution @x573 @x1718 $x584) $x1238) @x1709 $x654)))
(let (($x816 (not $x650)))
(let (($x1729 (or $x653 $x1323 $x1422 $x734 $x816 $x766 $x744 $x745 $x707 $x706 $x743 $x742 $x1421 $x1262 $x1191 $x1423)))
(let ((@x1731 (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) $x1729) @x1713 @x687 @x698 @x703 @x1138 @x715 @x1298 @x1254 (unit-resolution @x1168 @x1708 $x664) @x1617 @x683 @x1382 (unit-resolution @x1270 (unit-resolution @x591 @x1704 $x588) $x672) (unit-resolution @x1300 (unit-resolution @x573 @x1718 $x584) $x1239) @x1612 $x653)))
(let ((@x1732 (unit-resolution @x1306 @x1731 @x1726 (unit-resolution @x569 (unit-resolution @x1279 @x1713 @x1698 $x92) $x582) false)))
(let ((@x1734 (lemma @x1732 (or $x338 $x707 $x745 $x1723 $x1092 $x288))))
(let ((@x1745 (unit-resolution @x1734 @x1370 @x941 @x966 (unit-resolution @x865 (unit-resolution @x623 @x1741 $x620) $x840) @x1743 $x338)))
(let ((@x1747 (unit-resolution @x591 (unit-resolution @x1675 @x1745 @x763 @x941 @x1617 @x1743 $x463) $x588)))
(let ((@x1750 (unit-resolution @x647 (unit-resolution @x1656 @x1612 @x703 @x698 @x1138 @x1481 @x1617 @x1743 @x1370 $x313) $x644)))
(let ((@x1751 (unit-resolution @x1438 @x1750 $x1381)))
(let ((@x1735 (hypothesis $x1381)))
(let ((@x1736 ((_ 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) @x683 @x1617 @x698 @x703 @x858 @x857 @x1517 @x799 @x1735 @x1258 @x1255 @x832 @x1254 @x1251 @x1138 (hypothesis $x1360) @x1700 @x1481 false)))
(let ((@x1754 (unit-resolution (lemma @x1736 (or $x657 $x707 $x860 $x1532 $x1262 $x1423 $x1723)) (unit-resolution @x1117 (unit-resolution @x631 @x1745 $x628) $x667) @x1743 @x1751 (unit-resolution @x1270 @x1747 $x672) @x1612 @x966 $x657)))
(let ((@x1759 ((_ 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) @x1370 @x1751 @x1258 @x1698 @x1138 @x1612 (unit-resolution @x1129 (unit-resolution @x631 @x1745 $x628) $x663) @x1127 @x1617 @x698 @x1538 @x812 @x687 @x720 (unit-resolution @x725 @x1747 $x681) @x1743 @x703 @x941 $x488)))
(let ((@x1762 (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) $x1724) (unit-resolution @x1293 (unit-resolution @x573 @x1759 $x584) $x1238) @x832 @x853 @x835 @x730 @x1258 @x1286 @x1698 @x720 @x1672 @x966 (unit-resolution @x865 (unit-resolution @x623 @x1741 $x620) $x840) (unit-resolution @x1405 (unit-resolution @x641 @x1370 $x637) $x1369) (unit-resolution @x725 @x1747 $x681) @x1751 $x654)))
(let ((@x1767 (unit-resolution @x1426 (unit-resolution @x1300 (unit-resolution @x573 @x1759 $x584) $x1239) @x799 @x698 @x703 @x857 @x1138 @x1617 @x1612 @x1743 (unit-resolution @x1117 (unit-resolution @x631 @x1745 $x628) $x667) (unit-resolution @x1270 @x1747 $x672) (unit-resolution ((_ th-lemma arith assign-bounds 2 -1) (or $x933 $x414 $x800)) @x1517 @x1481 $x933) @x1254 @x1298 $x653)))
(let ((@x1768 (unit-resolution @x1306 @x1767 @x1762 (unit-resolution @x569 (unit-resolution @x1279 @x1754 @x1698 $x92) $x582) false)))
(let ((@x1770 (lemma @x1768 (or $x288 $x438))))
(let ((@x891 (unit-resolution @x1770 @x1370 $x438)))
(let ((@x783 (unit-resolution ((_ th-lemma arith assign-bounds -2 2 -2 -2 2 -1) (or $x932 $x817 $x818 $x706 $x364 $x743 $x903)) @x698 @x812 (or $x932 $x817 $x706 $x364 $x903))))
(let ((@x795 (unit-resolution (unit-resolution @x783 @x1538 @x1617 (or $x932 $x364 $x903)) (unit-resolution @x828 (unit-resolution @x599 @x891 $x596) $x669) (unit-resolution @x1645 @x1370 $x363) $x932)))
(let ((@x809 (unit-resolution (unit-resolution @x709 @x1617 (or $x463 $x339 $x439 $x707)) @x889 @x688 @x891 $x339)))
(let ((@x821 (unit-resolution ((_ th-lemma arith assign-bounds 2 -1) (or $x675 $x439 $x784)) (unit-resolution @x693 (unit-resolution @x599 @x891 $x596) $x678) @x891 $x675)))
(let ((@x836 (lemma (unit-resolution @x1734 @x821 @x809 @x1370 @x795 @x890 @x889 false) (or $x288 $x463))))
(let ((@x918 (unit-resolution @x836 @x688 $x288)))
(let ((@x722 (unit-resolution @x1151 (unit-resolution @x639 @x918 $x636) $x660)))
(let ((@x1807 (unit-resolution (unit-resolution @x1193 @x1138 (or $x338 $x313 $x1141 $x289)) @x1701 @x918 @x722 $x313)))
(let ((@x838 (unit-resolution (unit-resolution @x960 @x853 @x799 (or $x363 $x957 $x438 $x800)) @x1672 @x1517 (or $x363 $x438))))
(let ((@x910 (unit-resolution @x623 (unit-resolution @x838 @x763 $x363) $x620)))
(let ((@x920 (unit-resolution @x1146 (unit-resolution @x639 @x918 $x636) $x661)))
(let ((@x916 (unit-resolution ((_ th-lemma arith assign-bounds 1 1 1 1) (or $x488 $x463 $x813 $x815 $x438)) @x720 (or $x488 $x463 $x813 $x438))))
(let ((@x923 (unit-resolution @x1293 (unit-resolution @x573 (unit-resolution @x916 @x763 @x688 @x762 $x488) $x584) $x1238)))
(let ((@x924 ((_ th-lemma arith assign-bounds 1 -1 1 -1 1 -1 1 3 -3 1 -1 -1 2 -2 2 -2) @x923 @x1286 @x762 @x720 @x730 (hypothesis $x1699) @x857 @x1672 @x853 @x1517 @x799 @x920 @x832 @x966 (unit-resolution @x865 @x910 $x840) @x835 $x654)))
(let (($x886 (>= ?x676 0)))
(let ((@x735 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x589) $x886)) @x758 $x886)))
(let ((@x736 (unit-resolution @x1300 (unit-resolution @x573 (unit-resolution @x916 @x763 @x688 @x762 $x488) $x584) $x1239)))
(let ((@x682 ((_ th-lemma arith assign-bounds 1 -1 1 -1 1 -1 1 3 -3 1 -1 -1 2 -2 2 -2) @x736 @x1298 @x735 @x1254 @x1138 @x1647 @x1127 @x1617 @x698 @x1538 @x812 @x722 @x687 @x941 (unit-resolution @x926 @x910 $x670) @x703 $x653)))
(let (($x741 (not $x886)))
(let (($x748 (or $x657 $x741 $x1532 $x1471 $x1421 $x1191 $x706 $x743 $x744 $x745 $x707 $x742 $x1141)))
(let ((@x750 (unit-resolution ((_ th-lemma arith assign-bounds 1 -1 1 -1 1 1 -1 1 -1 1 -1 -1) $x748) (unit-resolution @x926 @x910 $x670) @x698 @x703 @x1138 @x1258 @x1254 @x722 @x1617 @x687 @x941 @x1735 @x735 $x657)))
(let ((@x755 (unit-resolution @x1279 @x1698 (or $x92 $x766))))
(let ((@x917 (unit-resolution @x569 (unit-resolution @x755 @x750 $x92) (unit-resolution @x1306 @x682 @x924 $x91) false)))
(let ((@x1810 (unit-resolution (lemma @x917 (or $x438 $x1532 $x1629 (not $x1699) $x463)) (unit-resolution @x1438 (unit-resolution @x647 @x1807 $x644) $x1381) @x1703 @x1712 @x688 $x438)))
(let ((@x1780 (hypothesis $x886)))
(let (($x1782 (or $x657 $x1531 $x741 $x1532 $x1471 $x1421 $x1191 $x957 $x958 $x744 $x742 $x1141 $x784 $x800 $x801)))
(let ((@x1784 (unit-resolution ((_ th-lemma arith assign-bounds 1 1 -1 1 -1 1 -1 1 1 -1 -1 -1 -2 2) $x1782) (hypothesis $x1503) @x799 @x853 @x703 @x1138 @x1258 @x1254 @x1139 @x868 @x1517 @x1672 @x687 @x1735 @x1780 $x657)))
(let ((@x1789 (unit-resolution ((_ th-lemma arith assign-bounds 1 1 1 1 1 1) (or $x488 $x338 $x1532 $x1471 $x710 $x1191 $x1141)) @x1701 @x1138 @x1258 @x1698 @x1139 @x1735 $x488)))
(let (($x927 (not $x1699)))
(let (($x1792 (or $x654 $x1415 $x1416 $x741 $x1421 $x1191 $x927 $x1424 $x957 $x958 $x800 $x801 $x1141 $x1532 $x1471 $x710)))
(let ((@x1794 (unit-resolution ((_ th-lemma arith assign-bounds 1 -1 -1 1 -1 -1 1 1 -1 1 -1 1 2 -2 -2) $x1792) (unit-resolution @x1293 (unit-resolution @x573 @x1789 $x584) $x1238) @x799 @x853 @x857 @x1138 @x1258 @x1286 @x1698 @x1139 @x1517 @x1672 @x1254 @x1735 @x1780 @x1712 $x654)))
(let (($x1796 (or $x653 $x1323 $x1422 $x813 $x815 $x814 $x1629 $x1199 $x706 $x743 $x817 $x818 $x733 $x734 $x816 $x766)))
(let ((@x1798 (unit-resolution ((_ th-lemma arith assign-bounds 1 -1 -1 1 -1 -1 1 1 -1 1 -1 1 2 -2 -2) $x1796) @x1784 @x812 @x698 @x1127 @x730 @x715 @x1298 @x720 @x731 @x716 @x1617 @x934 @x1538 @x1703 (unit-resolution @x1300 (unit-resolution @x573 @x1789 $x584) $x1239) $x653)))
(let ((@x1799 (unit-resolution @x1306 @x1798 @x1794 (unit-resolution @x569 (unit-resolution @x755 @x1784 $x92) $x582) false)))
(let ((@x1814 (unit-resolution (lemma @x1799 (or $x1531 $x733 $x734 $x813 $x1141 $x1532 $x741 $x784 $x338)) (unit-resolution @x1168 (unit-resolution @x647 @x1807 $x644) $x664) @x920 @x762 @x722 (unit-resolution @x1438 (unit-resolution @x647 @x1807 $x644) $x1381) @x735 (unit-resolution @x693 (unit-resolution @x599 @x1810 $x596) $x678) @x1701 $x1531)))
(let ((@x1816 (unit-resolution ((_ th-lemma arith assign-bounds -1 -2 2 -2 -2 2) (or $x1503 $x707 $x706 $x743 $x439 $x817 $x818)) @x698 @x1617 @x812 @x1538 (or $x1503 $x707 $x439))))
(let ((@x1803 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x823 $x1503)) (hypothesis $x621) (hypothesis $x1531) false)))
(let ((@x1804 (lemma @x1803 (or $x823 $x1503))))
(let ((@x1820 (unit-resolution @x623 (unit-resolution @x625 (unit-resolution @x1804 @x1814 $x823) $x363) $x620)))
(let ((@x1821 (unit-resolution @x926 @x1820 (unit-resolution @x1816 @x1814 @x1810 $x707) false)))
(let ((@x1861 (unit-resolution (lemma @x1821 (or $x338 $x463)) @x688 $x338)))
(let ((@x1827 (unit-resolution ((_ th-lemma arith assign-bounds 1 1 -1 -1 -1 1 1 -1) (or $x860 $x707 $x414 $x742 $x1424 $x800 $x801 $x289 $x438)) @x799 @x703 @x857 @x1481 @x1517 (or $x860 $x707 $x289 $x438))))
(let ((@x1829 (unit-resolution @x926 @x910 (unit-resolution @x1827 @x763 @x1078 @x858 $x707) false)))
(let ((@x1831 (lemma @x1829 (or $x438 $x289 $x860))))
(let ((@x1864 (unit-resolution @x1831 @x918 (unit-resolution @x1117 (unit-resolution @x631 @x1861 $x628) $x667) $x438)))
(let ((@x1865 (unit-resolution (unit-resolution @x709 @x1617 (or $x463 $x339 $x439 $x707)) @x1864 @x688 @x1861 $x707)))
(let ((@x1868 (unit-resolution @x1129 (unit-resolution @x631 @x1861 $x628) $x663)))
(let ((@x1619 (unit-resolution ((_ th-lemma arith assign-bounds -1 -1 -1 1 1 -1 1 1 -1) (or $x706 $x743 $x313 $x1141 $x1191 $x817 $x1198 $x1199 $x439 $x818)) @x698 @x1127 @x1138 @x812 (or $x706 $x313 $x1141 $x817 $x1198 $x439))))
(let ((@x1871 (unit-resolution (unit-resolution @x1619 @x1538 @x1617 (or $x313 $x1141 $x1198 $x439)) @x1864 @x722 @x1868 $x313)))
(let ((@x1836 (unit-resolution ((_ th-lemma arith assign-bounds 1 -1 -1 1 -1 -1 1 1 -1 1 -1 1 2 -2 -2) $x1796) @x1320 @x812 @x698 @x1127 @x730 @x715 @x1298 @x720 @x731 @x716 @x1617 @x934 @x1538 @x1647 @x764 $x1323)))
(let ((@x1833 ((_ th-lemma arith farkas 1 -1 -1 1 -1 1 1 1 -1 1 -1 -1 1) @x1138 @x1139 @x1298 @x1320 @x934 @x720 @x1127 @x1617 @x698 @x1538 @x812 @x1213 (hypothesis $x1506) false)))
(let ((@x1837 (unit-resolution (lemma @x1833 (or $x1558 $x1141 $x653 $x813 $x1198)) @x1320 @x1139 @x934 @x1213 $x1558)))
(let ((@x1840 (unit-resolution @x573 (unit-resolution @x575 (unit-resolution @x1569 @x1837 $x1546) $x488) $x584)))
(let ((@x1843 (lemma (unit-resolution @x1300 @x1840 @x1836 false) (or $x653 $x1141 $x813 $x1198 $x733 $x734 $x1629 $x766))))
(let ((@x1847 (unit-resolution @x1306 (unit-resolution @x1843 @x764 @x934 @x1213 @x731 @x716 @x1647 @x1139 $x653) (unit-resolution @x569 (unit-resolution @x755 @x764 $x92) $x582) $x1304)))
(let (($x1848 (or $x1550 $x814 $x733 $x1416 $x654 $x741 $x1421 $x1424 $x957 $x958 $x800 $x801 $x860)))
(let ((@x1850 (unit-resolution ((_ th-lemma arith assign-bounds 1 -1 -1 1 -1 1 1 1 -1 1 -1 -1) $x1848) @x1847 @x799 @x853 @x857 @x730 @x1254 @x731 @x1517 @x858 @x1672 @x1286 @x1780 $x1550)))
(let ((@x1853 (unit-resolution @x573 (unit-resolution @x575 (unit-resolution @x1583 @x1850 $x1546) $x488) $x584)))
(let ((@x1857 (unit-resolution ((_ th-lemma arith assign-bounds -1 -2 -2 2 2 2 -2) (or $x1699 $x860 $x489 $x734 $x816 $x766 $x814 $x733)) @x764 @x715 @x730 @x731 @x716 @x858 (unit-resolution @x575 (unit-resolution @x1583 @x1850 $x1546) $x488) $x1699)))
(let ((@x1858 (unit-resolution ((_ th-lemma arith assign-bounds 1 -1 -1 1 -1 -1 1 1 -1 1 -1 1 2 -2 -2) $x1792) @x1857 (unit-resolution @x1293 @x1853 $x1238) @x799 @x853 @x857 @x1138 @x1258 @x1735 @x1698 @x1139 @x1517 @x1672 @x1847 @x1254 @x1780 @x1286 false)))
(let ((@x1878 (unit-resolution (lemma @x1858 (or $x766 $x1532 $x1141 $x741 $x733 $x734 $x860 $x813 $x1198 $x1629)) (unit-resolution @x1438 (unit-resolution @x647 @x1871 $x644) $x1381) @x722 @x735 @x920 (unit-resolution @x1168 (unit-resolution @x647 @x1871 $x644) $x664) (unit-resolution @x1117 (unit-resolution @x631 @x1861 $x628) $x667) @x762 @x1868 (unit-resolution ((_ th-lemma arith assign-bounds 1 -2) (or $x875 $x1198 $x339)) @x1861 @x1868 $x875) $x766)))
(let ((@x1879 (unit-resolution ((_ th-lemma arith assign-bounds 1 1 -1 1 -1 1 -1 1 1 -1 -1 -1 -2 2) $x1782) @x1878 @x799 @x853 @x703 @x1138 @x1258 (unit-resolution @x1438 (unit-resolution @x647 @x1871 $x644) $x1381) @x722 (unit-resolution @x693 (unit-resolution @x599 @x1864 $x596) $x678) @x1517 @x1672 @x687 @x1254 @x735 $x1531)))
(let ((@x1882 (unit-resolution @x623 (unit-resolution @x625 (unit-resolution @x1804 @x1879 $x823) $x363) $x620)))
(let ((@x1884 (lemma (unit-resolution @x926 @x1882 @x1865 false) $x463)))
(let ((@x1943 (unit-resolution ((_ th-lemma arith assign-bounds 1 -1 1 -1 1) (or $x678 $x389 $x1472 $x817 $x818 $x464)) @x832 @x812 @x1610 @x1884 @x1538 $x678)))
(let ((@x1906 (unit-resolution @x1770 @x763 $x288)))
(let ((@x1910 (unit-resolution (unit-resolution @x1207 @x1481 (or $x438 $x289 $x313)) @x763 @x1906 $x313)))
(let ((@x1915 (unit-resolution ((_ th-lemma arith farkas 1 1) (or $x663 $x667)) (unit-resolution @x1831 @x1906 @x763 $x860) $x663)))
(let ((@x1886 (unit-resolution @x1270 (unit-resolution @x591 @x1884 $x588) $x672)))
(let ((@x1887 ((_ 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) @x857 @x1078 @x1517 @x799 @x1672 @x853 @x1735 @x1258 @x1255 @x1254 @x1700 @x832 @x1886 @x1138 @x1152 @x1208 @x835 (hypothesis $x1699) false)))
(let ((@x1890 (unit-resolution (lemma @x1887 (or $x657 $x289 $x1532 $x1723 $x1092 $x927)) @x1712 @x1735 @x1700 @x1208 @x1078 $x657)))
(let ((@x1772 (hypothesis $x871)))
(let ((@x1774 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x589) $x679)) @x758 (unit-resolution ((_ th-lemma arith assign-bounds 1 2) (or $x681 $x813 $x463)) @x688 @x1772 $x813) false)))
(let ((@x1777 (unit-resolution @x591 (unit-resolution (lemma @x1774 (or $x463 $x681)) @x1772 $x463) $x588)))
(let ((@x1779 (lemma (unit-resolution @x725 @x1777 @x1772 false) $x681)))
(let ((@x1897 (unit-resolution (unit-resolution ((_ th-lemma arith assign-bounds 2 -1) (or $x679 $x464 $x871)) @x1779 (or $x679 $x464)) @x1884 $x679)))
(let ((@x1899 (unit-resolution @x1306 (unit-resolution @x1843 @x1890 @x1897 @x1213 @x1147 @x716 @x1703 @x1152 $x653) (unit-resolution @x569 (unit-resolution @x755 @x1890 $x92) $x582) $x1304)))
(let ((@x1900 (unit-resolution ((_ th-lemma arith assign-bounds 1 1 1 1 1 1) (or $x488 $x338 $x1532 $x1471 $x710 $x1191 $x1141)) @x1701 @x1138 @x1258 @x1698 @x1152 @x1735 $x488)))
(let ((@x1903 ((_ th-lemma arith farkas -1 -1 1 -2 2 -1 1 1 1 -1 -1 1 -1 1 -1 1) @x857 @x1517 @x799 @x1672 @x853 @x1735 @x1258 @x1698 @x1700 @x832 @x1208 @x835 (unit-resolution @x1293 (unit-resolution @x573 @x1900 $x584) $x1238) @x1286 @x1899 @x1712 false)))
(let ((@x1917 (unit-resolution (lemma @x1903 (or $x338 $x1532 $x1723 $x1092 $x1198 $x734 $x289)) (unit-resolution @x1438 (unit-resolution @x647 @x1910 $x644) $x1381) @x966 (unit-resolution @x865 @x910 $x840) @x1915 (unit-resolution @x1168 (unit-resolution @x647 @x1910 $x644) $x664) @x1906 $x338)))
(let ((@x1919 (unit-resolution @x1117 (unit-resolution @x631 @x1917 $x628) (unit-resolution @x1831 @x1906 @x763 $x860) false)))
(let ((@x1920 (lemma @x1919 $x438)))
(let ((@x1922 (unit-resolution @x828 (unit-resolution @x599 @x1920 $x596) $x669)))
(let ((@x1925 (unit-resolution ((_ th-lemma arith assign-bounds -1 -2 2 -2 -2 2) (or $x839 $x706 $x817 $x818 $x464 $x903 $x1472)) @x832 @x812 @x1617 @x1538 @x1884 @x1922 $x839)))
(let ((@x1929 (unit-resolution @x631 (unit-resolution (unit-resolution @x1486 @x1481 (or $x338 $x872)) @x1925 $x338) $x628)))
(let ((@x1930 (unit-resolution @x1129 @x1929 $x663)))
(let ((@x1933 (unit-resolution (unit-resolution @x1491 @x1127 @x835 @x1672 (or $x872 $x1198 $x1092 $x288)) @x1370 @x1925 @x1930 $x1092)))
(let ((@x1934 (unit-resolution ((_ th-lemma arith assign-bounds 1 -2) (or $x875 $x1198 $x339)) @x1930 (unit-resolution (unit-resolution @x1486 @x1481 (or $x338 $x872)) @x1925 $x338) $x875)))
(let ((@x1937 (unit-resolution (unit-resolution @x1637 @x1127 @x1610 @x703 (or $x1629 $x1531 $x288)) @x1370 @x1934 $x1531)))
(let ((@x1939 (unit-resolution ((_ th-lemma arith farkas 1 1) (or $x840 $x670)) (unit-resolution @x1816 @x1937 @x1920 $x707) @x1933 false)))
(let ((@x1945 (unit-resolution @x1151 (unit-resolution @x639 (lemma @x1939 $x288) $x636) $x660)))
(let ((@x1948 (unit-resolution (unit-resolution @x1580 @x1779 (or $x653 $x872 $x1141 $x1262 $x784)) @x1945 @x1886 @x1925 @x1943 $x653)))
(let ((@x1950 (unit-resolution @x1146 (unit-resolution @x639 (lemma @x1939 $x288) $x636) $x661)))
(let ((@x1951 (unit-resolution ((_ th-lemma arith assign-bounds 2 -1) (or $x780 $x389 $x957)) @x1672 @x1610 $x780)))
(let ((@x1954 (unit-resolution (unit-resolution @x1592 @x1951 (or $x654 $x903 $x1262 $x733 $x860)) @x1950 @x1886 @x1922 (unit-resolution @x1117 @x1929 $x667) $x654)))
(let ((@x1957 (unit-resolution @x755 (unit-resolution @x569 (unit-resolution @x1306 @x1954 @x1948 $x91) $x583) $x766)))
(let ((@x1958 (unit-resolution (unit-resolution @x1619 @x1538 @x1617 (or $x313 $x1141 $x1198 $x439)) @x1945 @x1920 @x1930 $x313)))
(let ((@x1963 (unit-resolution ((_ th-lemma arith assign-bounds 2 -1) (or $x1249 $x314 $x1532)) (unit-resolution @x1438 (unit-resolution @x647 @x1958 $x644) $x1381) @x1958 $x1249)))
(let ((@x1966 (unit-resolution (unit-resolution @x1264 @x1951 (or $x657 $x707 $x1261 $x1262 $x733 $x903 $x860)) @x1963 @x1886 (unit-resolution @x1117 @x1929 $x667) @x1950 @x1922 @x1957 $x707)))
(let ((@x1968 (unit-resolution @x1534 @x853 @x703 @x1138 @x1258 @x1951 @x832 @x1254 (or $x657 $x1531 $x1532 $x903 $x1262 $x1141))))
(let ((@x1969 (unit-resolution @x1968 (unit-resolution @x1438 (unit-resolution @x647 @x1958 $x644) $x1381) @x1886 @x1922 @x1945 @x1957 $x1531)))
(let ((@x1972 (unit-resolution @x623 (unit-resolution @x625 (unit-resolution @x1804 @x1969 $x823) $x363) $x620)))
(unit-resolution @x926 @x1972 @x1966 false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

5c29815a1036cbd6b831d4adbe102069cf0d830f 20 0
unsat
((set-logic AUFLIRA)
(proof
(let ((?x30 (* 2.0 x$)))
(let ((?x32 (+ ?x30 1.0)))
(let ((?x28 (+ x$ x$)))
(let (($x33 (< ?x28 ?x32)))
(let (($x34 (or false $x33)))
(let (($x35 (or $x33 $x34)))
(let (($x36 (not $x35)))
(let ((@x67 (monotonicity (rewrite (= (< ?x30 (+ 1.0 ?x30)) true)) (= (not (< ?x30 (+ 1.0 ?x30))) (not true)))))
(let ((@x71 (trans @x67 (rewrite (= (not true) false)) (= (not (< ?x30 (+ 1.0 ?x30))) false))))
(let ((?x40 (+ 1.0 ?x30)))
(let (($x43 (< ?x30 ?x40)))
(let ((@x45 (monotonicity (rewrite (= ?x28 ?x30)) (rewrite (= ?x32 ?x40)) (= $x33 $x43))))
(let ((@x52 (trans (monotonicity @x45 (= $x34 (or false $x43))) (rewrite (= (or false $x43) $x43)) (= $x34 $x43))))
(let ((@x59 (trans (monotonicity @x45 @x52 (= $x35 (or $x43 $x43))) (rewrite (= (or $x43 $x43) $x43)) (= $x35 $x43))))
(let ((@x62 (monotonicity @x59 (= $x36 (not $x43)))))
(mp (asserted $x36) (trans @x62 @x71 (= $x36 false)) false))))))))))))))))))

faae12ee7efe4347f92e42776a0e0e57a624319c 113 0
unsat
((set-logic <null>)
(proof
(let ((?x228 (mod x$ 2)))
(let ((?x262 (* (- 1) ?x228)))
(let ((?x31 (mod$ x$ 2)))
(let ((?x263 (+ ?x31 ?x262)))
(let (($x280 (>= ?x263 0)))
(let (($x264 (= ?x263 0)))
(let (($x205 (forall ((?v0 Int) (?v1 Int) )(! (let ((?x136 (mod ?v0 ?v1)))
(let ((?x93 (* (- 1) ?v1)))
(let ((?x90 (* (- 1) ?v0)))
(let ((?x144 (mod ?x90 ?x93)))
(let ((?x150 (* (- 1) ?x144)))
(let (($x111 (<= ?v1 0)))
(let ((?x170 (ite $x111 ?x150 ?x136)))
(let (($x78 (= ?v1 0)))
(let ((?x175 (ite $x78 ?v0 ?x170)))
(let ((?x135 (mod$ ?v0 ?v1)))
(= ?x135 ?x175))))))))))) :pattern ( (mod$ ?v0 ?v1) ) :qid k!9))
))
(let (($x181 (forall ((?v0 Int) (?v1 Int) )(! (let ((?x136 (mod ?v0 ?v1)))
(let ((?x93 (* (- 1) ?v1)))
(let ((?x90 (* (- 1) ?v0)))
(let ((?x144 (mod ?x90 ?x93)))
(let ((?x150 (* (- 1) ?x144)))
(let (($x111 (<= ?v1 0)))
(let ((?x170 (ite $x111 ?x150 ?x136)))
(let (($x78 (= ?v1 0)))
(let ((?x175 (ite $x78 ?v0 ?x170)))
(let ((?x135 (mod$ ?v0 ?v1)))
(= ?x135 ?x175))))))))))) :qid k!9))
))
(let ((?x136 (mod ?1 ?0)))
(let ((?x93 (* (- 1) ?0)))
(let ((?x90 (* (- 1) ?1)))
(let ((?x144 (mod ?x90 ?x93)))
(let ((?x150 (* (- 1) ?x144)))
(let (($x111 (<= ?0 0)))
(let ((?x170 (ite $x111 ?x150 ?x136)))
(let (($x78 (= ?0 0)))
(let ((?x175 (ite $x78 ?1 ?x170)))
(let ((?x135 (mod$ ?1 ?0)))
(let (($x178 (= ?x135 ?x175)))
(let (($x142 (forall ((?v0 Int) (?v1 Int) )(! (let (($x78 (= ?v1 0)))
(let ((?x140 (ite $x78 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
(let ((?x135 (mod$ ?v0 ?v1)))
(= ?x135 ?x140)))) :qid k!9))
))
(let (($x164 (forall ((?v0 Int) (?v1 Int) )(! (let ((?x93 (* (- 1) ?v1)))
(let ((?x90 (* (- 1) ?v0)))
(let ((?x144 (mod ?x90 ?x93)))
(let ((?x150 (* (- 1) ?x144)))
(let ((?x136 (mod ?v0 ?v1)))
(let (($x79 (< 0 ?v1)))
(let ((?x155 (ite $x79 ?x136 ?x150)))
(let (($x78 (= ?v1 0)))
(let ((?x158 (ite $x78 ?v0 ?x155)))
(let ((?x135 (mod$ ?v0 ?v1)))
(= ?x135 ?x158))))))))))) :qid k!9))
))
(let ((@x169 (monotonicity (rewrite (= (< 0 ?0) (not $x111))) (= (ite (< 0 ?0) ?x136 ?x150) (ite (not $x111) ?x136 ?x150)))))
(let ((@x174 (trans @x169 (rewrite (= (ite (not $x111) ?x136 ?x150) ?x170)) (= (ite (< 0 ?0) ?x136 ?x150) ?x170))))
(let ((@x177 (monotonicity @x174 (= (ite $x78 ?1 (ite (< 0 ?0) ?x136 ?x150)) ?x175))))
(let ((@x180 (monotonicity @x177 (= (= ?x135 (ite $x78 ?1 (ite (< 0 ?0) ?x136 ?x150))) $x178))))
(let (($x79 (< 0 ?0)))
(let ((?x155 (ite $x79 ?x136 ?x150)))
(let ((?x158 (ite $x78 ?1 ?x155)))
(let (($x161 (= ?x135 ?x158)))
(let (($x162 (= (= ?x135 (ite $x78 ?1 (ite $x79 ?x136 (- (mod (- ?1) (- ?0)))))) $x161)))
(let ((@x146 (monotonicity (rewrite (= (- ?1) ?x90)) (rewrite (= (- ?0) ?x93)) (= (mod (- ?1) (- ?0)) ?x144))))
(let ((@x154 (trans (monotonicity @x146 (= (- (mod (- ?1) (- ?0))) (- ?x144))) (rewrite (= (- ?x144) ?x150)) (= (- (mod (- ?1) (- ?0))) ?x150))))
(let ((@x157 (monotonicity @x154 (= (ite $x79 ?x136 (- (mod (- ?1) (- ?0)))) ?x155))))
(let ((@x160 (monotonicity @x157 (= (ite $x78 ?1 (ite $x79 ?x136 (- (mod (- ?1) (- ?0))))) ?x158))))
(let ((@x185 (trans (quant-intro (monotonicity @x160 $x162) (= $x142 $x164)) (quant-intro @x180 (= $x164 $x181)) (= $x142 $x181))))
(let ((@x196 (mp~ (mp (asserted $x142) @x185 $x181) (nnf-pos (refl (~ $x178 $x178)) (~ $x181 $x181)) $x181)))
(let ((@x210 (mp @x196 (quant-intro (refl (= $x178 $x178)) (= $x181 $x205)) $x205)))
(let (($x270 (or (not $x205) $x264)))
(let ((?x225 (* (- 1) 2)))
(let ((?x224 (* (- 1) x$)))
(let ((?x226 (mod ?x224 ?x225)))
(let ((?x227 (* (- 1) ?x226)))
(let (($x223 (<= 2 0)))
(let ((?x229 (ite $x223 ?x227 ?x228)))
(let (($x222 (= 2 0)))
(let ((?x230 (ite $x222 x$ ?x229)))
(let (($x231 (= ?x31 ?x230)))
(let ((@x244 (monotonicity (monotonicity (rewrite (= ?x225 (- 2))) (= ?x226 (mod ?x224 (- 2)))) (= ?x227 (* (- 1) (mod ?x224 (- 2)))))))
(let ((@x247 (monotonicity (rewrite (= $x223 false)) @x244 (= ?x229 (ite false (* (- 1) (mod ?x224 (- 2))) ?x228)))))
(let ((@x251 (trans @x247 (rewrite (= (ite false (* (- 1) (mod ?x224 (- 2))) ?x228) ?x228)) (= ?x229 ?x228))))
(let ((@x254 (monotonicity (rewrite (= $x222 false)) @x251 (= ?x230 (ite false x$ ?x228)))))
(let ((@x261 (monotonicity (trans @x254 (rewrite (= (ite false x$ ?x228) ?x228)) (= ?x230 ?x228)) (= $x231 (= ?x31 ?x228)))))
(let ((@x274 (monotonicity (trans @x261 (rewrite (= (= ?x31 ?x228) $x264)) (= $x231 $x264)) (= (or (not $x205) $x231) $x270))))
(let ((@x277 (trans @x274 (rewrite (= $x270 $x270)) (= (or (not $x205) $x231) $x270))))
(let ((@x278 (mp ((_ quant-inst x$ 2) (or (not $x205) $x231)) @x277 $x270)))
(let ((@x332 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x264) $x280)) (unit-resolution @x278 @x210 $x264) $x280)))
(let (($x305 (>= ?x228 0)))
(let (($x64 (>= ?x31 0)))
(let (($x67 (not $x64)))
(let (($x36 (not (<= (+ x$ 1) (+ x$ (+ (* 2 ?x31) 1))))))
(let ((@x69 (monotonicity (rewrite (= (>= (* 2 ?x31) 0) $x64)) (= (not (>= (* 2 ?x31) 0)) $x67))))
(let ((?x32 (* 2 ?x31)))
(let ((?x47 (+ 1 x$ ?x32)))
(let (($x52 (<= (+ 1 x$) ?x47)))
(let (($x55 (not $x52)))
(let ((@x63 (monotonicity (rewrite (= $x52 (>= ?x32 0))) (= $x55 (not (>= ?x32 0))))))
(let ((@x46 (monotonicity (rewrite (= (+ ?x32 1) (+ 1 ?x32))) (= (+ x$ (+ ?x32 1)) (+ x$ (+ 1 ?x32))))))
(let ((@x51 (trans @x46 (rewrite (= (+ x$ (+ 1 ?x32)) ?x47)) (= (+ x$ (+ ?x32 1)) ?x47))))
(let ((@x54 (monotonicity (rewrite (= (+ x$ 1) (+ 1 x$))) @x51 (= (<= (+ x$ 1) (+ x$ (+ ?x32 1))) $x52))))
(let ((@x73 (trans (monotonicity @x54 (= $x36 $x55)) (trans @x63 @x69 (= $x55 $x67)) (= $x36 $x67))))
(let ((@x74 (mp (asserted $x36) @x73 $x67)))
((_ th-lemma arith farkas -1 1 1) @x74 (unit-resolution ((_ th-lemma arith) (or false $x305)) (true-axiom true) $x305) @x332 false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

57f344c9e787868c98d1e622f158c445c1899c96 112 0
unsat
((set-logic <null>)
(proof
(let ((?x224 (mod x$ 2)))
(let (($x318 (>= ?x224 2)))
(let (($x319 (not $x318)))
(let ((?x258 (* (- 1) ?x224)))
(let ((?x29 (mod$ x$ 2)))
(let ((?x259 (+ ?x29 ?x258)))
(let (($x275 (<= ?x259 0)))
(let (($x260 (= ?x259 0)))
(let (($x201 (forall ((?v0 Int) (?v1 Int) )(! (let ((?x132 (mod ?v0 ?v1)))
(let ((?x89 (* (- 1) ?v1)))
(let ((?x86 (* (- 1) ?v0)))
(let ((?x140 (mod ?x86 ?x89)))
(let ((?x146 (* (- 1) ?x140)))
(let (($x107 (<= ?v1 0)))
(let ((?x166 (ite $x107 ?x146 ?x132)))
(let (($x74 (= ?v1 0)))
(let ((?x171 (ite $x74 ?v0 ?x166)))
(let ((?x131 (mod$ ?v0 ?v1)))
(= ?x131 ?x171))))))))))) :pattern ( (mod$ ?v0 ?v1) ) :qid k!9))
))
(let (($x177 (forall ((?v0 Int) (?v1 Int) )(! (let ((?x132 (mod ?v0 ?v1)))
(let ((?x89 (* (- 1) ?v1)))
(let ((?x86 (* (- 1) ?v0)))
(let ((?x140 (mod ?x86 ?x89)))
(let ((?x146 (* (- 1) ?x140)))
(let (($x107 (<= ?v1 0)))
(let ((?x166 (ite $x107 ?x146 ?x132)))
(let (($x74 (= ?v1 0)))
(let ((?x171 (ite $x74 ?v0 ?x166)))
(let ((?x131 (mod$ ?v0 ?v1)))
(= ?x131 ?x171))))))))))) :qid k!9))
))
(let ((?x132 (mod ?1 ?0)))
(let ((?x89 (* (- 1) ?0)))
(let ((?x86 (* (- 1) ?1)))
(let ((?x140 (mod ?x86 ?x89)))
(let ((?x146 (* (- 1) ?x140)))
(let (($x107 (<= ?0 0)))
(let ((?x166 (ite $x107 ?x146 ?x132)))
(let (($x74 (= ?0 0)))
(let ((?x171 (ite $x74 ?1 ?x166)))
(let ((?x131 (mod$ ?1 ?0)))
(let (($x174 (= ?x131 ?x171)))
(let (($x138 (forall ((?v0 Int) (?v1 Int) )(! (let (($x74 (= ?v1 0)))
(let ((?x136 (ite $x74 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
(let ((?x131 (mod$ ?v0 ?v1)))
(= ?x131 ?x136)))) :qid k!9))
))
(let (($x160 (forall ((?v0 Int) (?v1 Int) )(! (let ((?x89 (* (- 1) ?v1)))
(let ((?x86 (* (- 1) ?v0)))
(let ((?x140 (mod ?x86 ?x89)))
(let ((?x146 (* (- 1) ?x140)))
(let ((?x132 (mod ?v0 ?v1)))
(let (($x75 (< 0 ?v1)))
(let ((?x151 (ite $x75 ?x132 ?x146)))
(let (($x74 (= ?v1 0)))
(let ((?x154 (ite $x74 ?v0 ?x151)))
(let ((?x131 (mod$ ?v0 ?v1)))
(= ?x131 ?x154))))))))))) :qid k!9))
))
(let ((@x165 (monotonicity (rewrite (= (< 0 ?0) (not $x107))) (= (ite (< 0 ?0) ?x132 ?x146) (ite (not $x107) ?x132 ?x146)))))
(let ((@x170 (trans @x165 (rewrite (= (ite (not $x107) ?x132 ?x146) ?x166)) (= (ite (< 0 ?0) ?x132 ?x146) ?x166))))
(let ((@x173 (monotonicity @x170 (= (ite $x74 ?1 (ite (< 0 ?0) ?x132 ?x146)) ?x171))))
(let ((@x176 (monotonicity @x173 (= (= ?x131 (ite $x74 ?1 (ite (< 0 ?0) ?x132 ?x146))) $x174))))
(let (($x75 (< 0 ?0)))
(let ((?x151 (ite $x75 ?x132 ?x146)))
(let ((?x154 (ite $x74 ?1 ?x151)))
(let (($x157 (= ?x131 ?x154)))
(let (($x158 (= (= ?x131 (ite $x74 ?1 (ite $x75 ?x132 (- (mod (- ?1) (- ?0)))))) $x157)))
(let ((@x142 (monotonicity (rewrite (= (- ?1) ?x86)) (rewrite (= (- ?0) ?x89)) (= (mod (- ?1) (- ?0)) ?x140))))
(let ((@x150 (trans (monotonicity @x142 (= (- (mod (- ?1) (- ?0))) (- ?x140))) (rewrite (= (- ?x140) ?x146)) (= (- (mod (- ?1) (- ?0))) ?x146))))
(let ((@x153 (monotonicity @x150 (= (ite $x75 ?x132 (- (mod (- ?1) (- ?0)))) ?x151))))
(let ((@x156 (monotonicity @x153 (= (ite $x74 ?1 (ite $x75 ?x132 (- (mod (- ?1) (- ?0))))) ?x154))))
(let ((@x181 (trans (quant-intro (monotonicity @x156 $x158) (= $x138 $x160)) (quant-intro @x176 (= $x160 $x177)) (= $x138 $x177))))
(let ((@x192 (mp~ (mp (asserted $x138) @x181 $x177) (nnf-pos (refl (~ $x174 $x174)) (~ $x177 $x177)) $x177)))
(let ((@x206 (mp @x192 (quant-intro (refl (= $x174 $x174)) (= $x177 $x201)) $x201)))
(let (($x266 (or (not $x201) $x260)))
(let ((?x221 (* (- 1) 2)))
(let ((?x220 (* (- 1) x$)))
(let ((?x222 (mod ?x220 ?x221)))
(let ((?x223 (* (- 1) ?x222)))
(let (($x219 (<= 2 0)))
(let ((?x225 (ite $x219 ?x223 ?x224)))
(let (($x218 (= 2 0)))
(let ((?x226 (ite $x218 x$ ?x225)))
(let (($x227 (= ?x29 ?x226)))
(let ((@x240 (monotonicity (monotonicity (rewrite (= ?x221 (- 2))) (= ?x222 (mod ?x220 (- 2)))) (= ?x223 (* (- 1) (mod ?x220 (- 2)))))))
(let ((@x243 (monotonicity (rewrite (= $x219 false)) @x240 (= ?x225 (ite false (* (- 1) (mod ?x220 (- 2))) ?x224)))))
(let ((@x247 (trans @x243 (rewrite (= (ite false (* (- 1) (mod ?x220 (- 2))) ?x224) ?x224)) (= ?x225 ?x224))))
(let ((@x250 (monotonicity (rewrite (= $x218 false)) @x247 (= ?x226 (ite false x$ ?x224)))))
(let ((@x257 (monotonicity (trans @x250 (rewrite (= (ite false x$ ?x224) ?x224)) (= ?x226 ?x224)) (= $x227 (= ?x29 ?x224)))))
(let ((@x270 (monotonicity (trans @x257 (rewrite (= (= ?x29 ?x224) $x260)) (= $x227 $x260)) (= (or (not $x201) $x227) $x266))))
(let ((@x273 (trans @x270 (rewrite (= $x266 $x266)) (= (or (not $x201) $x227) $x266))))
(let ((@x274 (mp ((_ quant-inst x$ 2) (or (not $x201) $x227)) @x273 $x266)))
(let ((@x331 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x260) $x275)) (unit-resolution @x274 @x206 $x260) $x275)))
(let (($x63 (>= ?x29 2)))
(let ((?x37 (* 2 ?x29)))
(let (($x56 (>= ?x37 3)))
(let (($x46 (< (+ x$ ?x37) (+ 3 x$))))
(let (($x49 (not $x46)))
(let ((@x58 (monotonicity (rewrite (= $x46 (not $x56))) (= $x49 (not (not $x56))))))
(let ((@x67 (trans (trans @x58 (rewrite (= (not (not $x56)) $x56)) (= $x49 $x56)) (rewrite (= $x56 $x63)) (= $x49 $x63))))
(let ((@x42 (monotonicity (rewrite (= (+ ?x29 ?x29) ?x37)) (= (+ x$ (+ ?x29 ?x29)) (+ x$ ?x37)))))
(let ((@x48 (monotonicity @x42 (rewrite (= (+ x$ 3) (+ 3 x$))) (= (< (+ x$ (+ ?x29 ?x29)) (+ x$ 3)) $x46))))
(let ((@x51 (monotonicity @x48 (= (not (< (+ x$ (+ ?x29 ?x29)) (+ x$ 3))) $x49))))
(let ((@x69 (trans @x51 @x67 (= (not (< (+ x$ (+ ?x29 ?x29)) (+ x$ 3))) $x63))))
(let ((@x70 (mp (asserted (not (< (+ x$ (+ ?x29 ?x29)) (+ x$ 3)))) @x69 $x63)))
((_ th-lemma arith farkas -1 1 1) @x70 @x331 (unit-resolution ((_ th-lemma arith) (or false $x319)) (true-axiom true) $x319) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

3938db798ebafb55191dcdaf83a8615d1d59c0c3 32 0
unsat
((set-logic <null>)
(proof
(let (($x28 (= x$ 0.0)))
(let (($x29 (not $x28)))
(let ((@x30 (asserted $x29)))
(let (($x101 (<= x$ 0.0)))
(let ((?x47 (* 2.0 x$)))
(let (($x99 (<= ?x47 0.0)))
(let (($x95 (= ?x47 0.0)))
(let (($x36 (< 1.0 (ite (< x$ 0.0) (- x$) x$))))
(let (($x38 (or $x36 (not $x36))))
(let ((?x41 (ite $x38 4.0 2.0)))
(let (($x45 (not (not (= (+ x$ x$) (* ?x41 x$))))))
(let ((@x90 (rewrite (= (not (not (= ?x47 (* 4.0 x$)))) (= ?x47 (* 4.0 x$))))))
(let (($x84 (= (not (= (+ x$ x$) (* ?x41 x$))) (not (= ?x47 (* 4.0 x$))))))
(let (($x57 (< 1.0 (ite (< x$ 0.0) (* (- 1.0) x$) x$))))
(let (($x55 (= (ite (< x$ 0.0) (- x$) x$) (ite (< x$ 0.0) (* (- 1.0) x$) x$))))
(let ((@x59 (monotonicity (monotonicity (rewrite (= (- x$) (* (- 1.0) x$))) $x55) (= $x36 $x57))))
(let ((@x65 (monotonicity @x59 (monotonicity @x59 (= (not $x36) (not $x57))) (= $x38 (or $x57 (not $x57))))))
(let ((@x69 (trans @x65 (rewrite (= (or $x57 (not $x57)) true)) (= $x38 true))))
(let ((@x76 (trans (monotonicity @x69 (= ?x41 (ite true 4.0 2.0))) (rewrite (= (ite true 4.0 2.0) 4.0)) (= ?x41 4.0))))
(let ((@x82 (monotonicity (rewrite (= (+ x$ x$) ?x47)) (monotonicity @x76 (= (* ?x41 x$) (* 4.0 x$))) (= (= (+ x$ x$) (* ?x41 x$)) (= ?x47 (* 4.0 x$))))))
(let ((@x88 (monotonicity (monotonicity @x82 $x84) (= $x45 (not (not (= ?x47 (* 4.0 x$))))))))
(let ((@x97 (trans (trans @x88 @x90 (= $x45 (= ?x47 (* 4.0 x$)))) (rewrite (= (= ?x47 (* 4.0 x$)) $x95)) (= $x45 $x95))))
(let ((@x98 (mp (asserted $x45) @x97 $x95)))
(let ((@x110 (unit-resolution ((_ th-lemma arith assign-bounds 1) (or $x101 (not $x99))) (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x95) $x99)) @x98 $x99) $x101)))
(let (($x102 (>= x$ 0.0)))
(let (($x100 (>= ?x47 0.0)))
(let ((@x117 (unit-resolution ((_ th-lemma arith assign-bounds 1) (or $x102 (not $x100))) (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x95) $x100)) @x98 $x100) $x102)))
(unit-resolution ((_ th-lemma arith triangle-eq) (or $x28 (not $x101) (not $x102))) @x117 @x110 @x30 false))))))))))))))))))))))))))))))

dcc9b986d57d4904aeadc1233210450bb15df4d3 12 0
unsat
((set-logic AUFLIA)
(proof
(let (($x28 (exists ((?v0 Int) )(! false :qid k!4))
))
(let (($x27 (not $x28)))
(let (($x29 (not $x27)))
(let ((@x35 (monotonicity (elim-unused (= $x28 false)) (= $x27 (not false)))))
(let ((@x42 (monotonicity (trans @x35 (rewrite (= (not false) true)) (= $x27 true)) (= $x29 (not true)))))
(let ((@x46 (trans @x42 (rewrite (= (not true) false)) (= $x29 false))))
(mp (asserted $x29) @x46 false)))))))))

e33f4ac0207897c2b7abfeafedc87232f999a6d5 12 0
unsat
((set-logic AUFLIRA)
(proof
(let (($x27 (exists ((?v0 Real) )(! false :qid k!4))
))
(let (($x28 (not $x27)))
(let (($x29 (not $x28)))
(let ((@x35 (monotonicity (elim-unused (= $x27 false)) (= $x28 (not false)))))
(let ((@x42 (monotonicity (trans @x35 (rewrite (= (not false) true)) (= $x28 true)) (= $x29 (not true)))))
(let ((@x46 (trans @x42 (rewrite (= (not true) false)) (= $x29 false))))
(mp (asserted $x29) @x46 false)))))))))

ef29919c373b650f8005a5573289548ab716b089 22 0
unsat
((set-logic AUFLIA)
(proof
(let (($x52 (forall ((?v0 Int) )(! (<= ?v0 0) :qid k!4))
))
(let (($x46 (forall ((?v0 Int) )(! (let (($x34 (<= ?v0 0)))
(let (($x35 (not $x34)))
(not $x35))) :qid k!4))
))
(let ((@x54 (quant-intro (rewrite (= (not (not (<= ?0 0))) (<= ?0 0))) (= $x46 $x52))))
(let (($x38 (exists ((?v0 Int) )(! (let (($x34 (<= ?v0 0)))
(not $x34)) :qid k!4))
))
(let (($x41 (not $x38)))
(let ((@x48 (nnf-neg (refl (~ (not (not (<= ?0 0))) (not (not (<= ?0 0))))) (~ $x41 $x46))))
(let (($x29 (exists ((?v0 Int) )(! (< 0 ?v0) :qid k!4))
))
(let (($x30 (not $x29)))
(let ((@x40 (quant-intro (rewrite (= (< 0 ?0) (not (<= ?0 0)))) (= $x29 $x38))))
(let ((@x49 (mp~ (mp (asserted $x30) (monotonicity @x40 (= $x30 $x41)) $x41) @x48 $x46)))
(mp (mp @x49 @x54 $x52) (rewrite (= $x52 false)) false)))))))))))))

4d3a976164de7ccb5d4650a113f067b8a1c55b22 22 0
unsat
((set-logic AUFLIRA)
(proof
(let (($x51 (forall ((?v0 Real) )(! (<= ?v0 0.0) :qid k!4))
))
(let (($x45 (forall ((?v0 Real) )(! (let (($x33 (<= ?v0 0.0)))
(let (($x34 (not $x33)))
(not $x34))) :qid k!4))
))
(let ((@x53 (quant-intro (rewrite (= (not (not (<= ?0 0.0))) (<= ?0 0.0))) (= $x45 $x51))))
(let (($x37 (exists ((?v0 Real) )(! (let (($x33 (<= ?v0 0.0)))
(not $x33)) :qid k!4))
))
(let (($x40 (not $x37)))
(let ((@x47 (nnf-neg (refl (~ (not (not (<= ?0 0.0))) (not (not (<= ?0 0.0))))) (~ $x40 $x45))))
(let (($x28 (exists ((?v0 Real) )(! (< 0.0 ?v0) :qid k!4))
))
(let (($x29 (not $x28)))
(let ((@x39 (quant-intro (rewrite (= (< 0.0 ?0) (not (<= ?0 0.0)))) (= $x28 $x37))))
(let ((@x48 (mp~ (mp (asserted $x29) (monotonicity @x39 (= $x29 $x40)) $x40) @x47 $x45)))
(mp (mp @x48 @x53 $x51) (rewrite (= $x51 false)) false)))))))))))))

f28123a872d014e01ec45f8bb7163bb037909301 31 0
unsat
((set-logic AUFLIA)
(declare-fun ?v0!0 () Int)
(proof
(let (($x71 (forall ((?v1 Int) )(! (<= (+ ?v1 (* (- 1) ?v0!0)) 0) :qid k!4))
))
(let (($x63 (forall ((?v1 Int) )(! (not (not (<= (+ ?v1 (* (- 1) ?v0!0)) 0))) :qid k!4))
))
(let (($x54 (<= (+ ?0 (* (- 1) ?v0!0)) 0)))
(let (($x60 (not (not $x54))))
(let (($x46 (forall ((?v0 Int) )(! (exists ((?v1 Int) )(! (not (<= (+ ?v1 (* (- 1) ?v0)) 0)) :qid k!4))
 :qid k!4))
))
(let (($x49 (not $x46)))
(let (($x56 (exists ((?v1 Int) )(! (let (($x54 (<= (+ ?v1 (* (- 1) ?v0!0)) 0)))
(not $x54)) :qid k!4))
))
(let ((@x67 (trans (sk (~ $x49 (not $x56))) (nnf-neg (refl (~ $x60 $x60)) (~ (not $x56) $x63)) (~ $x49 $x63))))
(let (($x31 (forall ((?v0 Int) )(! (exists ((?v1 Int) )(! (< ?v0 ?v1) :qid k!4))
 :qid k!4))
))
(let (($x32 (not $x31)))
(let (($x43 (exists ((?v1 Int) )(! (not (<= (+ ?v1 (* (- 1) ?0)) 0)) :qid k!4))
))
(let (($x30 (exists ((?v1 Int) )(! (< ?0 ?v1) :qid k!4))
))
(let ((@x42 (rewrite (= (< ?1 ?0) (not (<= (+ ?0 (* (- 1) ?1)) 0))))))
(let ((@x51 (monotonicity (quant-intro (quant-intro @x42 (= $x30 $x43)) (= $x31 $x46)) (= $x32 $x49))))
(let ((@x74 (mp (mp~ (mp (asserted $x32) @x51 $x49) @x67 $x63) (quant-intro (rewrite (= $x60 $x54)) (= $x63 $x71)) $x71)))
(mp @x74 (rewrite (= $x71 false)) false))))))))))))))))))

574f579e644304e47945be9d8bd47347079730d4 22 0
unsat
((set-logic AUFLIA)
(declare-fun ?v1!0 () Int)
(declare-fun ?v0!1 () Int)
(proof
(let (($x53 (= ?v1!0 1)))
(let (($x59 (not (or (not (and (= ?v0!1 0) $x53)) (not (= ?v0!1 ?v1!0))))))
(let (($x43 (forall ((?v0 Int) (?v1 Int) )(! (or (not (and (= ?v0 0) (= ?v1 1))) (not (= ?v0 ?v1))) :qid k!4))
))
(let (($x46 (not $x43)))
(let (($x36 (forall ((?v0 Int) (?v1 Int) )(! (=> (and (= ?v0 0) (= ?v1 1)) (not (= ?v0 ?v1))) :qid k!4))
))
(let (($x37 (not $x36)))
(let (($x41 (= (=> (and (= ?1 0) (= ?0 1)) (not (= ?1 ?0))) (or (not (and (= ?1 0) (= ?0 1))) (not (= ?1 ?0))))))
(let ((@x48 (monotonicity (quant-intro (rewrite $x41) (= $x36 $x43)) (= $x37 $x46))))
(let ((@x65 (not-or-elim (mp~ (mp (asserted $x37) @x48 $x46) (sk (~ $x46 $x59)) $x59) (and (= ?v0!1 0) $x53))))
(let ((@x67 (and-elim @x65 $x53)))
(let (($x56 (= ?v0!1 ?v1!0)))
(let ((@x68 (not-or-elim (mp~ (mp (asserted $x37) @x48 $x46) (sk (~ $x46 $x59)) $x59) $x56)))
(let ((@x70 (trans (symm (and-elim @x65 (= ?v0!1 0)) (= 0 ?v0!1)) @x68 (= 0 ?v1!0))))
(mp (trans @x70 @x67 (= 0 1)) (rewrite (= (= 0 1) false)) false))))))))))))))))

a24ff2e4a93d06b88e1d7717852cb82258ed11ed 55 0
unsat
((set-logic AUFLIA)
(proof
(let (($x35 (exists ((?v0 Int) )(! (forall ((?v1 Int) )(! (let (($x31 (<= 0 ?v1)))
(let (($x30 (< ?v1 0)))
(let (($x32 (or $x30 $x31)))
(let (($x29 (< ?v0 ?v1)))
(=> $x29 $x32))))) :qid k!4))
 :qid k!4))
))
(let (($x36 (not $x35)))
(let (($x45 (exists ((?v0 Int) )(! (forall ((?v1 Int) )(! (let (($x31 (<= 0 ?v1)))
(let (($x30 (< ?v1 0)))
(let (($x32 (or $x30 $x31)))
(let (($x29 (< ?v0 ?v1)))
(let (($x38 (not $x29)))
(or $x38 $x32)))))) :qid k!4))
 :qid k!4))
))
(let (($x48 (not $x45)))
(let (($x88 (exists ((?v0 Int) )(! true :qid k!4))
))
(let (($x42 (forall ((?v1 Int) )(! (let (($x31 (<= 0 ?v1)))
(let (($x30 (< ?v1 0)))
(let (($x32 (or $x30 $x31)))
(let (($x29 (< ?0 ?v1)))
(let (($x38 (not $x29)))
(or $x38 $x32)))))) :qid k!4))
))
(let (($x81 (forall ((?v1 Int) )(! true :qid k!4))
))
(let (($x31 (<= 0 ?0)))
(let (($x30 (< ?0 0)))
(let (($x32 (or $x30 $x31)))
(let (($x29 (< ?1 ?0)))
(let (($x38 (not $x29)))
(let (($x39 (or $x38 $x32)))
(let (($x60 (<= (+ ?0 (* (- 1) ?1)) 0)))
(let ((@x78 (rewrite (= (or $x60 (or (not (>= ?0 0)) (>= ?0 0))) true))))
(let ((@x73 (monotonicity (rewrite (= $x30 (not (>= ?0 0)))) (rewrite (= $x31 (>= ?0 0))) (= $x32 (or (not (>= ?0 0)) (>= ?0 0))))))
(let ((@x66 (monotonicity (rewrite (= $x29 (not $x60))) (= $x38 (not (not $x60))))))
(let ((@x76 (monotonicity (trans @x66 (rewrite (= (not (not $x60)) $x60)) (= $x38 $x60)) @x73 (= $x39 (or $x60 (or (not (>= ?0 0)) (>= ?0 0)))))))
(let ((@x87 (trans (quant-intro (trans @x76 @x78 (= $x39 true)) (= $x42 $x81)) (elim-unused (= $x81 true)) (= $x42 true))))
(let ((@x94 (trans (quant-intro @x87 (= $x45 $x88)) (elim-unused (= $x88 true)) (= $x45 true))))
(let ((@x101 (trans (monotonicity @x94 (= $x48 (not true))) (rewrite (= (not true) false)) (= $x48 false))))
(let (($x34 (forall ((?v1 Int) )(! (let (($x31 (<= 0 ?v1)))
(let (($x30 (< ?v1 0)))
(let (($x32 (or $x30 $x31)))
(let (($x29 (< ?0 ?v1)))
(=> $x29 $x32))))) :qid k!4))
))
(let ((@x47 (quant-intro (quant-intro (rewrite (= (=> $x29 $x32) $x39)) (= $x34 $x42)) (= $x35 $x45))))
(let ((@x50 (monotonicity @x47 (= $x36 $x48))))
(mp (asserted $x36) (trans @x50 @x101 (= $x36 false)) false)))))))))))))))))))))))))))

c446c8659459cda8dda1ecfd9aba54ce2a50f002 42 0
unsat
((set-logic AUFLIA)
(proof
(let (($x37 (forall ((?v0 Int) (?v1 Int) )(! (let ((?x34 (* 2 ?v1)))
(let ((?x31 (* 2 ?v0)))
(let ((?x33 (+ ?x31 1)))
(let (($x35 (< ?x33 ?x34)))
(let (($x29 (< ?v0 ?v1)))
(=> $x29 $x35)))))) :qid k!4))
))
(let (($x38 (not $x37)))
(let (($x55 (forall ((?v0 Int) (?v1 Int) )(! (let ((?x34 (* 2 ?v1)))
(let ((?x31 (* 2 ?v0)))
(let ((?x40 (+ 1 ?x31)))
(let (($x43 (< ?x40 ?x34)))
(let (($x29 (< ?v0 ?v1)))
(let (($x49 (not $x29)))
(or $x49 $x43))))))) :qid k!4))
))
(let (($x58 (not $x55)))
(let (($x84 (forall ((?v0 Int) (?v1 Int) )(! true :qid k!4))
))
(let ((?x34 (* 2 ?0)))
(let ((?x31 (* 2 ?1)))
(let ((?x40 (+ 1 ?x31)))
(let (($x43 (< ?x40 ?x34)))
(let (($x29 (< ?1 ?0)))
(let (($x49 (not $x29)))
(let (($x50 (or $x49 $x43)))
(let (($x63 (>= (+ ?1 (* (- 1) ?0)) 0)))
(let (($x62 (not $x63)))
(let ((@x74 (trans (monotonicity (rewrite (= $x29 $x62)) (= $x49 (not $x62))) (rewrite (= (not $x62) $x63)) (= $x49 $x63))))
(let ((@x79 (monotonicity @x74 (rewrite (= $x43 $x62)) (= $x50 (or $x63 $x62)))))
(let ((@x86 (quant-intro (trans @x79 (rewrite (= (or $x63 $x62) true)) (= $x50 true)) (= $x55 $x84))))
(let ((@x93 (monotonicity (trans @x86 (elim-unused (= $x84 true)) (= $x55 true)) (= $x58 (not true)))))
(let ((@x97 (trans @x93 (rewrite (= (not true) false)) (= $x58 false))))
(let ((@x45 (monotonicity (rewrite (= (+ ?x31 1) ?x40)) (= (< (+ ?x31 1) ?x34) $x43))))
(let ((@x48 (monotonicity @x45 (= (=> $x29 (< (+ ?x31 1) ?x34)) (=> $x29 $x43)))))
(let ((@x54 (trans @x48 (rewrite (= (=> $x29 $x43) $x50)) (= (=> $x29 (< (+ ?x31 1) ?x34)) $x50))))
(let ((@x60 (monotonicity (quant-intro @x54 (= $x37 $x55)) (= $x38 $x58))))
(mp (asserted $x38) (trans @x60 @x97 (= $x38 false)) false))))))))))))))))))))))))))

a6ee8724a53192e0bb5b41bbeed60d66d29cdc32 32 0
unsat
((set-logic AUFLIA)
(proof
(let (($x36 (forall ((?v0 Int) (?v1 Int) )(! (let ((?x33 (* 2 ?v1)))
(let ((?x30 (* 2 ?v0)))
(let ((?x32 (+ ?x30 1)))
(let (($x34 (= ?x32 ?x33)))
(not $x34))))) :qid k!4))
))
(let (($x37 (not $x36)))
(let (($x48 (forall ((?v0 Int) (?v1 Int) )(! (let ((?x33 (* 2 ?v1)))
(let ((?x30 (* 2 ?v0)))
(let ((?x39 (+ 1 ?x30)))
(let (($x42 (= ?x39 ?x33)))
(not $x42))))) :qid k!4))
))
(let (($x51 (not $x48)))
(let (($x63 (forall ((?v0 Int) (?v1 Int) )(! true :qid k!4))
))
(let ((?x33 (* 2 ?0)))
(let ((?x30 (* 2 ?1)))
(let ((?x39 (+ 1 ?x30)))
(let (($x42 (= ?x39 ?x33)))
(let (($x45 (not $x42)))
(let ((@x62 (trans (monotonicity (rewrite (= $x42 false)) (= $x45 (not false))) (rewrite (= (not false) true)) (= $x45 true))))
(let ((@x69 (trans (quant-intro @x62 (= $x48 $x63)) (elim-unused (= $x63 true)) (= $x48 true))))
(let ((@x76 (trans (monotonicity @x69 (= $x51 (not true))) (rewrite (= (not true) false)) (= $x51 false))))
(let ((@x44 (monotonicity (rewrite (= (+ ?x30 1) ?x39)) (= (= (+ ?x30 1) ?x33) $x42))))
(let ((@x50 (quant-intro (monotonicity @x44 (= (not (= (+ ?x30 1) ?x33)) $x45)) (= $x36 $x48))))
(let ((@x53 (monotonicity @x50 (= $x37 $x51))))
(mp (asserted $x37) (trans @x53 @x76 (= $x37 false)) false)))))))))))))))))))

07f4cd3fa64b76806d385c4af8945a76e01f07d9 43 0
unsat
((set-logic AUFLIA)
(declare-fun ?v0!1 () Int)
(declare-fun ?v1!0 () Int)
(proof
(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 (($x73 (or (not (<= (+ ?v0!1 ?v1!0) 2)) (= (+ ?v0!1 ?v1!0) 2) (not (>= (+ ?v0!1 ?v1!0) 2)))))
(let (($x74 (not $x73)))
(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 (= $x73 (or $x84 $x87 $x93)))))
(let (($x60 (forall ((?v0 Int) (?v1 Int) )(! (let (($x41 (not (>= (+ ?v0 ?v1) 2))))
(let ((?x30 (+ ?v0 ?v1)))
(let (($x32 (= ?x30 2)))
(let (($x46 (not (<= ?x30 2))))
(or $x46 $x32 $x41))))) :qid k!4))
))
(let (($x63 (not $x60)))
(let (($x36 (forall ((?v0 Int) (?v1 Int) )(! (or (< 2 (+ ?v0 ?v1)) (or (= (+ ?v0 ?v1) 2) (< (+ ?v0 ?v1) 2))) :qid k!4))
))
(let (($x37 (not $x36)))
(let (($x41 (not (>= (+ ?1 ?0) 2))))
(let ((?x30 (+ ?1 ?0)))
(let (($x32 (= ?x30 2)))
(let (($x46 (not (<= ?x30 2))))
(let (($x55 (or $x46 $x32 $x41)))
(let (($x35 (or (< 2 ?x30) (or $x32 (< ?x30 2)))))
(let ((@x51 (monotonicity (rewrite (= (< ?x30 2) $x41)) (= (or $x32 (< ?x30 2)) (or $x32 $x41)))))
(let ((@x54 (monotonicity (rewrite (= (< 2 ?x30) $x46)) @x51 (= $x35 (or $x46 (or $x32 $x41))))))
(let ((@x59 (trans @x54 (rewrite (= (or $x46 (or $x32 $x41)) $x55)) (= $x35 $x55))))
(let ((@x66 (mp (asserted $x37) (monotonicity (quant-intro @x59 (= $x36 $x60)) (= $x37 $x63)) $x63)))
(let ((@x102 (mp (mp~ @x66 (sk (~ $x63 $x74)) $x74) (monotonicity @x98 (= $x74 (not (or $x84 $x87 $x93)))) (not (or $x84 $x87 $x93)))))
(let ((@x105 (not-or-elim @x102 (not $x87))))
(let ((@x106 (not-or-elim @x102 $x90)))
(let ((@x103 (not-or-elim @x102 $x81)))
(unit-resolution (unit-resolution ((_ th-lemma arith triangle-eq) (or $x87 $x84 $x93)) @x103 (or $x87 $x93)) @x106 @x105 false)))))))))))))))))))))))))))))))))

7f22e563ec1d8ce90ee01f0d4b366d5b595fcdef 46 0
unsat
((set-logic AUFLIA)
(declare-fun ?v0!0 () Int)
(proof
(let (($x86 (<= ?v0!0 (- 1))))
(let (($x87 (not $x86)))
(let (($x84 (>= ?v0!0 1)))
(let (($x83 (<= ?v0!0 0)))
(let (($x93 (not $x83)))
(let (($x85 (not $x84)))
(let (($x88 (ite $x83 $x85 $x87)))
(let (($x89 (not $x88)))
(let (($x73 (forall ((?v0 Int) )(! (let (($x58 (not (<= ?v0 (- 1)))))
(let (($x61 (not (>= ?v0 1))))
(ite (<= ?v0 0) $x61 $x58))) :qid k!4))
))
(let (($x76 (not $x73)))
(let (($x34 (forall ((?v0 Int) )(! (let (($x32 (< ?v0 1)))
(let (($x28 (< 0 ?v0)))
(ite $x28 (< 0 (+ ?v0 1)) $x32))) :qid k!4))
))
(let (($x35 (not $x34)))
(let (($x46 (forall ((?v0 Int) )(! (let (($x32 (< ?v0 1)))
(let (($x40 (< 0 (+ 1 ?v0))))
(let (($x28 (< 0 ?v0)))
(ite $x28 $x40 $x32)))) :qid k!4))
))
(let (($x58 (not (<= ?0 (- 1)))))
(let (($x61 (not (>= ?0 1))))
(let (($x68 (ite (<= ?0 0) $x61 $x58)))
(let (($x32 (< ?0 1)))
(let (($x40 (< 0 (+ 1 ?0))))
(let (($x28 (< 0 ?0)))
(let (($x43 (ite $x28 $x40 $x32)))
(let ((@x67 (monotonicity (rewrite (= $x28 (not (<= ?0 0)))) (rewrite (= $x40 $x58)) (rewrite (= $x32 $x61)) (= $x43 (ite (not (<= ?0 0)) $x58 $x61)))))
(let ((@x72 (trans @x67 (rewrite (= (ite (not (<= ?0 0)) $x58 $x61) $x68)) (= $x43 $x68))))
(let ((@x78 (monotonicity (quant-intro @x72 (= $x46 $x73)) (= (not $x46) $x76))))
(let ((@x42 (monotonicity (rewrite (= (+ ?0 1) (+ 1 ?0))) (= (< 0 (+ ?0 1)) $x40))))
(let ((@x45 (monotonicity @x42 (= (ite $x28 (< 0 (+ ?0 1)) $x32) $x43))))
(let ((@x51 (monotonicity (quant-intro @x45 (= $x34 $x46)) (= $x35 (not $x46)))))
(let ((@x92 (mp~ (mp (asserted $x35) (trans @x51 @x78 (= $x35 $x76)) $x76) (sk (~ $x76 $x89)) $x89)))
(let ((@x105 (unit-resolution (unit-resolution (def-axiom (or $x88 $x93 $x84)) @x92 (or $x93 $x84)) (hypothesis $x85) $x93)))
(let ((@x108 (unit-resolution ((_ th-lemma arith farkas 1 1) (or $x83 $x84)) @x105 (hypothesis $x85) false)))
(let ((@x109 (lemma @x108 $x84)))
(unit-resolution (unit-resolution (def-axiom (or $x88 $x83 $x86)) @x92 (or $x83 $x86)) (unit-resolution ((_ th-lemma arith farkas 1 1) (or $x93 $x85)) @x109 $x93) (unit-resolution ((_ th-lemma arith farkas 1 1) (or $x87 $x85)) @x109 $x87) false)))))))))))))))))))))))))))))))))

e566ad249d308c74a627c15c9f02c271a6843a42 31 0
unsat
((set-logic AUFLIA)
(proof
(let (($x56 (forall ((?v0 Int) )(! (let (($x50 (not (<= ?v0 0))))
(let (($x45 (not (>= ?v0 0))))
(or $x45 $x50))) :qid k!4))
))
(let (($x458 (not $x56)))
(let (($x153 (<= 0 0)))
(let (($x68 (not $x153)))
(let (($x158 (>= 0 0)))
(let (($x143 (not $x158)))
(let (($x154 (or $x143 $x68)))
(let (($x119 (or $x458 $x154)))
(let ((@x137 (trans (monotonicity (rewrite (= $x153 true)) (= $x68 (not true))) (rewrite (= (not true) false)) (= $x68 false))))
(let ((@x261 (trans (monotonicity (rewrite (= $x158 true)) (= $x143 (not true))) (rewrite (= (not true) false)) (= $x143 false))))
(let ((@x116 (trans (monotonicity @x261 @x137 (= $x154 (or false false))) (rewrite (= (or false false) false)) (= $x154 false))))
(let ((@x463 (trans (monotonicity @x116 (= $x119 (or $x458 false))) (rewrite (= (or $x458 false) $x458)) (= $x119 $x458))))
(let ((@x464 (mp ((_ quant-inst 0) $x119) @x463 $x458)))
(let (($x50 (not (<= ?0 0))))
(let (($x45 (not (>= ?0 0))))
(let (($x53 (or $x45 $x50)))
(let (($x31 (forall ((?v0 Int) )(! (or (< ?v0 0) (< 0 ?v0)) :qid k!4))
))
(let (($x33 (not (ite $x31 false true))))
(let ((@x55 (monotonicity (rewrite (= (< ?0 0) $x45)) (rewrite (= (< 0 ?0) $x50)) (= (or (< ?0 0) (< 0 ?0)) $x53))))
(let ((@x40 (monotonicity (rewrite (= (ite $x31 false true) (not $x31))) (= $x33 (not (not $x31))))))
(let ((@x60 (trans (trans @x40 (rewrite (= (not (not $x31)) $x31)) (= $x33 $x31)) (quant-intro @x55 (= $x31 $x56)) (= $x33 $x56))))
(let ((@x66 (mp~ (mp (asserted $x33) @x60 $x56) (nnf-pos (refl (~ $x53 $x53)) (~ $x56 $x56)) $x56)))
(unit-resolution @x66 @x464 false)))))))))))))))))))))))))

a02ae6c9688537bbe4c3be0d3dcebbc703417864 62 0
unsat
((set-logic AUFLIA)
(declare-fun ?v0!1 () Int)
(declare-fun z3name!0 () Bool)
(proof
(let ((?x96 (ite z3name!0 (- 1) 3)))
(let (($x99 (<= ?x96 0)))
(let (($x62 (forall ((?v0 Int) )(! (let (($x56 (not (<= ?v0 0))))
(let (($x51 (not (>= ?v0 0))))
(or $x51 $x56))) :qid k!4))
))
(let ((?x65 (ite $x62 (- 1) 3)))
(let (($x71 (<= ?x65 0)))
(let ((@x93 (intro-def (and (or (not z3name!0) $x62) (or z3name!0 (not $x62))))))
(let ((@x101 (monotonicity (monotonicity (apply-def @x93 (~ $x62 z3name!0)) (= ?x65 ?x96)) (= $x71 $x99))))
(let (($x31 (forall ((?v0 Int) )(! (or (< ?v0 0) (< 0 ?v0)) :qid k!4))
))
(let (($x37 (not (< 0 (ite $x31 (- 1) 3)))))
(let (($x56 (not (<= ?0 0))))
(let (($x51 (not (>= ?0 0))))
(let (($x59 (or $x51 $x56)))
(let ((@x61 (monotonicity (rewrite (= (< ?0 0) $x51)) (rewrite (= (< 0 ?0) $x56)) (= (or (< ?0 0) (< 0 ?0)) $x59))))
(let ((@x67 (monotonicity (quant-intro @x61 (= $x31 $x62)) (= (ite $x31 (- 1) 3) ?x65))))
(let ((@x70 (monotonicity @x67 (= (< 0 (ite $x31 (- 1) 3)) (< 0 ?x65)))))
(let ((@x76 (trans @x70 (rewrite (= (< 0 ?x65) (not $x71))) (= (< 0 (ite $x31 (- 1) 3)) (not $x71)))))
(let ((@x79 (monotonicity @x76 (= (not (< 0 (ite $x31 (- 1) 3))) (not (not $x71))))))
(let ((@x83 (trans @x79 (rewrite (= (not (not $x71)) $x71)) (= (not (< 0 (ite $x31 (- 1) 3))) $x71))))
(let ((?x42 (ite $x31 (- 1) 3)))
(let (($x45 (< 0 ?x42)))
(let ((@x44 (monotonicity (rewrite (= (- 1) (- 1))) (= (ite $x31 (- 1) 3) ?x42))))
(let ((@x50 (monotonicity (monotonicity @x44 (= (< 0 (ite $x31 (- 1) 3)) $x45)) (= $x37 (not $x45)))))
(let ((@x128 (mp (mp (asserted $x37) (trans @x50 @x83 (= $x37 $x71)) $x71) @x101 $x99)))
(let ((@x245 (unit-resolution ((_ th-lemma arith farkas 1 1) (or (not (>= ?x96 3)) (not $x99))) @x128 (not (>= ?x96 3)))))
(let (($x220 (= ?x96 3)))
(let (($x88 (not z3name!0)))
(let (($x90 (not $x62)))
(let (($x323 (<= 0 0)))
(let (($x533 (not $x323)))
(let (($x542 (>= 0 0)))
(let (($x179 (not $x542)))
(let (($x206 (or $x179 $x533)))
(let (($x529 (or $x90 $x206)))
(let ((@x527 (trans (monotonicity (rewrite (= $x323 true)) (= $x533 (not true))) (rewrite (= (not true) false)) (= $x533 false))))
(let ((@x200 (trans (monotonicity (rewrite (= $x542 true)) (= $x179 (not true))) (rewrite (= (not true) false)) (= $x179 false))))
(let ((@x528 (trans (monotonicity @x200 @x527 (= $x206 (or false false))) (rewrite (= (or false false) false)) (= $x206 false))))
(let ((@x237 (trans (monotonicity @x528 (= $x529 (or $x90 false))) (rewrite (= (or $x90 false) $x90)) (= $x529 $x90))))
(let ((@x238 (mp ((_ quant-inst 0) $x529) @x237 $x90)))
(let (($x89 (or $x88 $x62)))
(let (($x115 (<= ?v0!1 0)))
(let (($x116 (not $x115)))
(let (($x113 (>= ?v0!1 0)))
(let (($x114 (not $x113)))
(let (($x117 (or $x114 $x116)))
(let (($x118 (not $x117)))
(let (($x121 (or z3name!0 $x118)))
(let ((@x123 (monotonicity (refl (~ z3name!0 z3name!0)) (sk (~ $x90 $x118)) (~ (or z3name!0 $x90) $x121))))
(let ((@x109 (monotonicity (refl (~ $x88 $x88)) (nnf-pos (refl (~ $x59 $x59)) (~ $x62 $x62)) (~ $x89 $x89))))
(let ((@x126 (monotonicity @x109 @x123 (~ (and $x89 (or z3name!0 $x90)) (and $x89 $x121)))))
(let ((@x131 (and-elim (mp~ @x93 @x126 (and $x89 $x121)) $x89)))
(let ((@x515 (unit-resolution (def-axiom (or z3name!0 $x220)) (unit-resolution @x131 @x238 $x88) $x220)))
(unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x220) (>= ?x96 3))) @x515 @x245 false))))))))))))))))))))))))))))))))))))))))))))))))))))))

9853592ad3514c1450e40271884a9f21f57ff85b 39 0
unsat
((set-logic AUFLIA)
(proof
(let (($x38 (exists ((?v0 Int) (?v1 Int) (?v2 Int) )(! (let ((?x33 (- 6)))
(let ((?x34 (* ?x33 ?v1)))
(let ((?x31 (* 4 ?v0)))
(let ((?x35 (+ ?x31 ?x34)))
(= ?x35 1))))) :qid k!4))
))
(let (($x29 (not $x38)))
(let (($x39 (not $x29)))
(let (($x61 (exists ((?v0 Int) (?v1 Int) )(! (let ((?x58 (* (- 6) ?v1)))
(let ((?x57 (* 4 ?v0)))
(let ((?x59 (+ ?x57 ?x58)))
(= ?x59 1)))) :qid k!4))
))
(let (($x77 (exists ((?v0 Int) (?v1 Int) )(! false :qid k!4))
))
(let ((@x81 (quant-intro (rewrite (= (= (+ (* 4 ?1) (* (- 6) ?0)) 1) false)) (= $x61 $x77))))
(let ((@x85 (trans @x81 (elim-unused (= $x77 false)) (= $x61 false))))
(let (($x53 (exists ((?v0 Int) (?v1 Int) (?v2 Int) )(! (let ((?x44 (* (- 6) ?v1)))
(let ((?x31 (* 4 ?v0)))
(let ((?x47 (+ ?x31 ?x44)))
(= ?x47 1)))) :qid k!4))
))
(let ((?x44 (* (- 6) ?1)))
(let ((?x31 (* 4 ?2)))
(let ((?x47 (+ ?x31 ?x44)))
(let (($x50 (= ?x47 1)))
(let ((?x33 (- 6)))
(let ((?x34 (* ?x33 ?1)))
(let ((?x35 (+ ?x31 ?x34)))
(let (($x37 (= ?x35 1)))
(let ((@x49 (monotonicity (monotonicity (rewrite (= ?x33 (- 6))) (= ?x34 ?x44)) (= ?x35 ?x47))))
(let ((@x65 (trans (quant-intro (monotonicity @x49 (= $x37 $x50)) (= $x38 $x53)) (elim-unused (= $x53 $x61)) (= $x38 $x61))))
(let ((@x71 (monotonicity (monotonicity @x65 (= $x29 (not $x61))) (= $x39 (not (not $x61))))))
(let ((@x75 (trans @x71 (rewrite (= (not (not $x61)) $x61)) (= $x39 $x61))))
(mp (asserted $x39) (trans @x75 @x85 (= $x39 false)) false)))))))))))))))))))))))

7f619f54c20728881b08a920d22e08bbe3d76a4d 52 0
unsat
((set-logic AUFLIA)
(declare-fun ?v1!1 () Int)
(declare-fun ?v2!0 () Int)
(proof
(let ((?x105 (+ ?v2!0 ?v1!1)))
(let (($x106 (<= ?x105 0)))
(let (($x108 (or (not (and (not (<= ?v1!1 0)) (not (<= ?v2!0 0)))) (not $x106))))
(let (($x88 (forall ((?v1 Int) (?v2 Int) )(! (or (not (and (not (<= ?v1 0)) (not (<= ?v2 0)))) (not (<= (+ ?v2 ?v1) 0))) :qid k!4))
))
(let (($x91 (not $x88)))
(let (($x36 (exists ((?v0 Int) )(! (forall ((?v1 Int) (?v2 Int) )(! (let (($x31 (and (< 0 ?v1) (< 0 ?v2))))
(=> $x31 (< 0 (+ ?v1 ?v2)))) :qid k!4))
 :qid k!4))
))
(let (($x37 (not $x36)))
(let (($x54 (forall ((?v1 Int) (?v2 Int) )(! (let ((?x39 (+ ?v2 ?v1)))
(let (($x42 (< 0 ?x39)))
(or (not (and (< 0 ?v1) (< 0 ?v2))) $x42))) :qid k!4))
))
(let (($x85 (or (not (and (not (<= ?1 0)) (not (<= ?0 0)))) (not (<= (+ ?0 ?1) 0)))))
(let ((?x39 (+ ?0 ?1)))
(let (($x42 (< 0 ?x39)))
(let (($x49 (or (not (and (< 0 ?1) (< 0 ?0))) $x42)))
(let (($x79 (= (not (and (< 0 ?1) (< 0 ?0))) (not (and (not (<= ?1 0)) (not (<= ?0 0)))))))
(let (($x31 (and (< 0 ?1) (< 0 ?0))))
(let ((@x77 (monotonicity (rewrite (= (< 0 ?1) (not (<= ?1 0)))) (rewrite (= (< 0 ?0) (not (<= ?0 0)))) (= $x31 (and (not (<= ?1 0)) (not (<= ?0 0)))))))
(let ((@x87 (monotonicity (monotonicity @x77 $x79) (rewrite (= $x42 (not (<= ?x39 0)))) (= $x49 $x85))))
(let ((@x93 (monotonicity (quant-intro @x87 (= $x54 $x88)) (= (not $x54) $x91))))
(let (($x57 (exists ((?v0 Int) )(! (forall ((?v1 Int) (?v2 Int) )(! (let ((?x39 (+ ?v2 ?v1)))
(let (($x42 (< 0 ?x39)))
(or (not (and (< 0 ?v1) (< 0 ?v2))) $x42))) :qid k!4))
 :qid k!4))
))
(let (($x35 (forall ((?v1 Int) (?v2 Int) )(! (let (($x31 (and (< 0 ?v1) (< 0 ?v2))))
(=> $x31 (< 0 (+ ?v1 ?v2)))) :qid k!4))
))
(let ((@x44 (monotonicity (rewrite (= (+ ?1 ?0) ?x39)) (= (< 0 (+ ?1 ?0)) $x42))))
(let ((@x47 (monotonicity @x44 (= (=> $x31 (< 0 (+ ?1 ?0))) (=> $x31 $x42)))))
(let ((@x53 (trans @x47 (rewrite (= (=> $x31 $x42) $x49)) (= (=> $x31 (< 0 (+ ?1 ?0))) $x49))))
(let ((@x63 (trans (quant-intro (quant-intro @x53 (= $x35 $x54)) (= $x36 $x57)) (elim-unused (= $x57 $x54)) (= $x36 $x54))))
(let ((@x95 (trans (monotonicity @x63 (= $x37 (not $x54))) @x93 (= $x37 $x91))))
(let ((@x112 (mp~ (mp (asserted $x37) @x95 $x91) (sk (~ $x91 (not $x108))) (not $x108))))
(let ((@x118 (not-or-elim @x112 $x106)))
(let (($x99 (<= ?v1!1 0)))
(let (($x100 (not $x99)))
(let ((@x116 (and-elim (not-or-elim @x112 (and $x100 (not (<= ?v2!0 0)))) $x100)))
(let (($x101 (<= ?v2!0 0)))
(let (($x102 (not $x101)))
(let ((@x117 (and-elim (not-or-elim @x112 (and $x100 $x102)) $x102)))
((_ th-lemma arith farkas 1 1 1) @x117 @x116 @x118 false)))))))))))))))))))))))))))))))))))

9201a8009730b821ad6a3a2b64598e50ab5748ca 45 0
unsat
((set-logic AUFLIRA)
(declare-fun ?v1!1 () Int)
(declare-fun ?v2!0 () Real)
(proof
(let (($x105 (<= ?v1!1 (- 1))))
(let (($x107 (or (not (and (not (<= ?v1!1 0)) (not (<= ?v2!0 0.0)))) (not $x105))))
(let (($x88 (forall ((?v1 Int) (?v2 Real) )(! (or (not (and (not (<= ?v1 0)) (not (<= ?v2 0.0)))) (not (<= ?v1 (- 1)))) :qid k!4))
))
(let (($x91 (not $x88)))
(let (($x37 (exists ((?v0 Int) )(! (forall ((?v1 Int) (?v2 Real) )(! (let (($x31 (and (< 0 ?v1) (< 0.0 ?v2))))
(=> $x31 (< (- 1) ?v1))) :qid k!4))
 :qid k!4))
))
(let (($x27 (not $x37)))
(let (($x54 (forall ((?v1 Int) (?v2 Real) )(! (let (($x42 (< (- 1) ?v1)))
(or (not (and (< 0 ?v1) (< 0.0 ?v2))) $x42)) :qid k!4))
))
(let (($x85 (or (not (and (not (<= ?1 0)) (not (<= ?0 0.0)))) (not (<= ?1 (- 1))))))
(let (($x42 (< (- 1) ?1)))
(let (($x49 (or (not (and (< 0 ?1) (< 0.0 ?0))) $x42)))
(let (($x79 (= (not (and (< 0 ?1) (< 0.0 ?0))) (not (and (not (<= ?1 0)) (not (<= ?0 0.0)))))))
(let (($x31 (and (< 0 ?1) (< 0.0 ?0))))
(let ((@x77 (monotonicity (rewrite (= (< 0 ?1) (not (<= ?1 0)))) (rewrite (= (< 0.0 ?0) (not (<= ?0 0.0)))) (= $x31 (and (not (<= ?1 0)) (not (<= ?0 0.0)))))))
(let ((@x87 (monotonicity (monotonicity @x77 $x79) (rewrite (= $x42 (not (<= ?1 (- 1))))) (= $x49 $x85))))
(let ((@x93 (monotonicity (quant-intro @x87 (= $x54 $x88)) (= (not $x54) $x91))))
(let (($x57 (exists ((?v0 Int) )(! (forall ((?v1 Int) (?v2 Real) )(! (let (($x42 (< (- 1) ?v1)))
(or (not (and (< 0 ?v1) (< 0.0 ?v2))) $x42)) :qid k!4))
 :qid k!4))
))
(let (($x36 (forall ((?v1 Int) (?v2 Real) )(! (let (($x31 (and (< 0 ?v1) (< 0.0 ?v2))))
(=> $x31 (< (- 1) ?v1))) :qid k!4))
))
(let ((@x44 (monotonicity (rewrite (= (- 1) (- 1))) (= (< (- 1) ?1) $x42))))
(let ((@x47 (monotonicity @x44 (= (=> $x31 (< (- 1) ?1)) (=> $x31 $x42)))))
(let ((@x53 (trans @x47 (rewrite (= (=> $x31 $x42) $x49)) (= (=> $x31 (< (- 1) ?1)) $x49))))
(let ((@x63 (trans (quant-intro (quant-intro @x53 (= $x36 $x54)) (= $x37 $x57)) (elim-unused (= $x57 $x54)) (= $x37 $x54))))
(let ((@x95 (trans (monotonicity @x63 (= $x27 (not $x54))) @x93 (= $x27 $x91))))
(let ((@x111 (mp~ (mp (asserted $x27) @x95 $x91) (sk (~ $x91 (not $x107))) (not $x107))))
(let ((@x117 (not-or-elim @x111 $x105)))
(let (($x99 (<= ?v1!1 0)))
(let (($x100 (not $x99)))
(let ((@x115 (and-elim (not-or-elim @x111 (and $x100 (not (<= ?v2!0 0.0)))) $x100)))
(unit-resolution ((_ th-lemma arith farkas 1 1) (or (not $x105) $x99)) @x115 @x117 false))))))))))))))))))))))))))))))

d9fbfe5a894f4a224aaf7d1fa1f67325ad2e1497 110 0
unsat
((set-logic AUFLIA)
(proof
(let (($x152 (forall ((?v0 Int) )(! (let (($x68 (<= ?v0 0)))
(let (($x69 (not $x68)))
(let (($x143 (not false)))
(let (($x146 (or $x143 $x69)))
(not $x146))))) :qid k!4))
))
(let (($x174 (forall ((?v0 Int) )(! false :qid k!4))
))
(let (($x68 (<= ?0 0)))
(let (($x69 (not $x68)))
(let (($x143 (not false)))
(let (($x146 (or $x143 $x69)))
(let ((@x166 (trans (monotonicity (rewrite (= $x143 true)) (= $x146 (or true $x69))) (rewrite (= (or true $x69) true)) (= $x146 true))))
(let ((@x173 (trans (monotonicity @x166 (= (not $x146) (not true))) (rewrite (= (not true) false)) (= (not $x146) false))))
(let ((@x180 (trans (quant-intro @x173 (= $x152 $x174)) (elim-unused (= $x174 false)) (= $x152 false))))
(let (($x122 (forall ((?v0 Int) )(! (let (($x68 (<= ?v0 0)))
(let (($x69 (not $x68)))
(let (($x75 (forall ((?v1 Int) )(! (let (($x68 (<= ?v1 0)))
(let (($x69 (not $x68)))
(or (not (>= (+ ?v1 (* (- 1) ?v0)) 0)) $x69))) :qid k!4))
))
(let (($x78 (not $x75)))
(let (($x81 (or $x78 $x69)))
(not $x81)))))) :qid k!4))
))
(let (($x138 (forall ((?v0 Int) )(! (let (($x68 (<= ?v0 0)))
(let (($x69 (not $x68)))
(let (($x126 (forall ((?v1 Int) )(! (let (($x68 (<= ?v1 0)))
(not $x68)) :qid k!4))
))
(not (or (not $x126) $x69))))) :qid k!4))
))
(let ((@x156 (trans (rewrite (= $x122 $x138)) (rewrite (= $x138 $x152)) (= $x122 $x152))))
(let (($x116 (forall ((?v0 Int) )(! (let (($x68 (<= ?v0 0)))
(let (($x75 (forall ((?v1 Int) )(! (let (($x68 (<= ?v1 0)))
(let (($x69 (not $x68)))
(or (not (>= (+ ?v1 (* (- 1) ?v0)) 0)) $x69))) :qid k!4))
))
(and $x75 $x68))) :qid k!4))
))
(let (($x75 (forall ((?v1 Int) )(! (let (($x68 (<= ?v1 0)))
(let (($x69 (not $x68)))
(or (not (>= (+ ?v1 (* (- 1) ?0)) 0)) $x69))) :qid k!4))
))
(let (($x78 (not $x75)))
(let (($x81 (or $x78 $x69)))
(let (($x104 (not $x81)))
(let (($x113 (and $x75 $x68)))
(let (($x107 (forall ((?v0 Int) )(! (let (($x68 (<= ?v0 0)))
(let (($x69 (not $x68)))
(let (($x100 (not $x69)))
(let (($x75 (forall ((?v1 Int) )(! (let (($x68 (<= ?v1 0)))
(let (($x69 (not $x68)))
(or (not (>= (+ ?v1 (* (- 1) ?v0)) 0)) $x69))) :qid k!4))
))
(and $x75 $x100))))) :qid k!4))
))
(let ((@x115 (monotonicity (rewrite (= (not $x69) $x68)) (= (and $x75 (not $x69)) $x113))))
(let (($x84 (exists ((?v0 Int) )(! (let (($x68 (<= ?v0 0)))
(let (($x69 (not $x68)))
(let (($x75 (forall ((?v1 Int) )(! (let (($x68 (<= ?v1 0)))
(let (($x69 (not $x68)))
(or (not (>= (+ ?v1 (* (- 1) ?v0)) 0)) $x69))) :qid k!4))
))
(let (($x78 (not $x75)))
(or $x78 $x69))))) :qid k!4))
))
(let (($x87 (not $x84)))
(let (($x72 (or (not (>= (+ ?0 (* (- 1) ?1)) 0)) $x69)))
(let ((@x99 (nnf-neg (nnf-pos (refl (~ $x72 $x72)) (~ $x75 $x75)) (~ (not $x78) $x75))))
(let ((@x106 (nnf-neg @x99 (refl (~ (not $x69) (not $x69))) (~ $x104 (and $x75 (not $x69))))))
(let (($x34 (exists ((?v0 Int) )(! (let (($x30 (< 0 ?v0)))
(let (($x32 (forall ((?v1 Int) )(! (let (($x30 (< 0 ?v1)))
(let (($x29 (<= ?v0 ?v1)))
(=> $x29 $x30))) :qid k!4))
))
(=> $x32 $x30))) :qid k!4))
))
(let (($x35 (not $x34)))
(let (($x53 (exists ((?v0 Int) )(! (let (($x30 (< 0 ?v0)))
(let (($x41 (forall ((?v1 Int) )(! (let (($x30 (< 0 ?v1)))
(or (not (<= ?v0 ?v1)) $x30)) :qid k!4))
))
(or (not $x41) $x30))) :qid k!4))
))
(let (($x30 (< 0 ?0)))
(let (($x41 (forall ((?v1 Int) )(! (let (($x30 (< 0 ?v1)))
(or (not (<= ?0 ?v1)) $x30)) :qid k!4))
))
(let (($x48 (or (not $x41) $x30)))
(let ((@x67 (monotonicity (rewrite (= (<= ?1 ?0) (>= (+ ?0 (* (- 1) ?1)) 0))) (= (not (<= ?1 ?0)) (not (>= (+ ?0 (* (- 1) ?1)) 0))))))
(let ((@x74 (monotonicity @x67 (rewrite (= $x30 $x69)) (= (or (not (<= ?1 ?0)) $x30) $x72))))
(let ((@x80 (monotonicity (quant-intro @x74 (= $x41 $x75)) (= (not $x41) $x78))))
(let ((@x86 (quant-intro (monotonicity @x80 (rewrite (= $x30 $x69)) (= $x48 $x81)) (= $x53 $x84))))
(let (($x32 (forall ((?v1 Int) )(! (let (($x30 (< 0 ?v1)))
(let (($x29 (<= ?0 ?v1)))
(=> $x29 $x30))) :qid k!4))
))
(let (($x33 (=> $x32 $x30)))
(let ((@x40 (rewrite (= (=> (<= ?1 ?0) $x30) (or (not (<= ?1 ?0)) $x30)))))
(let ((@x46 (monotonicity (quant-intro @x40 (= $x32 $x41)) (= $x33 (=> $x41 $x30)))))
(let ((@x55 (quant-intro (trans @x46 (rewrite (= (=> $x41 $x30) $x48)) (= $x33 $x48)) (= $x34 $x53))))
(let ((@x91 (trans (monotonicity @x55 (= $x35 (not $x53))) (monotonicity @x86 (= (not $x53) $x87)) (= $x35 $x87))))
(let ((@x110 (mp~ (mp (asserted $x35) @x91 $x87) (nnf-neg @x106 (~ $x87 $x107)) $x107)))
(let ((@x125 (mp (mp @x110 (quant-intro @x115 (= $x107 $x116)) $x116) (quant-intro (rewrite (= $x113 $x104)) (= $x116 $x122)) $x122)))
(mp (mp @x125 @x156 $x152) @x180 false))))))))))))))))))))))))))))))))))))))))))))))

ae4f4fb9c10608b8e3b893cc6c99e3ec5d13a86c 23 0
unsat
((set-logic AUFLIA)
(declare-fun ?v1!0 () Int)
(proof
(let (($x64 (>= ?v1!0 1)))
(let (($x52 (forall ((?v1 Int) )(! (or (not (<= ?v1 0)) (not (>= ?v1 1))) :qid k!4))
))
(let (($x55 (not $x52)))
(let (($x33 (forall ((?v0 Int) (?v1 Int) )(! (or (< 0 ?v1) (< ?v1 1)) :qid k!4))
))
(let (($x27 (not $x33)))
(let (($x35 (forall ((?v1 Int) )(! (or (< 0 ?v1) (< ?v1 1)) :qid k!4))
))
(let (($x32 (or (< 0 ?0) (< ?0 1))))
(let ((@x51 (monotonicity (rewrite (= (< 0 ?0) (not (<= ?0 0)))) (rewrite (= (< ?0 1) (not (>= ?0 1)))) (= $x32 (or (not (<= ?0 0)) (not (>= ?0 1)))))))
(let ((@x57 (monotonicity (quant-intro @x51 (= $x35 $x52)) (= (not $x35) $x55))))
(let ((@x59 (trans (monotonicity (elim-unused (= $x33 $x35)) (= $x27 (not $x35))) @x57 (= $x27 $x55))))
(let ((@x70 (mp~ (mp (asserted $x27) @x59 $x55) (sk (~ $x55 (not (or (not (<= ?v1!0 0)) (not $x64))))) (not (or (not (<= ?v1!0 0)) (not $x64))))))
(let ((@x74 (not-or-elim @x70 $x64)))
(let (($x62 (<= ?v1!0 0)))
(let ((@x73 (not-or-elim @x70 $x62)))
(unit-resolution ((_ th-lemma arith farkas 1 1) (or (not $x62) (not $x64))) @x73 @x74 false)))))))))))))))))

d98ad8f668dead6f610669a52351ea0176a811b0 26 0
unsat
((set-logic <null>)
(proof
(let (($x58 (<= b$ 0)))
(let (($x62 (or (not (and (not (<= a$ 0)) (not (<= (* a$ b$) 0)))) (not $x58))))
(let (($x65 (not $x62)))
(let (($x35 (not (=> (and (< 0 a$) (< 0 (* a$ b$))) (< 0 b$)))))
(let (($x33 (< 0 b$)))
(let (($x38 (or (not (and (< 0 a$) (< 0 (* a$ b$)))) $x33)))
(let (($x56 (= (not (and (< 0 a$) (< 0 (* a$ b$)))) (not (and (not (<= a$ 0)) (not (<= (* a$ b$) 0)))))))
(let ((?x30 (* a$ b$)))
(let (($x48 (<= ?x30 0)))
(let (($x49 (not $x48)))
(let (($x44 (<= a$ 0)))
(let (($x45 (not $x44)))
(let (($x52 (and $x45 $x49)))
(let (($x32 (and (< 0 a$) (< 0 ?x30))))
(let ((@x54 (monotonicity (rewrite (= (< 0 a$) $x45)) (rewrite (= (< 0 ?x30) $x49)) (= $x32 $x52))))
(let ((@x64 (monotonicity (monotonicity @x54 $x56) (rewrite (= $x33 (not $x58))) (= $x38 $x62))))
(let ((@x43 (monotonicity (rewrite (= (=> $x32 $x33) $x38)) (= $x35 (not $x38)))))
(let ((@x69 (trans @x43 (monotonicity @x64 (= (not $x38) $x65)) (= $x35 $x65))))
(let ((@x74 (not-or-elim (mp (asserted $x35) @x69 $x65) $x58)))
(let ((@x72 (and-elim (not-or-elim (mp (asserted $x35) @x69 $x65) $x52) $x45)))
(let ((@x73 (and-elim (not-or-elim (mp (asserted $x35) @x69 $x65) $x52) $x49)))
((_ th-lemma arith farkas 1 1 1) @x73 @x72 @x74 false))))))))))))))))))))))))

271390ea915947de195c2202e30f90bb84689d60 26 0
unsat
((set-logic <null>)
(proof
(let ((?x35 (+ y$ 1)))
(let ((?x36 (* a$ ?x35)))
(let ((?x34 (* a$ x$)))
(let ((?x37 (+ ?x34 ?x36)))
(let ((?x30 (+ x$ 1)))
(let ((?x32 (+ ?x30 y$)))
(let ((?x33 (* a$ ?x32)))
(let (($x38 (= ?x33 ?x37)))
(let (($x39 (not $x38)))
(let (($x82 (= (= (+ a$ ?x34 (* a$ y$)) (+ a$ ?x34 (* a$ y$))) true)))
(let (($x80 (= $x38 (= (+ a$ ?x34 (* a$ y$)) (+ a$ ?x34 (* a$ y$))))))
(let ((@x76 (rewrite (= (+ ?x34 (+ a$ (* a$ y$))) (+ a$ ?x34 (* a$ y$))))))
(let ((@x66 (monotonicity (rewrite (= ?x35 (+ 1 y$))) (= ?x36 (* a$ (+ 1 y$))))))
(let ((@x71 (trans @x66 (rewrite (= (* a$ (+ 1 y$)) (+ a$ (* a$ y$)))) (= ?x36 (+ a$ (* a$ y$))))))
(let ((@x78 (trans (monotonicity @x71 (= ?x37 (+ ?x34 (+ a$ (* a$ y$))))) @x76 (= ?x37 (+ a$ ?x34 (* a$ y$))))))
(let ((@x58 (rewrite (= (* a$ (+ 1 x$ y$)) (+ a$ ?x34 (* a$ y$))))))
(let ((@x46 (monotonicity (rewrite (= ?x30 (+ 1 x$))) (= ?x32 (+ (+ 1 x$) y$)))))
(let ((@x51 (trans @x46 (rewrite (= (+ (+ 1 x$) y$) (+ 1 x$ y$))) (= ?x32 (+ 1 x$ y$)))))
(let ((@x60 (trans (monotonicity @x51 (= ?x33 (* a$ (+ 1 x$ y$)))) @x58 (= ?x33 (+ a$ ?x34 (* a$ y$))))))
(let ((@x88 (monotonicity (trans (monotonicity @x60 @x78 $x80) (rewrite $x82) (= $x38 true)) (= $x39 (not true)))))
(let ((@x92 (trans @x88 (rewrite (= (not true) false)) (= $x39 false))))
(mp (asserted $x39) @x92 false))))))))))))))))))))))))

b216c79478e44396acca3654b76845499fc18a04 23 0
unsat
((set-logic <null>)
(proof
(let ((?x36 (* 2.0 x$)))
(let ((?x37 (* ?x36 y$)))
(let ((?x32 (- 1.0 y$)))
(let ((?x33 (* x$ ?x32)))
(let ((?x30 (+ 1.0 y$)))
(let ((?x31 (* x$ ?x30)))
(let ((?x34 (- ?x31 ?x33)))
(let (($x38 (= ?x34 ?x37)))
(let (($x39 (not $x38)))
(let ((@x73 (rewrite (= (= (* 2.0 (* x$ y$)) (* 2.0 (* x$ y$))) true))))
(let ((?x41 (* x$ y$)))
(let ((?x63 (* 2.0 ?x41)))
(let ((@x56 (rewrite (= (* x$ (+ 1.0 (* (- 1.0) y$))) (+ x$ (* (- 1.0) ?x41))))))
(let ((@x52 (monotonicity (rewrite (= ?x32 (+ 1.0 (* (- 1.0) y$)))) (= ?x33 (* x$ (+ 1.0 (* (- 1.0) y$)))))))
(let ((@x61 (monotonicity (rewrite (= ?x31 (+ x$ ?x41))) (trans @x52 @x56 (= ?x33 (+ x$ (* (- 1.0) ?x41)))) (= ?x34 (- (+ x$ ?x41) (+ x$ (* (- 1.0) ?x41)))))))
(let ((@x66 (trans @x61 (rewrite (= (- (+ x$ ?x41) (+ x$ (* (- 1.0) ?x41))) ?x63)) (= ?x34 ?x63))))
(let ((@x75 (trans (monotonicity @x66 (rewrite (= ?x37 ?x63)) (= $x38 (= ?x63 ?x63))) @x73 (= $x38 true))))
(let ((@x82 (trans (monotonicity @x75 (= $x39 (not true))) (rewrite (= (not true) false)) (= $x39 false))))
(mp (asserted $x39) @x82 false)))))))))))))))))))))

9df6daf3cc37f0807bf370ee01536b85d300ecce 51 0
unsat
((set-logic <null>)
(proof
(let ((?x47 (+ b$ d$)))
(let ((?x48 (+ ?x47 e$)))
(let ((?x30 (+ 1 p$)))
(let ((?x49 (* ?x30 ?x48)))
(let ((?x44 (* d$ p$)))
(let ((?x42 (* ?x30 d$)))
(let ((?x33 (+ b$ e$)))
(let ((?x40 (* 2 ?x30)))
(let ((?x41 (* ?x40 ?x33)))
(let ((?x43 (+ ?x41 ?x42)))
(let ((?x45 (+ ?x43 ?x44)))
(let ((?x46 (+ u$ ?x45)))
(let ((?x50 (- ?x46 ?x49)))
(let ((?x37 (* p$ d$)))
(let ((?x34 (* ?x30 ?x33)))
(let ((?x35 (+ u$ ?x34)))
(let ((?x38 (+ ?x35 ?x37)))
(let (($x51 (= ?x38 ?x50)))
(let (($x52 (not $x51)))
(let ((?x55 (* p$ e$)))
(let ((?x54 (* p$ b$)))
(let ((?x70 (+ u$ b$ e$ ?x37 ?x54 ?x55)))
(let ((?x127 (+ b$ e$ d$ ?x37 ?x54 ?x55)))
(let ((?x85 (* 2 ?x55)))
(let ((?x83 (* 2 ?x54)))
(let ((?x84 (* 2 e$)))
(let ((?x82 (* 2 b$)))
(let ((?x116 (+ u$ ?x82 ?x84 d$ (* 2 ?x37) ?x83 ?x85)))
(let ((@x126 (monotonicity (rewrite (= ?x48 (+ b$ e$ d$))) (= ?x49 (* ?x30 (+ b$ e$ d$))))))
(let ((@x131 (trans @x126 (rewrite (= (* ?x30 (+ b$ e$ d$)) ?x127)) (= ?x49 ?x127))))
(let ((@x118 (rewrite (= (+ u$ (+ ?x82 ?x84 d$ (* 2 ?x37) ?x83 ?x85)) ?x116))))
(let ((?x108 (+ ?x82 ?x84 d$ (* 2 ?x37) ?x83 ?x85)))
(let ((?x97 (+ ?x82 ?x84 d$ ?x37 ?x83 ?x85)))
(let ((@x88 (rewrite (= (* (+ 2 (* 2 p$)) ?x33) (+ ?x82 ?x84 ?x83 ?x85)))))
(let ((@x81 (monotonicity (rewrite (= ?x40 (+ 2 (* 2 p$)))) (= ?x41 (* (+ 2 (* 2 p$)) ?x33)))))
(let ((@x96 (monotonicity (trans @x81 @x88 (= ?x41 (+ ?x82 ?x84 ?x83 ?x85))) (rewrite (= ?x42 (+ d$ ?x37))) (= ?x43 (+ (+ ?x82 ?x84 ?x83 ?x85) (+ d$ ?x37))))))
(let ((@x101 (trans @x96 (rewrite (= (+ (+ ?x82 ?x84 ?x83 ?x85) (+ d$ ?x37)) ?x97)) (= ?x43 ?x97))))
(let ((@x112 (trans (monotonicity @x101 (rewrite (= ?x44 ?x37)) (= ?x45 (+ ?x97 ?x37))) (rewrite (= (+ ?x97 ?x37) ?x108)) (= ?x45 ?x108))))
(let ((@x120 (trans (monotonicity @x112 (= ?x46 (+ u$ ?x108))) @x118 (= ?x46 ?x116))))
(let ((@x139 (trans (monotonicity @x120 @x131 (= ?x50 (- ?x116 ?x127))) (rewrite (= (- ?x116 ?x127) ?x70)) (= ?x50 ?x70))))
(let ((@x64 (rewrite (= (+ u$ (+ b$ e$ ?x54 ?x55)) (+ u$ b$ e$ ?x54 ?x55)))))
(let ((@x61 (monotonicity (rewrite (= ?x34 (+ b$ e$ ?x54 ?x55))) (= ?x35 (+ u$ (+ b$ e$ ?x54 ?x55))))))
(let ((@x69 (monotonicity (trans @x61 @x64 (= ?x35 (+ u$ b$ e$ ?x54 ?x55))) (= ?x38 (+ (+ u$ b$ e$ ?x54 ?x55) ?x37)))))
(let ((@x74 (trans @x69 (rewrite (= (+ (+ u$ b$ e$ ?x54 ?x55) ?x37) ?x70)) (= ?x38 ?x70))))
(let ((@x145 (trans (monotonicity @x74 @x139 (= $x51 (= ?x70 ?x70))) (rewrite (= (= ?x70 ?x70) true)) (= $x51 true))))
(let ((@x152 (trans (monotonicity @x145 (= $x52 (not true))) (rewrite (= (not true) false)) (= $x52 false))))
(mp (asserted $x52) @x152 false)))))))))))))))))))))))))))))))))))))))))))))))))

5e90e9139eb4e9a7c2678bca8dda6cda05861f4c 23 0
unsat
((set-logic AUFLIA)
(proof
(let (($x40 (= x$ a$)))
(let ((?x36 (pair$ x$ y$)))
(let ((?x37 (fst$ ?x36)))
(let (($x39 (= ?x37 a$)))
(let ((@x50 (monotonicity (rewrite (= (=> $x39 $x40) (or (not $x39) $x40))) (= (not (=> $x39 $x40)) (not (or (not $x39) $x40))))))
(let ((@x51 (not-or-elim (mp (asserted (not (=> $x39 $x40))) @x50 (not (or (not $x39) $x40))) $x39)))
(let (($x56 (= ?x37 x$)))
(let (($x478 (forall ((?v0 A$) (?v1 B$) )(! (= (fst$ (pair$ ?v0 ?v1)) ?v0) :pattern ( (pair$ ?v0 ?v1) ) :qid k!12))
))
(let (($x32 (forall ((?v0 A$) (?v1 B$) )(! (= (fst$ (pair$ ?v0 ?v1)) ?v0) :qid k!12))
))
(let (($x31 (= (fst$ (pair$ ?1 ?0)) ?1)))
(let ((@x55 (mp~ (asserted $x32) (nnf-pos (refl (~ $x31 $x31)) (~ $x32 $x32)) $x32)))
(let ((@x483 (mp @x55 (quant-intro (refl (= $x31 $x31)) (= $x32 $x478)) $x478)))
(let (($x62 (or (not $x478) $x56)))
(let ((@x149 ((_ quant-inst x$ y$) $x62)))
(let ((@x150 (trans (symm (unit-resolution @x149 @x483 $x56) (= x$ ?x37)) @x51 $x40)))
(let ((@x54 (not-or-elim (mp (asserted (not (=> $x39 $x40))) @x50 (not (or (not $x39) $x40))) (not $x40))))
(unit-resolution @x54 @x150 false)))))))))))))))))))

53d3d89ffb6e574b15fcea58a111b4eecba9beb5 42 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x59 (snd$a p2$)))
(let ((?x58 (fst$a p1$)))
(let (($x60 (= ?x58 ?x59)))
(let ((?x55 (pair$ y$ x$)))
(let (($x56 (= p2$ ?x55)))
(let ((?x52 (pair$a x$ y$)))
(let (($x53 (= p1$ ?x52)))
(let (($x57 (and $x53 $x56)))
(let ((@x70 (monotonicity (rewrite (= (=> $x57 $x60) (or (not $x57) $x60))) (= (not (=> $x57 $x60)) (not (or (not $x57) $x60))))))
(let ((@x71 (not-or-elim (mp (asserted (not (=> $x57 $x60))) @x70 (not (or (not $x57) $x60))) $x57)))
(let ((@x74 (and-elim @x71 $x56)))
(let ((@x504 (symm (monotonicity @x74 (= ?x59 (snd$a ?x55))) (= (snd$a ?x55) ?x59))))
(let ((?x100 (snd$a ?x55)))
(let (($x185 (= ?x100 x$)))
(let (($x534 (forall ((?v0 B$) (?v1 A$) )(! (= (snd$a (pair$ ?v0 ?v1)) ?v1) :pattern ( (pair$ ?v0 ?v1) ) :qid k!21))
))
(let (($x47 (forall ((?v0 B$) (?v1 A$) )(! (= (snd$a (pair$ ?v0 ?v1)) ?v1) :qid k!21))
))
(let (($x46 (= (snd$a (pair$ ?1 ?0)) ?0)))
(let ((@x96 (mp~ (asserted $x47) (nnf-pos (refl (~ $x46 $x46)) (~ $x47 $x47)) $x47)))
(let ((@x539 (mp @x96 (quant-intro (refl (= $x46 $x46)) (= $x47 $x534)) $x534)))
(let (($x190 (or (not $x534) $x185)))
(let ((@x191 ((_ quant-inst y$ x$) $x190)))
(let ((?x187 (fst$a ?x52)))
(let (($x188 (= ?x187 x$)))
(let (($x522 (forall ((?v0 A$) (?v1 B$) )(! (= (fst$a (pair$a ?v0 ?v1)) ?v0) :pattern ( (pair$a ?v0 ?v1) ) :qid k!19))
))
(let (($x39 (forall ((?v0 A$) (?v1 B$) )(! (= (fst$a (pair$a ?v0 ?v1)) ?v0) :qid k!19))
))
(let (($x38 (= (fst$a (pair$a ?1 ?0)) ?1)))
(let ((@x90 (mp~ (asserted $x39) (nnf-pos (refl (~ $x38 $x38)) (~ $x39 $x39)) $x39)))
(let ((@x527 (mp @x90 (quant-intro (refl (= $x38 $x38)) (= $x39 $x522)) $x522)))
(let (($x162 (or (not $x522) $x188)))
(let ((@x292 ((_ quant-inst x$ y$) $x162)))
(let ((@x505 (trans (monotonicity (and-elim @x71 $x53) (= ?x58 ?x187)) (unit-resolution @x292 @x527 $x188) (= ?x58 x$))))
(let ((@x489 (trans @x505 (symm (unit-resolution @x191 @x539 $x185) (= x$ ?x100)) (= ?x58 ?x100))))
(let ((@x76 (not-or-elim (mp (asserted (not (=> $x57 $x60))) @x70 (not (or (not $x57) $x60))) (not $x60))))
(unit-resolution @x76 (trans @x489 @x504 $x60) false))))))))))))))))))))))))))))))))))))

f501ac3814a9ff559897f8057e18657ad1030d2a 60 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x69 (fun_app$ f$ i$)))
(let ((?x60 (fun_upd$ f$)))
(let ((?x61 (fun_app$b ?x60 i1$)))
(let ((?x63 (fun_app$a ?x61 v1$)))
(let ((?x64 (fun_upd$ ?x63)))
(let ((?x65 (fun_app$b ?x64 i2$)))
(let ((?x67 (fun_app$a ?x65 v2$)))
(let ((?x68 (fun_app$ ?x67 i$)))
(let (($x70 (= ?x68 ?x69)))
(let ((?x197 (fun_app$ ?x63 i$)))
(let (($x205 (= ?x197 ?x69)))
(let (($x204 (= ?x197 v1$)))
(let (($x53 (= i$ i1$)))
(let (($x484 (ite $x53 $x204 $x205)))
(let (($x531 (forall ((?v0 A_b_fun$) (?v1 A$) (?v2 B$) (?v3 A$) )(! (let ((?x46 (fun_app$ ?v0 ?v3)))
(let ((?x44 (fun_app$ (fun_app$a (fun_app$b (fun_upd$ ?v0) ?v1) ?v2) ?v3)))
(let (($x45 (= ?v3 ?v1)))
(ite $x45 (= ?x44 ?v2) (= ?x44 ?x46))))) :pattern ( (fun_app$ (fun_app$a (fun_app$b (fun_upd$ ?v0) ?v1) ?v2) ?v3) ) :qid k!20))
))
(let (($x102 (forall ((?v0 A_b_fun$) (?v1 A$) (?v2 B$) (?v3 A$) )(! (let ((?x46 (fun_app$ ?v0 ?v3)))
(let ((?x44 (fun_app$ (fun_app$a (fun_app$b (fun_upd$ ?v0) ?v1) ?v2) ?v3)))
(let (($x45 (= ?v3 ?v1)))
(ite $x45 (= ?x44 ?v2) (= ?x44 ?x46))))) :qid k!20))
))
(let ((?x46 (fun_app$ ?3 ?0)))
(let ((?x44 (fun_app$ (fun_app$a (fun_app$b (fun_upd$ ?3) ?2) ?1) ?0)))
(let (($x45 (= ?0 ?2)))
(let (($x97 (ite $x45 (= ?x44 ?1) (= ?x44 ?x46))))
(let (($x49 (forall ((?v0 A_b_fun$) (?v1 A$) (?v2 B$) (?v3 A$) )(! (let ((?x44 (fun_app$ (fun_app$a (fun_app$b (fun_upd$ ?v0) ?v1) ?v2) ?v3)))
(= ?x44 (ite (= ?v3 ?v1) ?v2 (fun_app$ ?v0 ?v3)))) :qid k!20))
))
(let ((@x104 (quant-intro (rewrite (= (= ?x44 (ite $x45 ?1 ?x46)) $x97)) (= $x49 $x102))))
(let ((@x91 (refl (~ (= ?x44 (ite $x45 ?1 ?x46)) (= ?x44 (ite $x45 ?1 ?x46))))))
(let ((@x105 (mp (mp~ (asserted $x49) (nnf-pos @x91 (~ $x49 $x49)) $x49) @x104 $x102)))
(let ((@x536 (mp @x105 (quant-intro (refl (= $x97 $x97)) (= $x102 $x531)) $x531)))
(let (($x171 (not $x531)))
(let (($x486 (or $x171 $x484)))
(let ((@x487 ((_ quant-inst f$ i1$ v1$ i$) $x486)))
(let (($x54 (not $x53)))
(let (($x56 (= i$ i2$)))
(let (($x57 (not $x56)))
(let (($x58 (and $x54 $x57)))
(let ((@x80 (monotonicity (rewrite (= (=> $x58 $x70) (or (not $x58) $x70))) (= (not (=> $x58 $x70)) (not (or (not $x58) $x70))))))
(let ((@x81 (not-or-elim (mp (asserted (not (=> $x58 $x70))) @x80 (not (or (not $x58) $x70))) $x58)))
(let ((@x82 (and-elim @x81 $x54)))
(let ((@x321 (unit-resolution (def-axiom (or (not $x484) $x53 $x205)) @x82 (or (not $x484) $x205))))
(let (($x200 (= ?x68 ?x197)))
(let (($x196 (= ?x68 v2$)))
(let (($x179 (ite $x56 $x196 $x200)))
(let (($x301 (or $x171 $x179)))
(let ((@x511 ((_ quant-inst (fun_app$a ?x61 v1$) i2$ v2$ i$) $x301)))
(let ((@x84 (and-elim @x81 $x57)))
(let ((@x466 (unit-resolution (def-axiom (or (not $x179) $x56 $x200)) @x84 (or (not $x179) $x200))))
(let ((@x470 (trans (unit-resolution @x466 (unit-resolution @x511 @x536 $x179) $x200) (unit-resolution @x321 (unit-resolution @x487 @x536 $x484) $x205) $x70)))
(let ((@x86 (not-or-elim (mp (asserted (not (=> $x58 $x70))) @x80 (not (or (not $x58) $x70))) (not $x70))))
(unit-resolution @x86 @x470 false))))))))))))))))))))))))))))))))))))))))))))))))

541ab286f481dab3994e7cef5aa3ab01f0d6487a 24 0
unsat
((set-logic AUFLIA)
(proof
(let (($x29 (f$ g$ x$)))
(let (($x73 (not $x29)))
(let (($x65 (not (or (= $x29 (fun_app$ g$ x$)) $x29 (fun_app$ g$ x$)))))
(let (($x32 (= $x29 (and (fun_app$ g$ x$) true))))
(let (($x37 (not (or $x32 (or (= $x29 true) (= (fun_app$ g$ x$) true))))))
(let (($x30 (fun_app$ g$ x$)))
(let (($x44 (= $x29 $x30)))
(let (($x56 (or $x44 (or $x29 $x30))))
(let ((@x67 (monotonicity (rewrite (= $x56 (or $x44 $x29 $x30))) (= (not $x56) $x65))))
(let ((@x55 (monotonicity (rewrite (= (= $x29 true) $x29)) (rewrite (= (= $x30 true) $x30)) (= (or (= $x29 true) (= $x30 true)) (or $x29 $x30)))))
(let ((@x43 (monotonicity (rewrite (= (and $x30 true) $x30)) (= $x32 (= $x29 $x30)))))
(let ((@x58 (monotonicity (trans @x43 (rewrite (= (= $x29 $x30) $x44)) (= $x32 $x44)) @x55 (= (or $x32 (or (= $x29 true) (= $x30 true))) $x56))))
(let ((@x69 (trans (monotonicity @x58 (= $x37 (not $x56))) @x67 (= $x37 $x65))))
(let ((@x70 (mp (asserted $x37) @x69 $x65)))
(let ((@x87 (monotonicity (iff-false (not-or-elim @x70 (not $x30)) (= $x30 false)) (= (= $x73 $x30) (= $x73 false)))))
(let ((@x91 (trans @x87 (rewrite (= (= $x73 false) $x29)) (= (= $x73 $x30) $x29))))
(let ((@x93 (trans @x91 (iff-false (not-or-elim @x70 $x73) (= $x29 false)) (= (= $x73 $x30) false))))
(let (($x77 (= $x73 $x30)))
(let ((@x80 (mp (not-or-elim @x70 (not $x44)) (rewrite (= (not $x44) $x77)) $x77)))
(mp @x80 @x93 false))))))))))))))))))))))

c6761b6a026c6bf2d28c35e9faf633fc441c84c5 45 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x44 (id$ x$)))
(let (($x46 (= ?x44 x$)))
(let (($x73 (not $x46)))
(let (($x47 (id$a true)))
(let (($x510 (forall ((?v0 Bool) )(! (let (($x33 (id$a ?v0)))
(= $x33 ?v0)) :pattern ( (id$a ?v0) ) :qid k!9))
))
(let (($x40 (forall ((?v0 Bool) )(! (let (($x33 (id$a ?v0)))
(= $x33 ?v0)) :qid k!9))
))
(let ((@x514 (quant-intro (refl (= (= (id$a ?0) ?0) (= (id$a ?0) ?0))) (= $x40 $x510))))
(let ((@x69 (nnf-pos (refl (~ (= (id$a ?0) ?0) (= (id$a ?0) ?0))) (~ $x40 $x40))))
(let (($x35 (forall ((?v0 Bool) )(! (let (($x33 (id$a ?v0)))
(= $x33 ?v0)) :qid k!9))
))
(let ((@x42 (quant-intro (rewrite (= (= (id$a ?0) ?0) (= (id$a ?0) ?0))) (= $x35 $x40))))
(let ((@x515 (mp (mp~ (mp (asserted $x35) @x42 $x40) @x69 $x40) @x514 $x510)))
(let (($x87 (or (not $x510) $x47)))
(let ((@x176 (monotonicity (rewrite (= (= $x47 true) $x47)) (= (or (not $x510) (= $x47 true)) $x87))))
(let ((@x179 (trans @x176 (rewrite (= $x87 $x87)) (= (or (not $x510) (= $x47 true)) $x87))))
(let ((@x495 (unit-resolution (mp ((_ quant-inst true) (or (not $x510) (= $x47 true))) @x179 $x87) @x515 (hypothesis (not $x47)) false)))
(let (($x71 (or $x73 (not $x47))))
(let ((@x79 (monotonicity (rewrite (= (and $x46 $x47) (not $x71))) (= (not (and $x46 $x47)) (not (not $x71))))))
(let ((@x83 (trans @x79 (rewrite (= (not (not $x71)) $x71)) (= (not (and $x46 $x47)) $x71))))
(let (($x54 (and $x46 $x47)))
(let (($x57 (not $x54)))
(let ((@x56 (monotonicity (rewrite (= (= $x47 true) $x47)) (= (and $x46 (= $x47 true)) $x54))))
(let ((@x62 (mp (asserted (not (and $x46 (= $x47 true)))) (monotonicity @x56 (= (not (and $x46 (= $x47 true))) $x57)) $x57)))
(let ((@x84 (mp @x62 @x83 $x71)))
(let (($x503 (forall ((?v0 A$) )(! (let ((?x28 (id$ ?v0)))
(= ?x28 ?v0)) :pattern ( (id$ ?v0) ) :qid k!8))
))
(let (($x30 (forall ((?v0 A$) )(! (let ((?x28 (id$ ?v0)))
(= ?x28 ?v0)) :qid k!8))
))
(let ((@x507 (quant-intro (refl (= (= (id$ ?0) ?0) (= (id$ ?0) ?0))) (= $x30 $x503))))
(let ((@x64 (nnf-pos (refl (~ (= (id$ ?0) ?0) (= (id$ ?0) ?0))) (~ $x30 $x30))))
(let ((@x508 (mp (mp~ (asserted $x30) @x64 $x30) @x507 $x503)))
(let (($x163 (or (not $x503) $x46)))
(let ((@x496 ((_ quant-inst x$) $x163)))
(unit-resolution @x496 @x508 (unit-resolution @x84 (lemma @x495 $x47) $x73) false)))))))))))))))))))))))))))))))))

50e0d27d5994794dc9d5826e8afa4b3217acf731 14 0
unsat
((set-logic AUFLIA)
(proof
(let (($x29 (exists ((?v0 A$) )(! (g$ ?v0) :qid k!7))
))
(let (($x30 (ite $x29 true false)))
(let (($x31 (f$ $x30)))
(let (($x32 (=> $x31 true)))
(let (($x33 (not $x32)))
(let ((@x42 (monotonicity (monotonicity (rewrite (= $x30 $x29)) (= $x31 (f$ $x29))) (= $x32 (=> (f$ $x29) true)))))
(let ((@x46 (trans @x42 (rewrite (= (=> (f$ $x29) true) true)) (= $x32 true))))
(let ((@x53 (trans (monotonicity @x46 (= $x33 (not true))) (rewrite (= (not true) false)) (= $x33 false))))
(mp (asserted $x33) @x53 false)))))))))))

8b09776b03122aeacc9dd9526e1f0e5d41a07f14 14 0
unsat
((set-logic AUFLIA)
(proof
(let (($x29 (forall ((?v0 A$) )(! (g$ ?v0) :qid k!7))
))
(let (($x30 (ite $x29 true false)))
(let (($x31 (f$ $x30)))
(let (($x32 (=> $x31 true)))
(let (($x33 (not $x32)))
(let ((@x42 (monotonicity (monotonicity (rewrite (= $x30 $x29)) (= $x31 (f$ $x29))) (= $x32 (=> (f$ $x29) true)))))
(let ((@x46 (trans @x42 (rewrite (= (=> (f$ $x29) true) true)) (= $x32 true))))
(let ((@x53 (trans (monotonicity @x46 (= $x33 (not true))) (rewrite (= (not true) false)) (= $x33 false))))
(mp (asserted $x33) @x53 false)))))))))))

feaa6ef662dd489cf55f86209489c2992ff08d28 46 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x61 (fun_app$a le$ 3)))
(let (($x63 (fun_app$ ?x61 42)))
(let (($x75 (not $x63)))
(let (($x59 (= le$ uu$)))
(let ((@x73 (monotonicity (rewrite (= (=> $x59 $x63) (or (not $x59) $x63))) (= (not (=> $x59 $x63)) (not (or (not $x59) $x63))))))
(let ((@x74 (not-or-elim (mp (asserted (not (=> $x59 $x63))) @x73 (not (or (not $x59) $x63))) $x59)))
(let ((@x482 (monotonicity (symm @x74 (= uu$ le$)) (= (fun_app$a uu$ 3) ?x61))))
(let ((@x484 (symm (monotonicity @x482 (= (fun_app$ (fun_app$a uu$ 3) 42) $x63)) (= $x63 (fun_app$ (fun_app$a uu$ 3) 42)))))
(let ((@x472 (monotonicity @x484 (= $x75 (not (fun_app$ (fun_app$a uu$ 3) 42))))))
(let ((@x77 (not-or-elim (mp (asserted (not (=> $x59 $x63))) @x73 (not (or (not $x59) $x63))) $x75)))
(let ((?x79 (fun_app$a uu$ 3)))
(let (($x168 (fun_app$ ?x79 42)))
(let (($x52 (forall ((?v0 Int) (?v1 Int) )(! (let (($x46 (<= (+ ?v0 (* (- 1) ?v1)) 0)))
(let (($x31 (fun_app$ (fun_app$a uu$ ?v0) ?v1)))
(= $x31 $x46))) :pattern ( (fun_app$ (fun_app$a uu$ ?v0) ?v1) ) :qid k!10))
))
(let (($x46 (<= (+ ?1 (* (- 1) ?0)) 0)))
(let (($x31 (fun_app$ (fun_app$a uu$ ?1) ?0)))
(let (($x49 (= $x31 $x46)))
(let (($x35 (forall ((?v0 Int) (?v1 Int) )(! (let (($x32 (<= ?v0 ?v1)))
(let (($x31 (fun_app$ (fun_app$a uu$ ?v0) ?v1)))
(= $x31 $x32))) :pattern ( (fun_app$ (fun_app$a uu$ ?v0) ?v1) ) :qid k!10))
))
(let (($x40 (forall ((?v0 Int) (?v1 Int) )(! (let (($x32 (<= ?v0 ?v1)))
(let (($x31 (fun_app$ (fun_app$a uu$ ?v0) ?v1)))
(= $x31 $x32))) :pattern ( (fun_app$ (fun_app$a uu$ ?v0) ?v1) ) :qid k!10))
))
(let ((@x51 (monotonicity (rewrite (= (<= ?1 ?0) $x46)) (= (= $x31 (<= ?1 ?0)) $x49))))
(let ((@x42 (quant-intro (rewrite (= (= $x31 (<= ?1 ?0)) (= $x31 (<= ?1 ?0)))) (= $x35 $x40))))
(let ((@x57 (mp (asserted $x35) (trans @x42 (quant-intro @x51 (= $x40 $x52)) (= $x35 $x52)) $x52)))
(let ((@x78 (mp~ @x57 (nnf-pos (refl (~ $x49 $x49)) (~ $x52 $x52)) $x52)))
(let (($x134 (or (not $x52) $x168)))
(let (($x137 (= (or (not $x52) (= $x168 (<= (+ 3 (* (- 1) 42)) 0))) $x134)))
(let ((?x169 (* (- 1) 42)))
(let ((?x170 (+ 3 ?x169)))
(let (($x160 (<= ?x170 0)))
(let (($x171 (= $x168 $x160)))
(let ((@x158 (trans (monotonicity (rewrite (= ?x169 (- 42))) (= ?x170 (+ 3 (- 42)))) (rewrite (= (+ 3 (- 42)) (- 39))) (= ?x170 (- 39)))))
(let ((@x497 (trans (monotonicity @x158 (= $x160 (<= (- 39) 0))) (rewrite (= (<= (- 39) 0) true)) (= $x160 true))))
(let ((@x131 (trans (monotonicity @x497 (= $x171 (= $x168 true))) (rewrite (= (= $x168 true) $x168)) (= $x171 $x168))))
(let ((@x478 (mp ((_ quant-inst 3 42) (or (not $x52) $x171)) (trans (monotonicity @x131 $x137) (rewrite (= $x134 $x134)) $x137) $x134)))
(unit-resolution (unit-resolution @x478 @x78 $x168) (mp @x77 @x472 (not $x168)) false)))))))))))))))))))))))))))))))))))

9cdd1051dbf4e0648f71536fbc74bbab8e0e744e 75 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x78 (cons$ 2 nil$)))
(let ((?x79 (cons$ 1 ?x78)))
(let ((?x74 (cons$ 1 nil$)))
(let ((?x75 (cons$ 0 ?x74)))
(let ((?x76 (map$ uu$ ?x75)))
(let (($x80 (= ?x76 ?x79)))
(let ((?x185 (map$ uu$ ?x74)))
(let ((?x189 (map$ uu$ nil$)))
(let ((?x188 (fun_app$ uu$ 1)))
(let ((?x160 (cons$ ?x188 ?x189)))
(let (($x290 (= ?x185 ?x160)))
(let (($x521 (forall ((?v0 Int_int_fun$) (?v1 Int) (?v2 Int_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)) ) :qid k!13))
))
(let (($x72 (forall ((?v0 Int_int_fun$) (?v1 Int) (?v2 Int_list$) )(! (= (map$ ?v0 (cons$ ?v1 ?v2)) (cons$ (fun_app$ ?v0 ?v1) (map$ ?v0 ?v2))) :qid k!13))
))
(let (($x71 (= (map$ ?2 (cons$ ?1 ?0)) (cons$ (fun_app$ ?2 ?1) (map$ ?2 ?0)))))
(let ((@x97 (mp~ (asserted $x72) (nnf-pos (refl (~ $x71 $x71)) (~ $x72 $x72)) $x72)))
(let ((@x526 (mp @x97 (quant-intro (refl (= $x71 $x71)) (= $x72 $x521)) $x521)))
(let (($x173 (or (not $x521) $x290)))
(let ((@x506 ((_ quant-inst uu$ 1 nil$) $x173)))
(let (($x492 (= ?x189 nil$)))
(let (($x513 (forall ((?v0 Int_int_fun$) )(! (= (map$ ?v0 nil$) nil$) :pattern ( (map$ ?v0 nil$) ) :qid k!12))
))
(let (($x61 (forall ((?v0 Int_int_fun$) )(! (= (map$ ?v0 nil$) nil$) :qid k!12))
))
(let ((@x515 (refl (= (= (map$ ?0 nil$) nil$) (= (map$ ?0 nil$) nil$)))))
(let ((@x83 (refl (~ (= (map$ ?0 nil$) nil$) (= (map$ ?0 nil$) nil$)))))
(let ((@x518 (mp (mp~ (asserted $x61) (nnf-pos @x83 (~ $x61 $x61)) $x61) (quant-intro @x515 (= $x61 $x513)) $x513)))
(let (($x495 (or (not $x513) $x492)))
(let ((@x496 ((_ quant-inst uu$) $x495)))
(let (($x136 (= ?x188 2)))
(let (($x51 (forall ((?v0 Int) )(! (= (+ ?v0 (* (- 1) (fun_app$ uu$ ?v0))) (- 1)) :pattern ( (fun_app$ uu$ ?v0) ) :qid k!11))
))
(let (($x47 (= (+ ?0 (* (- 1) (fun_app$ uu$ ?0))) (- 1))))
(let (($x34 (forall ((?v0 Int) )(! (let ((?x29 (fun_app$ uu$ ?v0)))
(= ?x29 (+ ?v0 1))) :pattern ( (fun_app$ uu$ ?v0) ) :qid k!11))
))
(let (($x42 (forall ((?v0 Int) )(! (let ((?x29 (fun_app$ uu$ ?v0)))
(= ?x29 (+ 1 ?v0))) :pattern ( (fun_app$ uu$ ?v0) ) :qid k!11))
))
(let ((@x53 (quant-intro (rewrite (= (= (fun_app$ uu$ ?0) (+ 1 ?0)) $x47)) (= $x42 $x51))))
(let ((?x29 (fun_app$ uu$ ?0)))
(let (($x39 (= ?x29 (+ 1 ?0))))
(let ((@x41 (monotonicity (rewrite (= (+ ?0 1) (+ 1 ?0))) (= (= ?x29 (+ ?0 1)) $x39))))
(let ((@x56 (mp (asserted $x34) (trans (quant-intro @x41 (= $x34 $x42)) @x53 (= $x34 $x51)) $x51)))
(let ((@x85 (mp~ @x56 (nnf-pos (refl (~ $x47 $x47)) (~ $x51 $x51)) $x51)))
(let (($x145 (not $x51)))
(let (($x499 (or $x145 $x136)))
(let ((@x498 (rewrite (= (= (+ 1 (* (- 1) ?x188)) (- 1)) $x136))))
(let ((@x204 (monotonicity @x498 (= (or $x145 (= (+ 1 (* (- 1) ?x188)) (- 1))) $x499))))
(let ((@x207 (trans @x204 (rewrite (= $x499 $x499)) (= (or $x145 (= (+ 1 (* (- 1) ?x188)) (- 1))) $x499))))
(let ((@x104 (mp ((_ quant-inst 1) (or $x145 (= (+ 1 (* (- 1) ?x188)) (- 1)))) @x207 $x499)))
(let ((@x191 (monotonicity (symm (unit-resolution @x104 @x85 $x136) (= 2 ?x188)) (symm (unit-resolution @x496 @x518 $x492) (= nil$ ?x189)) (= ?x78 ?x160))))
(let ((@x473 (trans @x191 (symm (unit-resolution @x506 @x526 $x290) (= ?x160 ?x185)) (= ?x78 ?x185))))
(let ((?x182 (fun_app$ uu$ 0)))
(let (($x163 (= ?x182 1)))
(let (($x487 (or $x145 $x163)))
(let ((@x501 (monotonicity (rewrite (= (+ 0 (* (- 1) ?x182)) (* (- 1) ?x182))) (= (= (+ 0 (* (- 1) ?x182)) (- 1)) (= (* (- 1) ?x182) (- 1))))))
(let ((@x503 (trans @x501 (rewrite (= (= (* (- 1) ?x182) (- 1)) $x163)) (= (= (+ 0 (* (- 1) ?x182)) (- 1)) $x163))))
(let ((@x151 (monotonicity @x503 (= (or $x145 (= (+ 0 (* (- 1) ?x182)) (- 1))) $x487))))
(let ((@x490 (trans @x151 (rewrite (= $x487 $x487)) (= (or $x145 (= (+ 0 (* (- 1) ?x182)) (- 1))) $x487))))
(let ((@x491 (mp ((_ quant-inst 0) (or $x145 (= (+ 0 (* (- 1) ?x182)) (- 1)))) @x490 $x487)))
(let ((@x478 (monotonicity (symm (unit-resolution @x491 @x85 $x163) (= 1 ?x182)) @x473 (= ?x79 (cons$ ?x182 ?x185)))))
(let ((?x186 (cons$ ?x182 ?x185)))
(let (($x187 (= ?x76 ?x186)))
(let (($x504 (or (not $x521) $x187)))
(let ((@x505 ((_ quant-inst uu$ 0 (cons$ 1 nil$)) $x504)))
(let ((@x466 (trans (unit-resolution @x505 @x526 $x187) (symm @x478 (= ?x186 ?x79)) $x80)))
(let (($x81 (not $x80)))
(let ((@x82 (asserted $x81)))
(unit-resolution @x82 @x466 false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

40c61a0200976d6203302a7343af5b7ad1e6ce36 11 0
unsat
((set-logic AUFLIA)
(proof
(let (($x29 (forall ((?v0 A$) )(! (p$ ?v0) :qid k!6))
))
(let (($x30 (not $x29)))
(let (($x31 (or $x29 $x30)))
(let (($x32 (not $x31)))
(let ((@x42 (trans (monotonicity (rewrite (= $x31 true)) (= $x32 (not true))) (rewrite (= (not true) false)) (= $x32 false))))
(mp (asserted $x32) @x42 false))))))))

f17a5e4d5f1a5a93fbc847f858c7c845c29d8349 109 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x75 (dec_10$ 4)))
(let ((?x76 (* 4 ?x75)))
(let ((?x77 (dec_10$ ?x76)))
(let (($x79 (= ?x77 6)))
(let (($x150 (<= ?x75 4)))
(let (($x174 (= ?x75 4)))
(let (($x513 (forall ((?v0 Int) )(! (let (($x55 (>= ?v0 10)))
(ite $x55 (= (dec_10$ ?v0) (dec_10$ (+ (- 10) ?v0))) (= (dec_10$ ?v0) ?v0))) :pattern ( (dec_10$ ?v0) ) :qid k!5))
))
(let (($x92 (forall ((?v0 Int) )(! (let (($x55 (>= ?v0 10)))
(ite $x55 (= (dec_10$ ?v0) (dec_10$ (+ (- 10) ?v0))) (= (dec_10$ ?v0) ?v0))) :qid k!5))
))
(let (($x55 (>= ?0 10)))
(let (($x87 (ite $x55 (= (dec_10$ ?0) (dec_10$ (+ (- 10) ?0))) (= (dec_10$ ?0) ?0))))
(let (($x68 (forall ((?v0 Int) )(! (let ((?x38 (+ (- 10) ?v0)))
(let ((?x41 (dec_10$ ?x38)))
(let (($x55 (>= ?v0 10)))
(let ((?x60 (ite $x55 ?x41 ?v0)))
(let ((?x28 (dec_10$ ?v0)))
(= ?x28 ?x60)))))) :qid k!5))
))
(let ((?x38 (+ (- 10) ?0)))
(let ((?x41 (dec_10$ ?x38)))
(let ((?x60 (ite $x55 ?x41 ?0)))
(let ((?x28 (dec_10$ ?0)))
(let (($x65 (= ?x28 ?x60)))
(let (($x35 (forall ((?v0 Int) )(! (let ((?x28 (dec_10$ ?v0)))
(= ?x28 (ite (< ?v0 10) ?v0 (dec_10$ (- ?v0 10))))) :qid k!5))
))
(let (($x50 (forall ((?v0 Int) )(! (let ((?x38 (+ (- 10) ?v0)))
(let ((?x41 (dec_10$ ?x38)))
(let (($x30 (< ?v0 10)))
(let ((?x44 (ite $x30 ?v0 ?x41)))
(let ((?x28 (dec_10$ ?v0)))
(= ?x28 ?x44)))))) :qid k!5))
))
(let ((@x59 (monotonicity (rewrite (= (< ?0 10) (not $x55))) (= (ite (< ?0 10) ?0 ?x41) (ite (not $x55) ?0 ?x41)))))
(let ((@x64 (trans @x59 (rewrite (= (ite (not $x55) ?0 ?x41) ?x60)) (= (ite (< ?0 10) ?0 ?x41) ?x60))))
(let ((@x67 (monotonicity @x64 (= (= ?x28 (ite (< ?0 10) ?0 ?x41)) $x65))))
(let (($x30 (< ?0 10)))
(let ((?x44 (ite $x30 ?0 ?x41)))
(let (($x47 (= ?x28 ?x44)))
(let ((@x43 (monotonicity (rewrite (= (- ?0 10) ?x38)) (= (dec_10$ (- ?0 10)) ?x41))))
(let ((@x49 (monotonicity (monotonicity @x43 (= (ite $x30 ?0 (dec_10$ (- ?0 10))) ?x44)) (= (= ?x28 (ite $x30 ?0 (dec_10$ (- ?0 10)))) $x47))))
(let ((@x72 (trans (quant-intro @x49 (= $x35 $x50)) (quant-intro @x67 (= $x50 $x68)) (= $x35 $x68))))
(let ((@x86 (mp~ (mp (asserted $x35) @x72 $x68) (nnf-pos (refl (~ $x65 $x65)) (~ $x68 $x68)) $x68)))
(let ((@x95 (mp @x86 (quant-intro (rewrite (= $x65 $x87)) (= $x68 $x92)) $x92)))
(let ((@x518 (mp @x95 (quant-intro (refl (= $x87 $x87)) (= $x92 $x513)) $x513)))
(let (($x501 (not $x513)))
(let (($x163 (or $x501 $x174)))
(let ((?x97 (+ (- 10) 4)))
(let ((?x183 (dec_10$ ?x97)))
(let (($x184 (= ?x75 ?x183)))
(let (($x96 (>= 4 10)))
(let (($x185 (ite $x96 $x184 $x174)))
(let ((@x172 (monotonicity (monotonicity (rewrite (= ?x97 (- 6))) (= ?x183 (dec_10$ (- 6)))) (= $x184 (= ?x75 (dec_10$ (- 6)))))))
(let ((@x507 (monotonicity (rewrite (= $x96 false)) @x172 (= $x185 (ite false (= ?x75 (dec_10$ (- 6))) $x174)))))
(let ((@x511 (trans @x507 (rewrite (= (ite false (= ?x75 (dec_10$ (- 6))) $x174) $x174)) (= $x185 $x174))))
(let ((@x148 (trans (monotonicity @x511 (= (or $x501 $x185) $x163)) (rewrite (= $x163 $x163)) (= (or $x501 $x185) $x163))))
(let ((@x149 (mp ((_ quant-inst 4) (or $x501 $x185)) @x148 $x163)))
(let ((@x438 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x174) $x150)) (unit-resolution @x149 @x518 $x174) $x150)))
(let (($x151 (>= ?x75 4)))
(let ((@x428 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x174) $x151)) (unit-resolution @x149 @x518 $x174) $x151)))
(let ((?x489 (+ (- 10) ?x76)))
(let ((?x490 (dec_10$ ?x489)))
(let ((?x448 (* (- 1) ?x490)))
(let ((?x449 (+ ?x76 ?x448)))
(let (($x444 (<= ?x449 10)))
(let (($x292 (= ?x449 10)))
(let ((?x455 (+ (- 20) ?x76)))
(let ((?x458 (dec_10$ ?x455)))
(let (($x461 (= ?x490 ?x458)))
(let (($x310 (>= ?x75 5)))
(let (($x450 (ite $x310 $x461 $x292)))
(let (($x453 (or $x501 $x450)))
(let (($x470 (= ?x490 ?x489)))
(let ((?x467 (+ (- 10) ?x489)))
(let ((?x468 (dec_10$ ?x467)))
(let (($x469 (= ?x490 ?x468)))
(let (($x466 (>= ?x489 10)))
(let (($x471 (ite $x466 $x469 $x470)))
(let ((@x463 (monotonicity (monotonicity (rewrite (= ?x467 ?x455)) (= ?x468 ?x458)) (= $x469 $x461))))
(let ((@x452 (monotonicity (rewrite (= $x466 $x310)) @x463 (rewrite (= $x470 $x292)) (= $x471 $x450))))
(let ((@x442 (trans (monotonicity @x452 (= (or $x501 $x471) $x453)) (rewrite (= $x453 $x453)) (= (or $x501 $x471) $x453))))
(let ((@x443 (mp ((_ quant-inst (+ (- 10) ?x76)) (or $x501 $x471)) @x442 $x453)))
(let (($x346 (not $x310)))
(let ((@x418 (unit-resolution (def-axiom (or (not $x450) $x310 $x292)) (unit-resolution ((_ th-lemma arith farkas 1 1) (or $x346 (not $x150))) @x438 $x346) (or (not $x450) $x292))))
(let ((@x422 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x292) $x444)) (unit-resolution @x418 (unit-resolution @x443 @x518 $x450) $x292) $x444)))
(let (($x336 (>= ?x449 10)))
(let ((@x410 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x292) $x336)) (unit-resolution @x418 (unit-resolution @x443 @x518 $x450) $x292) $x336)))
(let (($x491 (= ?x77 ?x490)))
(let ((?x499 (* (- 1) ?x77)))
(let ((?x485 (+ ?x76 ?x499)))
(let (($x497 (= ?x485 0)))
(let (($x131 (>= ?x75 3)))
(let (($x486 (ite $x131 $x491 $x497)))
(let (($x205 (or $x501 $x486)))
(let ((@x204 (monotonicity (rewrite (= (>= ?x76 10) $x131)) (rewrite (= (= ?x77 ?x76) $x497)) (= (ite (>= ?x76 10) $x491 (= ?x77 ?x76)) $x486))))
(let ((@x479 (monotonicity @x204 (= (or $x501 (ite (>= ?x76 10) $x491 (= ?x77 ?x76))) $x205))))
(let ((@x212 (trans @x479 (rewrite (= $x205 $x205)) (= (or $x501 (ite (>= ?x76 10) $x491 (= ?x77 ?x76))) $x205))))
(let ((@x481 (mp ((_ quant-inst (* 4 ?x75)) (or $x501 (ite (>= ?x76 10) $x491 (= ?x77 ?x76)))) @x212 $x205)))
(let ((@x397 (unit-resolution (def-axiom (or (not $x486) (not $x131) $x491)) (unit-resolution ((_ th-lemma arith farkas 1 1) (or $x131 (not $x151))) @x428 $x131) (unit-resolution @x481 @x518 $x486) $x491)))
(let (($x80 (not $x79)))
(let ((@x81 (asserted $x80)))
(unit-resolution @x81 (trans @x397 ((_ th-lemma arith eq-propagate 1 1 -4 -4) @x410 @x422 @x428 @x438 (= ?x490 6)) $x79) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

8c0c900f4d4a92edc7d6113704948dc9280df015 348 0
unsat
((set-logic <null>)
(proof
(let ((?x96 (map$ uu$ xs$)))
(let ((?x97 (eval_dioph$ ks$ ?x96)))
(let ((?x424 (+ l$ ?x97)))
(let ((?x425 (mod ?x424 2)))
(let (($x482 (>= ?x425 2)))
(let (($x564 (not $x482)))
(let ((@x26 (true-axiom true)))
(let ((?x369 (* (- 1) l$)))
(let ((?x93 (eval_dioph$ ks$ xs$)))
(let ((?x678 (+ ?x93 ?x369)))
(let (($x679 (<= ?x678 0)))
(let (($x95 (= ?x93 l$)))
(let ((?x110 (* (- 1) ?x97)))
(let ((?x111 (+ l$ ?x110)))
(let ((?x114 (div$ ?x111 2)))
(let ((?x101 (map$ uua$ xs$)))
(let ((?x102 (eval_dioph$ ks$ ?x101)))
(let (($x117 (= ?x102 ?x114)))
(let (($x282 (not $x117)))
(let ((?x99 (mod$ l$ 2)))
(let ((?x98 (mod$ ?x97 2)))
(let (($x100 (= ?x98 ?x99)))
(let (($x281 (not $x100)))
(let (($x283 (or $x281 $x282)))
(let (($x465 (>= ?x425 0)))
(let ((?x496 (* (- 2) ?x102)))
(let ((?x497 (+ ?x93 ?x110 ?x496)))
(let (($x504 (<= ?x497 0)))
(let (($x498 (= ?x497 0)))
(let (($x304 (forall ((?v0 Int_list$) (?v1 Int_list$) )(! (let ((?x45 (eval_dioph$ ?v0 ?v1)))
(let ((?x83 (+ ?x45 (* (- 1) (eval_dioph$ ?v0 (map$ uu$ ?v1))) (* (- 2) (eval_dioph$ ?v0 (map$ uua$ ?v1))))))
(= ?x83 0))) :pattern ( (eval_dioph$ ?v0 (map$ uu$ ?v1)) ) :pattern ( (eval_dioph$ ?v0 (map$ uua$ ?v1)) ) :qid k!19))
))
(let (($x85 (forall ((?v0 Int_list$) (?v1 Int_list$) )(! (let ((?x45 (eval_dioph$ ?v0 ?v1)))
(let ((?x83 (+ ?x45 (* (- 1) (eval_dioph$ ?v0 (map$ uu$ ?v1))) (* (- 2) (eval_dioph$ ?v0 (map$ uua$ ?v1))))))
(= ?x83 0))) :qid k!19))
))
(let ((?x45 (eval_dioph$ ?1 ?0)))
(let ((?x83 (+ ?x45 (* (- 1) (eval_dioph$ ?1 (map$ uu$ ?0))) (* (- 2) (eval_dioph$ ?1 (map$ uua$ ?0))))))
(let (($x79 (= ?x83 0)))
(let (($x58 (forall ((?v0 Int_list$) (?v1 Int_list$) )(! (let ((?x45 (eval_dioph$ ?v0 ?v1)))
(let ((?x48 (eval_dioph$ ?v0 (map$ uu$ ?v1))))
(let ((?x56 (+ (* (eval_dioph$ ?v0 (map$ uua$ ?v1)) 2) ?x48)))
(= ?x56 ?x45)))) :qid k!19))
))
(let (($x74 (forall ((?v0 Int_list$) (?v1 Int_list$) )(! (let ((?x45 (eval_dioph$ ?v0 ?v1)))
(let ((?x54 (eval_dioph$ ?v0 (map$ uua$ ?v1))))
(let ((?x60 (* 2 ?x54)))
(let ((?x48 (eval_dioph$ ?v0 (map$ uu$ ?v1))))
(let ((?x66 (+ ?x48 ?x60)))
(= ?x66 ?x45)))))) :qid k!19))
))
(let ((?x54 (eval_dioph$ ?1 (map$ uua$ ?0))))
(let ((?x60 (* 2 ?x54)))
(let ((?x48 (eval_dioph$ ?1 (map$ uu$ ?0))))
(let ((?x66 (+ ?x48 ?x60)))
(let (($x71 (= ?x66 ?x45)))
(let ((@x65 (monotonicity (rewrite (= (* ?x54 2) ?x60)) (= (+ (* ?x54 2) ?x48) (+ ?x60 ?x48)))))
(let ((@x70 (trans @x65 (rewrite (= (+ ?x60 ?x48) ?x66)) (= (+ (* ?x54 2) ?x48) ?x66))))
(let ((@x76 (quant-intro (monotonicity @x70 (= (= (+ (* ?x54 2) ?x48) ?x45) $x71)) (= $x58 $x74))))
(let ((@x89 (trans @x76 (quant-intro (rewrite (= $x71 $x79)) (= $x74 $x85)) (= $x58 $x85))))
(let ((@x270 (mp~ (mp (asserted $x58) @x89 $x85) (nnf-pos (refl (~ $x79 $x79)) (~ $x85 $x85)) $x85)))
(let ((@x309 (mp @x270 (quant-intro (refl (= $x79 $x79)) (= $x85 $x304)) $x304)))
(let (($x502 (or (not $x304) $x498)))
(let ((@x503 ((_ quant-inst ks$ xs$) $x502)))
(let ((@x795 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x498) $x504)) (unit-resolution @x503 @x309 $x498) $x504)))
(let (($x815 (not $x679)))
(let (($x680 (>= ?x678 0)))
(let ((?x592 (mod ?x97 2)))
(let ((?x619 (* (- 1) ?x592)))
(let ((?x511 (mod l$ 2)))
(let ((?x538 (* (- 1) ?x511)))
(let ((?x776 (* (- 1) ?x102)))
(let ((?x759 (+ l$ ?x98 ?x776 ?x538 (* (- 1) (div l$ 2)) ?x619 (* (- 1) (div ?x97 2)))))
(let (($x760 (>= ?x759 1)))
(let (($x747 (not $x760)))
(let ((?x674 (* (- 1) ?x99)))
(let ((?x675 (+ ?x98 ?x674)))
(let (($x676 (<= ?x675 0)))
(let (($x284 (not $x283)))
(let ((@x493 (hypothesis $x284)))
(let ((@x781 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x281 $x676)) (unit-resolution (def-axiom (or $x283 $x100)) @x493 $x100) $x676)))
(let ((?x670 (* (- 1) ?x114)))
(let ((?x671 (+ ?x102 ?x670)))
(let (($x673 (>= ?x671 0)))
(let ((@x787 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x282 $x673)) (unit-resolution (def-axiom (or $x283 $x117)) @x493 $x117) $x673)))
(let ((?x557 (div l$ 2)))
(let ((?x570 (* (- 2) ?x557)))
(let ((?x571 (+ l$ ?x538 ?x570)))
(let (($x576 (<= ?x571 0)))
(let (($x569 (= ?x571 0)))
(let ((@x568 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x569) $x576)) (unit-resolution ((_ th-lemma arith) (or false $x569)) @x26 $x569) $x576)))
(let ((?x620 (+ ?x98 ?x619)))
(let (($x635 (<= ?x620 0)))
(let (($x621 (= ?x620 0)))
(let (($x318 (forall ((?v0 Int) (?v1 Int) )(! (let ((?x200 (mod ?v0 ?v1)))
(let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x208 (mod ?x154 ?x157)))
(let ((?x214 (* (- 1) ?x208)))
(let (($x175 (<= ?v1 0)))
(let ((?x234 (ite $x175 ?x214 ?x200)))
(let (($x143 (= ?v1 0)))
(let ((?x239 (ite $x143 ?v0 ?x234)))
(let ((?x199 (mod$ ?v0 ?v1)))
(= ?x199 ?x239))))))))))) :pattern ( (mod$ ?v0 ?v1) ) :qid k!22))
))
(let (($x245 (forall ((?v0 Int) (?v1 Int) )(! (let ((?x200 (mod ?v0 ?v1)))
(let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x208 (mod ?x154 ?x157)))
(let ((?x214 (* (- 1) ?x208)))
(let (($x175 (<= ?v1 0)))
(let ((?x234 (ite $x175 ?x214 ?x200)))
(let (($x143 (= ?v1 0)))
(let ((?x239 (ite $x143 ?v0 ?x234)))
(let ((?x199 (mod$ ?v0 ?v1)))
(= ?x199 ?x239))))))))))) :qid k!22))
))
(let ((?x200 (mod ?1 ?0)))
(let ((?x157 (* (- 1) ?0)))
(let ((?x154 (* (- 1) ?1)))
(let ((?x208 (mod ?x154 ?x157)))
(let ((?x214 (* (- 1) ?x208)))
(let (($x175 (<= ?0 0)))
(let ((?x234 (ite $x175 ?x214 ?x200)))
(let (($x143 (= ?0 0)))
(let ((?x239 (ite $x143 ?1 ?x234)))
(let ((?x199 (mod$ ?1 ?0)))
(let (($x242 (= ?x199 ?x239)))
(let (($x206 (forall ((?v0 Int) (?v1 Int) )(! (let (($x143 (= ?v1 0)))
(let ((?x204 (ite $x143 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
(let ((?x199 (mod$ ?v0 ?v1)))
(= ?x199 ?x204)))) :qid k!22))
))
(let (($x228 (forall ((?v0 Int) (?v1 Int) )(! (let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x208 (mod ?x154 ?x157)))
(let ((?x214 (* (- 1) ?x208)))
(let ((?x200 (mod ?v0 ?v1)))
(let (($x144 (< 0 ?v1)))
(let ((?x219 (ite $x144 ?x200 ?x214)))
(let (($x143 (= ?v1 0)))
(let ((?x222 (ite $x143 ?v0 ?x219)))
(let ((?x199 (mod$ ?v0 ?v1)))
(= ?x199 ?x222))))))))))) :qid k!22))
))
(let ((@x233 (monotonicity (rewrite (= (< 0 ?0) (not $x175))) (= (ite (< 0 ?0) ?x200 ?x214) (ite (not $x175) ?x200 ?x214)))))
(let ((@x238 (trans @x233 (rewrite (= (ite (not $x175) ?x200 ?x214) ?x234)) (= (ite (< 0 ?0) ?x200 ?x214) ?x234))))
(let ((@x241 (monotonicity @x238 (= (ite $x143 ?1 (ite (< 0 ?0) ?x200 ?x214)) ?x239))))
(let ((@x244 (monotonicity @x241 (= (= ?x199 (ite $x143 ?1 (ite (< 0 ?0) ?x200 ?x214))) $x242))))
(let (($x144 (< 0 ?0)))
(let ((?x219 (ite $x144 ?x200 ?x214)))
(let ((?x222 (ite $x143 ?1 ?x219)))
(let (($x225 (= ?x199 ?x222)))
(let (($x226 (= (= ?x199 (ite $x143 ?1 (ite $x144 ?x200 (- (mod (- ?1) (- ?0)))))) $x225)))
(let ((@x210 (monotonicity (rewrite (= (- ?1) ?x154)) (rewrite (= (- ?0) ?x157)) (= (mod (- ?1) (- ?0)) ?x208))))
(let ((@x218 (trans (monotonicity @x210 (= (- (mod (- ?1) (- ?0))) (- ?x208))) (rewrite (= (- ?x208) ?x214)) (= (- (mod (- ?1) (- ?0))) ?x214))))
(let ((@x221 (monotonicity @x218 (= (ite $x144 ?x200 (- (mod (- ?1) (- ?0)))) ?x219))))
(let ((@x224 (monotonicity @x221 (= (ite $x143 ?1 (ite $x144 ?x200 (- (mod (- ?1) (- ?0))))) ?x222))))
(let ((@x249 (trans (quant-intro (monotonicity @x224 $x226) (= $x206 $x228)) (quant-intro @x244 (= $x228 $x245)) (= $x206 $x245))))
(let ((@x280 (mp~ (mp (asserted $x206) @x249 $x245) (nnf-pos (refl (~ $x242 $x242)) (~ $x245 $x245)) $x245)))
(let ((@x323 (mp @x280 (quant-intro (refl (= $x242 $x242)) (= $x245 $x318)) $x318)))
(let (($x545 (not $x318)))
(let (($x626 (or $x545 $x621)))
(let ((?x359 (* (- 1) 2)))
(let ((?x590 (mod ?x110 ?x359)))
(let ((?x591 (* (- 1) ?x590)))
(let (($x357 (<= 2 0)))
(let ((?x593 (ite $x357 ?x591 ?x592)))
(let (($x356 (= 2 0)))
(let ((?x594 (ite $x356 ?x97 ?x593)))
(let (($x595 (= ?x98 ?x594)))
(let ((@x601 (monotonicity (monotonicity (rewrite (= ?x359 (- 2))) (= ?x590 (mod ?x110 (- 2)))) (= ?x591 (* (- 1) (mod ?x110 (- 2)))))))
(let ((@x368 (rewrite (= $x357 false))))
(let ((@x604 (monotonicity @x368 @x601 (= ?x593 (ite false (* (- 1) (mod ?x110 (- 2))) ?x592)))))
(let ((@x608 (trans @x604 (rewrite (= (ite false (* (- 1) (mod ?x110 (- 2))) ?x592) ?x592)) (= ?x593 ?x592))))
(let ((@x366 (rewrite (= $x356 false))))
(let ((@x615 (trans (monotonicity @x366 @x608 (= ?x594 (ite false ?x97 ?x592))) (rewrite (= (ite false ?x97 ?x592) ?x592)) (= ?x594 ?x592))))
(let ((@x625 (trans (monotonicity @x615 (= $x595 (= ?x98 ?x592))) (rewrite (= (= ?x98 ?x592) $x621)) (= $x595 $x621))))
(let ((@x633 (trans (monotonicity @x625 (= (or $x545 $x595) $x626)) (rewrite (= $x626 $x626)) (= (or $x545 $x595) $x626))))
(let ((@x634 (mp ((_ quant-inst (eval_dioph$ ks$ ?x96) 2) (or $x545 $x595)) @x633 $x626)))
(let ((@x431 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x621) $x635)) (unit-resolution @x634 @x323 $x621) $x635)))
(let ((?x637 (div ?x97 2)))
(let ((?x650 (* (- 2) ?x637)))
(let ((?x651 (+ ?x97 ?x619 ?x650)))
(let (($x656 (<= ?x651 0)))
(let (($x649 (= ?x651 0)))
(let ((@x661 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x649) $x656)) (unit-resolution ((_ th-lemma arith) (or false $x649)) @x26 $x649) $x656)))
(let ((?x539 (+ ?x99 ?x538)))
(let (($x555 (<= ?x539 0)))
(let (($x540 (= ?x539 0)))
(let (($x546 (or $x545 $x540)))
(let ((?x506 (mod ?x369 ?x359)))
(let ((?x507 (* (- 1) ?x506)))
(let ((?x512 (ite $x357 ?x507 ?x511)))
(let ((?x513 (ite $x356 l$ ?x512)))
(let (($x514 (= ?x99 ?x513)))
(let ((@x520 (monotonicity (monotonicity (rewrite (= ?x359 (- 2))) (= ?x506 (mod ?x369 (- 2)))) (= ?x507 (* (- 1) (mod ?x369 (- 2)))))))
(let ((@x523 (monotonicity @x368 @x520 (= ?x512 (ite false (* (- 1) (mod ?x369 (- 2))) ?x511)))))
(let ((@x527 (trans @x523 (rewrite (= (ite false (* (- 1) (mod ?x369 (- 2))) ?x511) ?x511)) (= ?x512 ?x511))))
(let ((@x534 (trans (monotonicity @x366 @x527 (= ?x513 (ite false l$ ?x511))) (rewrite (= (ite false l$ ?x511) ?x511)) (= ?x513 ?x511))))
(let ((@x544 (trans (monotonicity @x534 (= $x514 (= ?x99 ?x511))) (rewrite (= (= ?x99 ?x511) $x540)) (= $x514 $x540))))
(let ((@x553 (trans (monotonicity @x544 (= (or $x545 $x514) $x546)) (rewrite (= $x546 $x546)) (= (or $x545 $x514) $x546))))
(let ((@x554 (mp ((_ quant-inst l$ 2) (or $x545 $x514)) @x553 $x546)))
(let ((@x668 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x540) $x555)) (unit-resolution @x554 @x323 $x540) $x555)))
(let ((?x361 (div ?x111 2)))
(let ((?x395 (* (- 1) ?x361)))
(let ((?x396 (+ ?x114 ?x395)))
(let (($x414 (>= ?x396 0)))
(let (($x397 (= ?x396 0)))
(let (($x311 (forall ((?v0 Int) (?v1 Int) )(! (let ((?x145 (div ?v0 ?v1)))
(let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x160 (div ?x154 ?x157)))
(let (($x175 (<= ?v1 0)))
(let ((?x182 (ite $x175 ?x160 ?x145)))
(let (($x143 (= ?v1 0)))
(let ((?x141 (div$ ?v0 ?v1)))
(= ?x141 (ite $x143 0 ?x182)))))))))) :pattern ( (div$ ?v0 ?v1) ) :qid k!21))
))
(let (($x193 (forall ((?v0 Int) (?v1 Int) )(! (let ((?x145 (div ?v0 ?v1)))
(let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x160 (div ?x154 ?x157)))
(let (($x175 (<= ?v1 0)))
(let ((?x182 (ite $x175 ?x160 ?x145)))
(let (($x143 (= ?v1 0)))
(let ((?x141 (div$ ?v0 ?v1)))
(= ?x141 (ite $x143 0 ?x182)))))))))) :qid k!21))
))
(let ((?x141 (div$ ?1 ?0)))
(let (($x190 (= ?x141 (ite $x143 0 (ite $x175 (div ?x154 ?x157) (div ?1 ?0))))))
(let (($x152 (forall ((?v0 Int) (?v1 Int) )(! (let (($x143 (= ?v1 0)))
(let ((?x150 (ite $x143 0 (ite (< 0 ?v1) (div ?v0 ?v1) (div (- ?v0) (- ?v1))))))
(let ((?x141 (div$ ?v0 ?v1)))
(= ?x141 ?x150)))) :qid k!21))
))
(let (($x172 (forall ((?v0 Int) (?v1 Int) )(! (let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x160 (div ?x154 ?x157)))
(let ((?x145 (div ?v0 ?v1)))
(let (($x144 (< 0 ?v1)))
(let ((?x163 (ite $x144 ?x145 ?x160)))
(let (($x143 (= ?v1 0)))
(let ((?x166 (ite $x143 0 ?x163)))
(let ((?x141 (div$ ?v0 ?v1)))
(= ?x141 ?x166)))))))))) :qid k!21))
))
(let ((?x160 (div ?x154 ?x157)))
(let ((?x145 (div ?1 ?0)))
(let ((?x163 (ite $x144 ?x145 ?x160)))
(let ((?x166 (ite $x143 0 ?x163)))
(let (($x169 (= ?x141 ?x166)))
(let ((@x181 (monotonicity (rewrite (= $x144 (not $x175))) (= ?x163 (ite (not $x175) ?x145 ?x160)))))
(let ((@x186 (trans @x181 (rewrite (= (ite (not $x175) ?x145 ?x160) (ite $x175 ?x160 ?x145))) (= ?x163 (ite $x175 ?x160 ?x145)))))
(let ((@x192 (monotonicity (monotonicity @x186 (= ?x166 (ite $x143 0 (ite $x175 ?x160 ?x145)))) (= $x169 $x190))))
(let (($x170 (= (= ?x141 (ite $x143 0 (ite $x144 ?x145 (div (- ?1) (- ?0))))) $x169)))
(let ((@x162 (monotonicity (rewrite (= (- ?1) ?x154)) (rewrite (= (- ?0) ?x157)) (= (div (- ?1) (- ?0)) ?x160))))
(let ((@x168 (monotonicity (monotonicity @x162 (= (ite $x144 ?x145 (div (- ?1) (- ?0))) ?x163)) (= (ite $x143 0 (ite $x144 ?x145 (div (- ?1) (- ?0)))) ?x166))))
(let ((@x197 (trans (quant-intro (monotonicity @x168 $x170) (= $x152 $x172)) (quant-intro @x192 (= $x172 $x193)) (= $x152 $x193))))
(let ((@x275 (mp~ (mp (asserted $x152) @x197 $x193) (nnf-pos (refl (~ $x190 $x190)) (~ $x193 $x193)) $x193)))
(let ((@x316 (mp @x275 (quant-intro (refl (= $x190 $x190)) (= $x193 $x311)) $x311)))
(let (($x403 (or (not $x311) $x397)))
(let ((?x358 (* (- 1) ?x111)))
(let ((?x360 (div ?x358 ?x359)))
(let ((?x362 (ite $x357 ?x360 ?x361)))
(let ((?x363 (ite $x356 0 ?x362)))
(let (($x364 (= ?x114 ?x363)))
(let ((@x374 (rewrite (= ?x359 (- 2)))))
(let ((@x377 (monotonicity (rewrite (= ?x358 (+ ?x369 ?x97))) @x374 (= ?x360 (div (+ ?x369 ?x97) (- 2))))))
(let ((@x380 (monotonicity @x368 @x377 (= ?x362 (ite false (div (+ ?x369 ?x97) (- 2)) ?x361)))))
(let ((@x384 (trans @x380 (rewrite (= (ite false (div (+ ?x369 ?x97) (- 2)) ?x361) ?x361)) (= ?x362 ?x361))))
(let ((@x391 (trans (monotonicity @x366 @x384 (= ?x363 (ite false 0 ?x361))) (rewrite (= (ite false 0 ?x361) ?x361)) (= ?x363 ?x361))))
(let ((@x401 (trans (monotonicity @x391 (= $x364 (= ?x114 ?x361))) (rewrite (= (= ?x114 ?x361) $x397)) (= $x364 $x397))))
(let ((@x410 (trans (monotonicity @x401 (= (or (not $x311) $x364) $x403)) (rewrite (= $x403 $x403)) (= (or (not $x311) $x364) $x403))))
(let ((@x411 (mp ((_ quant-inst (+ l$ ?x110) 2) (or (not $x311) $x364)) @x410 $x403)))
(let ((@x485 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x397) $x414)) (unit-resolution @x411 @x316 $x397) $x414)))
(let ((?x436 (* (- 1) ?x425)))
(let ((?x435 (* (- 2) ?x361)))
(let ((?x437 (+ l$ ?x110 ?x435 ?x436)))
(let (($x442 (<= ?x437 0)))
(let (($x434 (= ?x437 0)))
(let ((@x745 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x434) $x442)) (unit-resolution ((_ th-lemma arith) (or false $x434)) @x26 $x434) $x442)))
(let ((@x746 ((_ th-lemma arith farkas 1 -2 -2 -2 1 1 1 1 1 1) @x745 @x485 (hypothesis $x673) (hypothesis $x760) (hypothesis $x676) @x668 @x661 @x431 @x568 (unit-resolution ((_ th-lemma arith) (or false $x564)) @x26 $x564) false)))
(let ((@x788 (unit-resolution (lemma @x746 (or $x747 (not $x673) (not $x676))) @x787 @x781 $x747)))
(let (($x677 (>= ?x675 0)))
(let ((@x812 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x281 $x677)) (unit-resolution (def-axiom (or $x283 $x100)) @x493 $x100) $x677)))
(let (($x577 (>= ?x571 0)))
(let ((@x778 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x569) $x577)) (unit-resolution ((_ th-lemma arith) (or false $x569)) @x26 $x569) $x577)))
(let (($x556 (>= ?x539 0)))
(let ((@x645 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x540) $x556)) (unit-resolution @x554 @x323 $x540) $x556)))
(let (($x636 (>= ?x620 0)))
(let ((@x652 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x621) $x636)) (unit-resolution @x634 @x323 $x621) $x636)))
(let (($x505 (>= ?x497 0)))
(let ((@x488 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x498) $x505)) (unit-resolution @x503 @x309 $x498) $x505)))
(let (($x657 (>= ?x651 0)))
(let ((@x581 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x649) $x657)) (unit-resolution ((_ th-lemma arith) (or false $x649)) @x26 $x649) $x657)))
(let ((@x582 ((_ th-lemma arith farkas -1/2 -1/2 -1/2 1/2 -1/2 -1/2 -1/2 1) @x581 (hypothesis $x677) @x488 (hypothesis (not $x680)) @x652 @x645 @x778 (hypothesis $x747) false)))
(let ((@x813 (unit-resolution (lemma @x582 (or $x680 (not $x677) $x760)) @x812 @x788 $x680)))
(let (($x134 (not $x95)))
(let (($x290 (= $x95 $x283)))
(let ((@x289 (monotonicity (rewrite (= (and $x100 $x117) $x284)) (= (= $x134 (and $x100 $x117)) (= $x134 $x284)))))
(let ((@x294 (trans @x289 (rewrite (= (= $x134 $x284) $x290)) (= (= $x134 (and $x100 $x117)) $x290))))
(let (($x120 (and $x100 $x117)))
(let (($x135 (= $x134 $x120)))
(let (($x107 (= $x95 (and $x100 (= ?x102 (div$ (- l$ ?x97) 2))))))
(let (($x108 (not $x107)))
(let ((@x116 (monotonicity (rewrite (= (- l$ ?x97) ?x111)) (= (div$ (- l$ ?x97) 2) ?x114))))
(let ((@x122 (monotonicity (monotonicity @x116 (= (= ?x102 (div$ (- l$ ?x97) 2)) $x117)) (= (and $x100 (= ?x102 (div$ (- l$ ?x97) 2))) $x120))))
(let ((@x130 (trans (monotonicity @x122 (= $x107 (= $x95 $x120))) (rewrite (= (= $x95 $x120) (= $x95 $x120))) (= $x107 (= $x95 $x120)))))
(let ((@x139 (trans (monotonicity @x130 (= $x108 (not (= $x95 $x120)))) (rewrite (= (not (= $x95 $x120)) $x135)) (= $x108 $x135))))
(let ((@x295 (mp (mp (asserted $x108) @x139 $x135) @x294 $x290)))
(let ((@x344 (unit-resolution (def-axiom (or $x134 $x283 (not $x290))) @x295 (or $x134 $x283))))
(let ((@x819 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x95 $x815 (not $x680))) (unit-resolution @x344 @x493 $x134) (or $x815 (not $x680)))))
(let (($x672 (<= ?x671 0)))
(let ((@x823 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x282 $x672)) (unit-resolution (def-axiom (or $x283 $x117)) @x493 $x117) $x672)))
(let (($x413 (<= ?x396 0)))
(let ((@x802 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x397) $x413)) (unit-resolution @x411 @x316 $x397) $x413)))
(let (($x443 (>= ?x437 0)))
(let ((@x826 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x434) $x443)) (unit-resolution ((_ th-lemma arith) (or false $x434)) @x26 $x434) $x443)))
(let ((@x827 ((_ th-lemma arith farkas 1 -2 -2 1 -1 1) @x826 @x802 @x823 (unit-resolution @x819 @x813 $x815) @x795 (unit-resolution ((_ th-lemma arith) (or false $x465)) @x26 $x465) false)))
(let ((@x828 (lemma @x827 $x283)))
(let ((@x340 (unit-resolution (def-axiom (or $x95 $x284 (not $x290))) @x295 (or $x95 $x284))))
(let ((@x584 (unit-resolution @x340 @x828 $x95)))
(let (($x807 (not $x672)))
(let ((@x888 ((_ th-lemma arith assign-bounds 1 -1/2 -1/2 1/2 -1/2) (or $x673 (not $x413) (not $x465) (not $x443) (not $x504) (not $x680)))))
(let ((@x889 (unit-resolution @x888 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x134 $x680)) @x584 $x680) @x802 @x826 (unit-resolution ((_ th-lemma arith) (or false $x465)) @x26 $x465) @x795 $x673)))
(let ((@x741 (symm (monotonicity (symm @x584 (= l$ ?x93)) (= ?x99 (mod$ ?x93 2))) (= (mod$ ?x93 2) ?x99))))
(let ((?x499 (mod$ ?x93 2)))
(let (($x500 (= ?x499 ?x98)))
(let (($x297 (forall ((?v0 Int_list$) (?v1 Int_list$) )(! (= (mod$ (eval_dioph$ ?v0 ?v1) 2) (mod$ (eval_dioph$ ?v0 (map$ uu$ ?v1)) 2)) :pattern ( (eval_dioph$ ?v0 (map$ uu$ ?v1)) ) :qid k!18))
))
(let (($x51 (forall ((?v0 Int_list$) (?v1 Int_list$) )(! (= (mod$ (eval_dioph$ ?v0 ?v1) 2) (mod$ (eval_dioph$ ?v0 (map$ uu$ ?v1)) 2)) :qid k!18))
))
(let (($x50 (= (mod$ ?x45 2) (mod$ ?x48 2))))
(let ((@x265 (mp~ (asserted $x51) (nnf-pos (refl (~ $x50 $x50)) (~ $x51 $x51)) $x51)))
(let ((@x302 (mp @x265 (quant-intro (refl (= $x50 $x50)) (= $x51 $x297)) $x297)))
(let (($x464 (or (not $x297) $x500)))
(let ((@x578 ((_ quant-inst ks$ xs$) $x464)))
(let ((@x748 (trans (symm (unit-resolution @x578 @x302 $x500) (= ?x98 ?x499)) @x741 $x100)))
(let ((@x891 (unit-resolution (unit-resolution (def-axiom (or $x284 $x281 $x282)) @x828 $x283) (lemma (unit-resolution (hypothesis $x281) @x748 false) $x100) $x282)))
(let ((@x895 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x117 $x807 (not $x673))) @x891 (or $x807 (not $x673)))))
((_ th-lemma arith farkas -2 -2 1 -1 1 1) (unit-resolution @x895 @x889 $x807) @x485 @x745 @x488 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x134 $x679)) @x584 $x679) (unit-resolution ((_ th-lemma arith) (or false $x564)) @x26 $x564) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

db184ed715734759b60f9bdc99290a92283563f5 64 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x108 (collect$ uu$)))
(let ((?x109 (sup$ ?x108)))
(let (($x117 (less_eq$ ?x109 ?x109)))
(let (($x118 (not $x117)))
(let ((@x119 (asserted $x118)))
(let ((?x111 (collect$ uua$)))
(let ((?x112 (sup$ ?x111)))
(let (($x115 (less_eq$ ?x112 ?x109)))
(let ((@x116 (asserted $x115)))
(let (($x113 (less_eq$ ?x109 ?x112)))
(let ((@x114 (asserted $x113)))
(let (($x578 (forall ((?v0 A$) (?v1 A$) (?v2 A$) )(! (let (($x97 (less_eq$ ?v0 ?v2)))
(let (($x95 (less_eq$ ?v1 ?v2)))
(let (($x138 (not $x95)))
(let (($x93 (less_eq$ ?v0 ?v1)))
(let (($x137 (not $x93)))
(or $x137 $x138 $x97)))))) :pattern ( (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v2) ) :qid k!17))
))
(let (($x156 (forall ((?v0 A$) (?v1 A$) (?v2 A$) )(! (let (($x97 (less_eq$ ?v0 ?v2)))
(let (($x95 (less_eq$ ?v1 ?v2)))
(let (($x138 (not $x95)))
(let (($x93 (less_eq$ ?v0 ?v1)))
(let (($x137 (not $x93)))
(or $x137 $x138 $x97)))))) :qid k!17))
))
(let ((@x583 (trans (rewrite (= $x156 $x578)) (rewrite (= $x578 $x578)) (= $x156 $x578))))
(let (($x105 (forall ((?v0 A$) (?v1 A$) (?v2 A$) )(! (let (($x97 (less_eq$ ?v0 ?v2)))
(let (($x95 (less_eq$ ?v1 ?v2)))
(let (($x93 (less_eq$ ?v0 ?v1)))
(let (($x96 (and $x93 $x95)))
(let (($x101 (not $x96)))
(or $x101 $x97)))))) :qid k!17))
))
(let (($x97 (less_eq$ ?2 ?0)))
(let (($x95 (less_eq$ ?1 ?0)))
(let (($x138 (not $x95)))
(let (($x93 (less_eq$ ?2 ?1)))
(let (($x137 (not $x93)))
(let (($x151 (or $x137 $x138 $x97)))
(let (($x96 (and $x93 $x95)))
(let (($x101 (not $x96)))
(let (($x102 (or $x101 $x97)))
(let ((@x143 (monotonicity (rewrite (= $x96 (not (or $x137 $x138)))) (= $x101 (not (not (or $x137 $x138)))))))
(let ((@x147 (trans @x143 (rewrite (= (not (not (or $x137 $x138))) (or $x137 $x138))) (= $x101 (or $x137 $x138)))))
(let ((@x155 (trans (monotonicity @x147 (= $x102 (or (or $x137 $x138) $x97))) (rewrite (= (or (or $x137 $x138) $x97) $x151)) (= $x102 $x151))))
(let (($x99 (forall ((?v0 A$) (?v1 A$) (?v2 A$) )(! (let (($x97 (less_eq$ ?v0 ?v2)))
(let (($x95 (less_eq$ ?v1 ?v2)))
(let (($x93 (less_eq$ ?v0 ?v1)))
(let (($x96 (and $x93 $x95)))
(=> $x96 $x97))))) :qid k!17))
))
(let ((@x110 (mp (asserted $x99) (quant-intro (rewrite (= (=> $x96 $x97) $x102)) (= $x99 $x105)) $x105)))
(let ((@x159 (mp (mp~ @x110 (nnf-pos (refl (~ $x102 $x102)) (~ $x105 $x105)) $x105) (quant-intro @x155 (= $x105 $x156)) $x156)))
(let ((@x584 (mp @x159 @x583 $x578)))
(let (($x247 (not $x115)))
(let (($x160 (not $x113)))
(let (($x251 (not $x578)))
(let (($x252 (or $x251 $x160 $x247 $x117)))
(let ((@x570 (mp ((_ quant-inst (sup$ ?x108) (sup$ ?x111) (sup$ ?x108)) (or $x251 (or $x160 $x247 $x117))) (rewrite (= (or $x251 (or $x160 $x247 $x117)) $x252)) $x252)))
(unit-resolution @x570 @x584 @x114 @x116 @x119 false)))))))))))))))))))))))))))))))))))))))

4e8ab14f236ad601aa67494ca8ea18b2ba6a1a79 25 0
unsat
((set-logic AUFLIA)
(proof
(let (($x142 (pred$e 1)))
(let (($x144 (not $x142)))
(let ((@x145 (asserted $x144)))
(let (($x615 (forall ((?v0 Int) )(! (pred$e ?v0) :pattern ( (pred$e ?v0) ) :qid k!29))
))
(let (($x138 (forall ((?v0 Int) )(! (pred$e ?v0) :qid k!29))
))
(let (($x127 (forall ((?v0 Int) )(! (let (($x125 (or (pred$d (cons$d ?v0 nil$d)) (not (pred$d (cons$d ?v0 nil$d))))))
(let (($x119 (pred$e ?v0)))
(and $x119 $x125))) :qid k!29))
))
(let (($x119 (pred$e ?0)))
(let (($x125 (or (pred$d (cons$d ?0 nil$d)) (not (pred$d (cons$d ?0 nil$d))))))
(let (($x126 (and $x119 $x125)))
(let ((@x133 (monotonicity (rewrite (= $x125 true)) (= $x126 (and $x119 true)))))
(let ((@x140 (quant-intro (trans @x133 (rewrite (= (and $x119 true) $x119)) (= $x126 $x119)) (= $x127 $x138))))
(let ((@x170 (mp~ (mp (asserted $x127) @x140 $x138) (nnf-pos (refl (~ $x119 $x119)) (~ $x138 $x138)) $x138)))
(let ((@x620 (mp @x170 (quant-intro (refl (= $x119 $x119)) (= $x138 $x615)) $x615)))
(let (($x257 (or (not $x615) $x142)))
(let ((@x258 ((_ quant-inst 1) $x257)))
(unit-resolution @x258 @x620 @x145 false))))))))))))))))))

b4b100f728c8f0d6f96483e4de44e248cc4be1aa 101 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x124 (some$a true)))
(let ((?x125 (g$b ?x124)))
(let ((?x122 (some$ 3)))
(let ((?x123 (g$ ?x122)))
(let (($x126 (= ?x123 ?x125)))
(let ((?x269 (cons$a true nil$a)))
(let ((?x270 (g$c ?x269)))
(let (($x587 (= ?x125 ?x270)))
(let (($x604 (forall ((?v0 Bool) )(! (= (g$b (some$a ?v0)) (g$c (cons$a ?v0 nil$a))) :pattern ( (some$a ?v0) ) :pattern ( (cons$a ?v0 nil$a) ) :qid k!33))
))
(let (($x43 (forall ((?v0 Bool) )(! (= (g$b (some$a ?v0)) (g$c (cons$a ?v0 nil$a))) :qid k!33))
))
(let (($x42 (= (g$b (some$a ?0)) (g$c (cons$a ?0 nil$a)))))
(let ((@x160 (mp~ (asserted $x43) (nnf-pos (refl (~ $x42 $x42)) (~ $x43 $x43)) $x43)))
(let ((@x609 (mp @x160 (quant-intro (refl (= $x42 $x42)) (= $x43 $x604)) $x604)))
(let (($x254 (or (not $x604) $x587)))
(let ((@x255 ((_ quant-inst true) $x254)))
(let ((?x227 (size$ ?x269)))
(let (($x569 (= ?x270 ?x227)))
(let (($x612 (forall ((?v0 Bool_list$) )(! (let ((?x61 (size$ ?v0)))
(let ((?x60 (g$c ?v0)))
(= ?x60 ?x61))) :pattern ( (g$c ?v0) ) :pattern ( (size$ ?v0) ) :qid k!38))
))
(let (($x63 (forall ((?v0 Bool_list$) )(! (let ((?x61 (size$ ?v0)))
(let ((?x60 (g$c ?v0)))
(= ?x60 ?x61))) :qid k!38))
))
(let ((@x616 (quant-intro (refl (= (= (g$c ?0) (size$ ?0)) (= (g$c ?0) (size$ ?0)))) (= $x63 $x612))))
(let ((@x142 (nnf-pos (refl (~ (= (g$c ?0) (size$ ?0)) (= (g$c ?0) (size$ ?0)))) (~ $x63 $x63))))
(let ((@x617 (mp (mp~ (asserted $x63) @x142 $x63) @x616 $x612)))
(let (($x571 (or (not $x612) $x569)))
(let ((@x572 ((_ quant-inst (cons$a true nil$a)) $x571)))
(let ((?x89 (suc$ zero$)))
(let ((?x105 (size$ nil$a)))
(let ((?x233 (plus$ ?x105 ?x89)))
(let (($x570 (= ?x227 ?x233)))
(let (($x657 (forall ((?v0 Bool) (?v1 Bool_list$) )(! (= (size$ (cons$a ?v0 ?v1)) (plus$ (size$ ?v1) (suc$ zero$))) :pattern ( (cons$a ?v0 ?v1) ) :qid k!46))
))
(let (($x114 (forall ((?v0 Bool) (?v1 Bool_list$) )(! (= (size$ (cons$a ?v0 ?v1)) (plus$ (size$ ?v1) (suc$ zero$))) :qid k!46))
))
(let (($x113 (= (size$ (cons$a ?1 ?0)) (plus$ (size$ ?0) ?x89))))
(let ((@x173 (mp~ (asserted $x114) (nnf-pos (refl (~ $x113 $x113)) (~ $x114 $x114)) $x114)))
(let ((@x662 (mp @x173 (quant-intro (refl (= $x113 $x113)) (= $x114 $x657)) $x657)))
(let (($x576 (or (not $x657) $x570)))
(let ((@x213 ((_ quant-inst true nil$a) $x576)))
(let ((?x108 (size$a nil$)))
(let (($x109 (= ?x108 zero$)))
(let ((@x110 (asserted $x109)))
(let (($x106 (= ?x105 zero$)))
(let ((@x107 (asserted $x106)))
(let ((@x287 (monotonicity (trans @x107 (symm @x110 (= zero$ ?x108)) (= ?x105 ?x108)) (= ?x233 (plus$ ?x108 ?x89)))))
(let ((?x246 (plus$ ?x108 ?x89)))
(let ((?x256 (cons$ 3 nil$)))
(let ((?x588 (size$a ?x256)))
(let (($x584 (= ?x588 ?x246)))
(let (($x664 (forall ((?v0 Int) (?v1 Int_list$) )(! (= (size$a (cons$ ?v0 ?v1)) (plus$ (size$a ?v1) (suc$ zero$))) :pattern ( (cons$ ?v0 ?v1) ) :qid k!47))
))
(let (($x119 (forall ((?v0 Int) (?v1 Int_list$) )(! (= (size$a (cons$ ?v0 ?v1)) (plus$ (size$a ?v1) (suc$ zero$))) :qid k!47))
))
(let (($x118 (= (size$a (cons$ ?1 ?0)) (plus$ (size$a ?0) ?x89))))
(let ((@x178 (mp~ (asserted $x119) (nnf-pos (refl (~ $x118 $x118)) (~ $x119 $x119)) $x119)))
(let ((@x669 (mp @x178 (quant-intro (refl (= $x118 $x118)) (= $x119 $x664)) $x664)))
(let (($x231 (or (not $x664) $x584)))
(let ((@x232 ((_ quant-inst 3 nil$) $x231)))
(let ((?x267 (g$a ?x256)))
(let (($x592 (= ?x267 ?x588)))
(let (($x620 (forall ((?v0 Int_list$) )(! (let ((?x67 (size$a ?v0)))
(let ((?x66 (g$a ?v0)))
(= ?x66 ?x67))) :pattern ( (g$a ?v0) ) :pattern ( (size$a ?v0) ) :qid k!39))
))
(let (($x69 (forall ((?v0 Int_list$) )(! (let ((?x67 (size$a ?v0)))
(let ((?x66 (g$a ?v0)))
(= ?x66 ?x67))) :qid k!39))
))
(let ((@x622 (refl (= (= (g$a ?0) (size$a ?0)) (= (g$a ?0) (size$a ?0))))))
(let ((@x129 (nnf-pos (refl (~ (= (g$a ?0) (size$a ?0)) (= (g$a ?0) (size$a ?0)))) (~ $x69 $x69))))
(let ((@x625 (mp (mp~ (asserted $x69) @x129 $x69) (quant-intro @x622 (= $x69 $x620)) $x620)))
(let (($x248 (or (not $x620) $x592)))
(let ((@x585 ((_ quant-inst (cons$ 3 nil$)) $x248)))
(let (($x268 (= ?x123 ?x267)))
(let (($x596 (forall ((?v0 Int) )(! (= (g$ (some$ ?v0)) (g$a (cons$ ?v0 nil$))) :pattern ( (some$ ?v0) ) :pattern ( (cons$ ?v0 nil$) ) :qid k!32))
))
(let (($x34 (forall ((?v0 Int) )(! (= (g$ (some$ ?v0)) (g$a (cons$ ?v0 nil$))) :qid k!32))
))
(let (($x33 (= (g$ (some$ ?0)) (g$a (cons$ ?0 nil$)))))
(let ((@x157 (mp~ (asserted $x34) (nnf-pos (refl (~ $x33 $x33)) (~ $x34 $x34)) $x34)))
(let ((@x601 (mp @x157 (quant-intro (refl (= $x33 $x33)) (= $x34 $x596)) $x596)))
(let (($x250 (or (not $x596) $x268)))
(let ((@x586 ((_ quant-inst 3) $x250)))
(let ((@x275 (trans (unit-resolution @x586 @x601 $x268) (unit-resolution @x585 @x625 $x592) (= ?x123 ?x588))))
(let ((@x280 (trans (trans @x275 (unit-resolution @x232 @x669 $x584) (= ?x123 ?x246)) (symm @x287 (= ?x246 ?x233)) (= ?x123 ?x233))))
(let ((@x558 (trans @x280 (symm (unit-resolution @x213 @x662 $x570) (= ?x233 ?x227)) (= ?x123 ?x227))))
(let ((@x560 (trans @x558 (symm (unit-resolution @x572 @x617 $x569) (= ?x227 ?x270)) (= ?x123 ?x270))))
(let ((@x546 (trans @x560 (symm (unit-resolution @x255 @x609 $x587) (= ?x270 ?x125)) $x126)))
(let (($x127 (not $x126)))
(let ((@x128 (asserted $x127)))
(unit-resolution @x128 @x546 false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

0f7f4a10f8a84029fd3a6efddc4408fa429b0cda 113 0
unsat
((set-logic <null>)
(proof
(let ((?x228 (mod x$ 2)))
(let ((?x262 (* (- 1) ?x228)))
(let ((?x31 (mod$ x$ 2)))
(let ((?x263 (+ ?x31 ?x262)))
(let (($x280 (>= ?x263 0)))
(let (($x264 (= ?x263 0)))
(let (($x205 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x136 (mod ?v0 ?v1)))
(let ((?x93 (* (- 1) ?v1)))
(let ((?x90 (* (- 1) ?v0)))
(let ((?x144 (mod ?x90 ?x93)))
(let ((?x150 (* (- 1) ?x144)))
(let (($x111 (<= ?v1 0)))
(let ((?x170 (ite $x111 ?x150 ?x136)))
(let (($x78 (= ?v1 0)))
(let ((?x175 (ite $x78 ?v0 ?x170)))
(let ((?x135 (mod$ ?v0 ?v1)))
(= ?x135 ?x175))))))))))) :pattern ( (mod$ ?v0 ?v1) )))
))
(let (($x181 (forall ((?v0 Int) (?v1 Int) )(let ((?x136 (mod ?v0 ?v1)))
(let ((?x93 (* (- 1) ?v1)))
(let ((?x90 (* (- 1) ?v0)))
(let ((?x144 (mod ?x90 ?x93)))
(let ((?x150 (* (- 1) ?x144)))
(let (($x111 (<= ?v1 0)))
(let ((?x170 (ite $x111 ?x150 ?x136)))
(let (($x78 (= ?v1 0)))
(let ((?x175 (ite $x78 ?v0 ?x170)))
(let ((?x135 (mod$ ?v0 ?v1)))
(= ?x135 ?x175))))))))))))
))
(let ((?x136 (mod ?1 ?0)))
(let ((?x93 (* (- 1) ?0)))
(let ((?x90 (* (- 1) ?1)))
(let ((?x144 (mod ?x90 ?x93)))
(let ((?x150 (* (- 1) ?x144)))
(let (($x111 (<= ?0 0)))
(let ((?x170 (ite $x111 ?x150 ?x136)))
(let (($x78 (= ?0 0)))
(let ((?x175 (ite $x78 ?1 ?x170)))
(let ((?x135 (mod$ ?1 ?0)))
(let (($x178 (= ?x135 ?x175)))
(let (($x142 (forall ((?v0 Int) (?v1 Int) )(let (($x78 (= ?v1 0)))
(let ((?x140 (ite $x78 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
(let ((?x135 (mod$ ?v0 ?v1)))
(= ?x135 ?x140)))))
))
(let (($x164 (forall ((?v0 Int) (?v1 Int) )(let ((?x93 (* (- 1) ?v1)))
(let ((?x90 (* (- 1) ?v0)))
(let ((?x144 (mod ?x90 ?x93)))
(let ((?x150 (* (- 1) ?x144)))
(let ((?x136 (mod ?v0 ?v1)))
(let (($x79 (< 0 ?v1)))
(let ((?x155 (ite $x79 ?x136 ?x150)))
(let (($x78 (= ?v1 0)))
(let ((?x158 (ite $x78 ?v0 ?x155)))
(let ((?x135 (mod$ ?v0 ?v1)))
(= ?x135 ?x158))))))))))))
))
(let ((@x169 (monotonicity (rewrite (= (< 0 ?0) (not $x111))) (= (ite (< 0 ?0) ?x136 ?x150) (ite (not $x111) ?x136 ?x150)))))
(let ((@x174 (trans @x169 (rewrite (= (ite (not $x111) ?x136 ?x150) ?x170)) (= (ite (< 0 ?0) ?x136 ?x150) ?x170))))
(let ((@x177 (monotonicity @x174 (= (ite $x78 ?1 (ite (< 0 ?0) ?x136 ?x150)) ?x175))))
(let ((@x180 (monotonicity @x177 (= (= ?x135 (ite $x78 ?1 (ite (< 0 ?0) ?x136 ?x150))) $x178))))
(let (($x79 (< 0 ?0)))
(let ((?x155 (ite $x79 ?x136 ?x150)))
(let ((?x158 (ite $x78 ?1 ?x155)))
(let (($x161 (= ?x135 ?x158)))
(let (($x162 (= (= ?x135 (ite $x78 ?1 (ite $x79 ?x136 (- (mod (- ?1) (- ?0)))))) $x161)))
(let ((@x146 (monotonicity (rewrite (= (- ?1) ?x90)) (rewrite (= (- ?0) ?x93)) (= (mod (- ?1) (- ?0)) ?x144))))
(let ((@x154 (trans (monotonicity @x146 (= (- (mod (- ?1) (- ?0))) (- ?x144))) (rewrite (= (- ?x144) ?x150)) (= (- (mod (- ?1) (- ?0))) ?x150))))
(let ((@x157 (monotonicity @x154 (= (ite $x79 ?x136 (- (mod (- ?1) (- ?0)))) ?x155))))
(let ((@x160 (monotonicity @x157 (= (ite $x78 ?1 (ite $x79 ?x136 (- (mod (- ?1) (- ?0))))) ?x158))))
(let ((@x185 (trans (quant-intro (monotonicity @x160 $x162) (= $x142 $x164)) (quant-intro @x180 (= $x164 $x181)) (= $x142 $x181))))
(let ((@x196 (mp~ (mp (asserted $x142) @x185 $x181) (nnf-pos (refl (~ $x178 $x178)) (~ $x181 $x181)) $x181)))
(let ((@x210 (mp @x196 (quant-intro (refl (= $x178 $x178)) (= $x181 $x205)) $x205)))
(let (($x270 (or (not $x205) $x264)))
(let ((?x225 (* (- 1) 2)))
(let ((?x224 (* (- 1) x$)))
(let ((?x226 (mod ?x224 ?x225)))
(let ((?x227 (* (- 1) ?x226)))
(let (($x223 (<= 2 0)))
(let ((?x229 (ite $x223 ?x227 ?x228)))
(let (($x222 (= 2 0)))
(let ((?x230 (ite $x222 x$ ?x229)))
(let (($x231 (= ?x31 ?x230)))
(let ((@x244 (monotonicity (monotonicity (rewrite (= ?x225 (- 2))) (= ?x226 (mod ?x224 (- 2)))) (= ?x227 (* (- 1) (mod ?x224 (- 2)))))))
(let ((@x247 (monotonicity (rewrite (= $x223 false)) @x244 (= ?x229 (ite false (* (- 1) (mod ?x224 (- 2))) ?x228)))))
(let ((@x251 (trans @x247 (rewrite (= (ite false (* (- 1) (mod ?x224 (- 2))) ?x228) ?x228)) (= ?x229 ?x228))))
(let ((@x254 (monotonicity (rewrite (= $x222 false)) @x251 (= ?x230 (ite false x$ ?x228)))))
(let ((@x261 (monotonicity (trans @x254 (rewrite (= (ite false x$ ?x228) ?x228)) (= ?x230 ?x228)) (= $x231 (= ?x31 ?x228)))))
(let ((@x274 (monotonicity (trans @x261 (rewrite (= (= ?x31 ?x228) $x264)) (= $x231 $x264)) (= (or (not $x205) $x231) $x270))))
(let ((@x277 (trans @x274 (rewrite (= $x270 $x270)) (= (or (not $x205) $x231) $x270))))
(let ((@x278 (mp ((_ quant-inst x$ 2) (or (not $x205) $x231)) @x277 $x270)))
(let ((@x337 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x264) $x280)) (unit-resolution @x278 @x210 $x264) $x280)))
(let (($x305 (>= ?x228 0)))
(let (($x64 (>= ?x31 0)))
(let (($x67 (not $x64)))
(let (($x36 (not (<= (+ x$ 1) (+ x$ (+ (* 2 ?x31) 1))))))
(let ((@x69 (monotonicity (rewrite (= (>= (* 2 ?x31) 0) $x64)) (= (not (>= (* 2 ?x31) 0)) $x67))))
(let ((?x32 (* 2 ?x31)))
(let ((?x47 (+ 1 x$ ?x32)))
(let (($x52 (<= (+ 1 x$) ?x47)))
(let (($x55 (not $x52)))
(let ((@x63 (monotonicity (rewrite (= $x52 (>= ?x32 0))) (= $x55 (not (>= ?x32 0))))))
(let ((@x46 (monotonicity (rewrite (= (+ ?x32 1) (+ 1 ?x32))) (= (+ x$ (+ ?x32 1)) (+ x$ (+ 1 ?x32))))))
(let ((@x51 (trans @x46 (rewrite (= (+ x$ (+ 1 ?x32)) ?x47)) (= (+ x$ (+ ?x32 1)) ?x47))))
(let ((@x54 (monotonicity (rewrite (= (+ x$ 1) (+ 1 x$))) @x51 (= (<= (+ x$ 1) (+ x$ (+ ?x32 1))) $x52))))
(let ((@x73 (trans (monotonicity @x54 (= $x36 $x55)) (trans @x63 @x69 (= $x55 $x67)) (= $x36 $x67))))
(let ((@x74 (mp (asserted $x36) @x73 $x67)))
((_ th-lemma arith farkas -1 1 1) @x74 (unit-resolution ((_ th-lemma arith) (or false $x305)) (true-axiom true) $x305) @x337 false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

fa5abc269019f00f5093218b287856c2a08c0adf 112 0
unsat
((set-logic <null>)
(proof
(let ((?x224 (mod x$ 2)))
(let (($x318 (>= ?x224 2)))
(let (($x319 (not $x318)))
(let ((?x258 (* (- 1) ?x224)))
(let ((?x29 (mod$ x$ 2)))
(let ((?x259 (+ ?x29 ?x258)))
(let (($x275 (<= ?x259 0)))
(let (($x260 (= ?x259 0)))
(let (($x201 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x132 (mod ?v0 ?v1)))
(let ((?x89 (* (- 1) ?v1)))
(let ((?x86 (* (- 1) ?v0)))
(let ((?x140 (mod ?x86 ?x89)))
(let ((?x146 (* (- 1) ?x140)))
(let (($x107 (<= ?v1 0)))
(let ((?x166 (ite $x107 ?x146 ?x132)))
(let (($x74 (= ?v1 0)))
(let ((?x171 (ite $x74 ?v0 ?x166)))
(let ((?x131 (mod$ ?v0 ?v1)))
(= ?x131 ?x171))))))))))) :pattern ( (mod$ ?v0 ?v1) )))
))
(let (($x177 (forall ((?v0 Int) (?v1 Int) )(let ((?x132 (mod ?v0 ?v1)))
(let ((?x89 (* (- 1) ?v1)))
(let ((?x86 (* (- 1) ?v0)))
(let ((?x140 (mod ?x86 ?x89)))
(let ((?x146 (* (- 1) ?x140)))
(let (($x107 (<= ?v1 0)))
(let ((?x166 (ite $x107 ?x146 ?x132)))
(let (($x74 (= ?v1 0)))
(let ((?x171 (ite $x74 ?v0 ?x166)))
(let ((?x131 (mod$ ?v0 ?v1)))
(= ?x131 ?x171))))))))))))
))
(let ((?x132 (mod ?1 ?0)))
(let ((?x89 (* (- 1) ?0)))
(let ((?x86 (* (- 1) ?1)))
(let ((?x140 (mod ?x86 ?x89)))
(let ((?x146 (* (- 1) ?x140)))
(let (($x107 (<= ?0 0)))
(let ((?x166 (ite $x107 ?x146 ?x132)))
(let (($x74 (= ?0 0)))
(let ((?x171 (ite $x74 ?1 ?x166)))
(let ((?x131 (mod$ ?1 ?0)))
(let (($x174 (= ?x131 ?x171)))
(let (($x138 (forall ((?v0 Int) (?v1 Int) )(let (($x74 (= ?v1 0)))
(let ((?x136 (ite $x74 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
(let ((?x131 (mod$ ?v0 ?v1)))
(= ?x131 ?x136)))))
))
(let (($x160 (forall ((?v0 Int) (?v1 Int) )(let ((?x89 (* (- 1) ?v1)))
(let ((?x86 (* (- 1) ?v0)))
(let ((?x140 (mod ?x86 ?x89)))
(let ((?x146 (* (- 1) ?x140)))
(let ((?x132 (mod ?v0 ?v1)))
(let (($x75 (< 0 ?v1)))
(let ((?x151 (ite $x75 ?x132 ?x146)))
(let (($x74 (= ?v1 0)))
(let ((?x154 (ite $x74 ?v0 ?x151)))
(let ((?x131 (mod$ ?v0 ?v1)))
(= ?x131 ?x154))))))))))))
))
(let ((@x165 (monotonicity (rewrite (= (< 0 ?0) (not $x107))) (= (ite (< 0 ?0) ?x132 ?x146) (ite (not $x107) ?x132 ?x146)))))
(let ((@x170 (trans @x165 (rewrite (= (ite (not $x107) ?x132 ?x146) ?x166)) (= (ite (< 0 ?0) ?x132 ?x146) ?x166))))
(let ((@x173 (monotonicity @x170 (= (ite $x74 ?1 (ite (< 0 ?0) ?x132 ?x146)) ?x171))))
(let ((@x176 (monotonicity @x173 (= (= ?x131 (ite $x74 ?1 (ite (< 0 ?0) ?x132 ?x146))) $x174))))
(let (($x75 (< 0 ?0)))
(let ((?x151 (ite $x75 ?x132 ?x146)))
(let ((?x154 (ite $x74 ?1 ?x151)))
(let (($x157 (= ?x131 ?x154)))
(let (($x158 (= (= ?x131 (ite $x74 ?1 (ite $x75 ?x132 (- (mod (- ?1) (- ?0)))))) $x157)))
(let ((@x142 (monotonicity (rewrite (= (- ?1) ?x86)) (rewrite (= (- ?0) ?x89)) (= (mod (- ?1) (- ?0)) ?x140))))
(let ((@x150 (trans (monotonicity @x142 (= (- (mod (- ?1) (- ?0))) (- ?x140))) (rewrite (= (- ?x140) ?x146)) (= (- (mod (- ?1) (- ?0))) ?x146))))
(let ((@x153 (monotonicity @x150 (= (ite $x75 ?x132 (- (mod (- ?1) (- ?0)))) ?x151))))
(let ((@x156 (monotonicity @x153 (= (ite $x74 ?1 (ite $x75 ?x132 (- (mod (- ?1) (- ?0))))) ?x154))))
(let ((@x181 (trans (quant-intro (monotonicity @x156 $x158) (= $x138 $x160)) (quant-intro @x176 (= $x160 $x177)) (= $x138 $x177))))
(let ((@x192 (mp~ (mp (asserted $x138) @x181 $x177) (nnf-pos (refl (~ $x174 $x174)) (~ $x177 $x177)) $x177)))
(let ((@x206 (mp @x192 (quant-intro (refl (= $x174 $x174)) (= $x177 $x201)) $x201)))
(let (($x266 (or (not $x201) $x260)))
(let ((?x221 (* (- 1) 2)))
(let ((?x220 (* (- 1) x$)))
(let ((?x222 (mod ?x220 ?x221)))
(let ((?x223 (* (- 1) ?x222)))
(let (($x219 (<= 2 0)))
(let ((?x225 (ite $x219 ?x223 ?x224)))
(let (($x218 (= 2 0)))
(let ((?x226 (ite $x218 x$ ?x225)))
(let (($x227 (= ?x29 ?x226)))
(let ((@x240 (monotonicity (monotonicity (rewrite (= ?x221 (- 2))) (= ?x222 (mod ?x220 (- 2)))) (= ?x223 (* (- 1) (mod ?x220 (- 2)))))))
(let ((@x243 (monotonicity (rewrite (= $x219 false)) @x240 (= ?x225 (ite false (* (- 1) (mod ?x220 (- 2))) ?x224)))))
(let ((@x247 (trans @x243 (rewrite (= (ite false (* (- 1) (mod ?x220 (- 2))) ?x224) ?x224)) (= ?x225 ?x224))))
(let ((@x250 (monotonicity (rewrite (= $x218 false)) @x247 (= ?x226 (ite false x$ ?x224)))))
(let ((@x257 (monotonicity (trans @x250 (rewrite (= (ite false x$ ?x224) ?x224)) (= ?x226 ?x224)) (= $x227 (= ?x29 ?x224)))))
(let ((@x270 (monotonicity (trans @x257 (rewrite (= (= ?x29 ?x224) $x260)) (= $x227 $x260)) (= (or (not $x201) $x227) $x266))))
(let ((@x273 (trans @x270 (rewrite (= $x266 $x266)) (= (or (not $x201) $x227) $x266))))
(let ((@x274 (mp ((_ quant-inst x$ 2) (or (not $x201) $x227)) @x273 $x266)))
(let ((@x336 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x260) $x275)) (unit-resolution @x274 @x206 $x260) $x275)))
(let (($x63 (>= ?x29 2)))
(let ((?x37 (* 2 ?x29)))
(let (($x56 (>= ?x37 3)))
(let (($x46 (< (+ x$ ?x37) (+ 3 x$))))
(let (($x49 (not $x46)))
(let ((@x58 (monotonicity (rewrite (= $x46 (not $x56))) (= $x49 (not (not $x56))))))
(let ((@x67 (trans (trans @x58 (rewrite (= (not (not $x56)) $x56)) (= $x49 $x56)) (rewrite (= $x56 $x63)) (= $x49 $x63))))
(let ((@x42 (monotonicity (rewrite (= (+ ?x29 ?x29) ?x37)) (= (+ x$ (+ ?x29 ?x29)) (+ x$ ?x37)))))
(let ((@x48 (monotonicity @x42 (rewrite (= (+ x$ 3) (+ 3 x$))) (= (< (+ x$ (+ ?x29 ?x29)) (+ x$ 3)) $x46))))
(let ((@x51 (monotonicity @x48 (= (not (< (+ x$ (+ ?x29 ?x29)) (+ x$ 3))) $x49))))
(let ((@x69 (trans @x51 @x67 (= (not (< (+ x$ (+ ?x29 ?x29)) (+ x$ 3))) $x63))))
(let ((@x70 (mp (asserted (not (< (+ x$ (+ ?x29 ?x29)) (+ x$ 3)))) @x69 $x63)))
((_ th-lemma arith farkas -1 1 1) @x70 @x336 (unit-resolution ((_ th-lemma arith) (or false $x319)) (true-axiom true) $x319) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

1880f0ed1cb3d1cfa006dff17f1b5553ce3a5158 236 0
unsat
((set-logic <null>)
(proof
(let ((?x410 (div n$ 2)))
(let ((?x704 (* (- 1) ?x410)))
(let ((?x381 (div n$ 4)))
(let ((?x601 (* (- 2) ?x381)))
(let ((?x329 (mod n$ 4)))
(let ((?x363 (* (- 1) ?x329)))
(let ((?x35 (mod$ n$ 4)))
(let ((?x705 (+ n$ ?x35 ?x363 ?x601 ?x704)))
(let (($x706 (>= ?x705 2)))
(let ((?x39 (mod$ n$ 2)))
(let (($x515 (>= ?x39 1)))
(let (($x725 (not $x515)))
(let (($x514 (<= ?x39 1)))
(let ((?x519 (mod n$ 2)))
(let ((?x534 (* (- 1) ?x519)))
(let ((?x535 (+ ?x39 ?x534)))
(let (($x408 (<= ?x535 0)))
(let (($x490 (= ?x535 0)))
(let (($x191 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x108 (mod ?v0 ?v1)))
(let ((?x65 (* (- 1) ?v1)))
(let ((?x62 (* (- 1) ?v0)))
(let ((?x116 (mod ?x62 ?x65)))
(let ((?x122 (* (- 1) ?x116)))
(let (($x83 (<= ?v1 0)))
(let ((?x142 (ite $x83 ?x122 ?x108)))
(let (($x50 (= ?v1 0)))
(let ((?x147 (ite $x50 ?v0 ?x142)))
(let ((?x107 (mod$ ?v0 ?v1)))
(= ?x107 ?x147))))))))))) :pattern ( (mod$ ?v0 ?v1) )))
))
(let (($x153 (forall ((?v0 Int) (?v1 Int) )(let ((?x108 (mod ?v0 ?v1)))
(let ((?x65 (* (- 1) ?v1)))
(let ((?x62 (* (- 1) ?v0)))
(let ((?x116 (mod ?x62 ?x65)))
(let ((?x122 (* (- 1) ?x116)))
(let (($x83 (<= ?v1 0)))
(let ((?x142 (ite $x83 ?x122 ?x108)))
(let (($x50 (= ?v1 0)))
(let ((?x147 (ite $x50 ?v0 ?x142)))
(let ((?x107 (mod$ ?v0 ?v1)))
(= ?x107 ?x147))))))))))))
))
(let ((?x108 (mod ?1 ?0)))
(let ((?x65 (* (- 1) ?0)))
(let ((?x62 (* (- 1) ?1)))
(let ((?x116 (mod ?x62 ?x65)))
(let ((?x122 (* (- 1) ?x116)))
(let (($x83 (<= ?0 0)))
(let ((?x142 (ite $x83 ?x122 ?x108)))
(let (($x50 (= ?0 0)))
(let ((?x147 (ite $x50 ?1 ?x142)))
(let ((?x107 (mod$ ?1 ?0)))
(let (($x150 (= ?x107 ?x147)))
(let (($x114 (forall ((?v0 Int) (?v1 Int) )(let (($x50 (= ?v1 0)))
(let ((?x112 (ite $x50 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
(let ((?x107 (mod$ ?v0 ?v1)))
(= ?x107 ?x112)))))
))
(let (($x136 (forall ((?v0 Int) (?v1 Int) )(let ((?x65 (* (- 1) ?v1)))
(let ((?x62 (* (- 1) ?v0)))
(let ((?x116 (mod ?x62 ?x65)))
(let ((?x122 (* (- 1) ?x116)))
(let ((?x108 (mod ?v0 ?v1)))
(let (($x51 (< 0 ?v1)))
(let ((?x127 (ite $x51 ?x108 ?x122)))
(let (($x50 (= ?v1 0)))
(let ((?x130 (ite $x50 ?v0 ?x127)))
(let ((?x107 (mod$ ?v0 ?v1)))
(= ?x107 ?x130))))))))))))
))
(let ((@x141 (monotonicity (rewrite (= (< 0 ?0) (not $x83))) (= (ite (< 0 ?0) ?x108 ?x122) (ite (not $x83) ?x108 ?x122)))))
(let ((@x146 (trans @x141 (rewrite (= (ite (not $x83) ?x108 ?x122) ?x142)) (= (ite (< 0 ?0) ?x108 ?x122) ?x142))))
(let ((@x149 (monotonicity @x146 (= (ite $x50 ?1 (ite (< 0 ?0) ?x108 ?x122)) ?x147))))
(let ((@x152 (monotonicity @x149 (= (= ?x107 (ite $x50 ?1 (ite (< 0 ?0) ?x108 ?x122))) $x150))))
(let (($x51 (< 0 ?0)))
(let ((?x127 (ite $x51 ?x108 ?x122)))
(let ((?x130 (ite $x50 ?1 ?x127)))
(let (($x133 (= ?x107 ?x130)))
(let (($x134 (= (= ?x107 (ite $x50 ?1 (ite $x51 ?x108 (- (mod (- ?1) (- ?0)))))) $x133)))
(let ((@x118 (monotonicity (rewrite (= (- ?1) ?x62)) (rewrite (= (- ?0) ?x65)) (= (mod (- ?1) (- ?0)) ?x116))))
(let ((@x126 (trans (monotonicity @x118 (= (- (mod (- ?1) (- ?0))) (- ?x116))) (rewrite (= (- ?x116) ?x122)) (= (- (mod (- ?1) (- ?0))) ?x122))))
(let ((@x129 (monotonicity @x126 (= (ite $x51 ?x108 (- (mod (- ?1) (- ?0)))) ?x127))))
(let ((@x132 (monotonicity @x129 (= (ite $x50 ?1 (ite $x51 ?x108 (- (mod (- ?1) (- ?0))))) ?x130))))
(let ((@x157 (trans (quant-intro (monotonicity @x132 $x134) (= $x114 $x136)) (quant-intro @x152 (= $x136 $x153)) (= $x114 $x153))))
(let ((@x168 (mp~ (mp (asserted $x114) @x157 $x153) (nnf-pos (refl (~ $x150 $x150)) (~ $x153 $x153)) $x153)))
(let ((@x196 (mp @x168 (quant-intro (refl (= $x150 $x150)) (= $x153 $x191)) $x191)))
(let (($x260 (not $x191)))
(let (($x541 (or $x260 $x490)))
(let ((?x211 (* (- 1) 2)))
(let ((?x222 (* (- 1) n$)))
(let ((?x517 (mod ?x222 ?x211)))
(let ((?x518 (* (- 1) ?x517)))
(let (($x209 (<= 2 0)))
(let ((?x520 (ite $x209 ?x518 ?x519)))
(let (($x208 (= 2 0)))
(let ((?x521 (ite $x208 n$ ?x520)))
(let (($x485 (= ?x39 ?x521)))
(let ((@x593 (monotonicity (monotonicity (rewrite (= ?x211 (- 2))) (= ?x517 (mod ?x222 (- 2)))) (= ?x518 (* (- 1) (mod ?x222 (- 2)))))))
(let ((@x221 (rewrite (= $x209 false))))
(let ((@x596 (monotonicity @x221 @x593 (= ?x520 (ite false (* (- 1) (mod ?x222 (- 2))) ?x519)))))
(let ((@x599 (trans @x596 (rewrite (= (ite false (* (- 1) (mod ?x222 (- 2))) ?x519) ?x519)) (= ?x520 ?x519))))
(let ((@x219 (rewrite (= $x208 false))))
(let ((@x487 (trans (monotonicity @x219 @x599 (= ?x521 (ite false n$ ?x519))) (rewrite (= (ite false n$ ?x519) ?x519)) (= ?x521 ?x519))))
(let ((@x538 (trans (monotonicity @x487 (= $x485 (= ?x39 ?x519))) (rewrite (= (= ?x39 ?x519) $x490)) (= $x485 $x490))))
(let ((@x406 (trans (monotonicity @x538 (= (or $x260 $x485) $x541)) (rewrite (= $x541 $x541)) (= (or $x260 $x485) $x541))))
(let ((@x407 (mp ((_ quant-inst n$ 2) (or $x260 $x485)) @x406 $x541)))
(let ((@x715 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x490) $x408)) (unit-resolution @x407 @x196 $x490) $x408)))
(let (($x303 (>= ?x519 2)))
(let (($x304 (not $x303)))
(let ((@x26 (true-axiom true)))
(let ((@x722 (unit-resolution ((_ th-lemma arith assign-bounds 1 1) (or $x514 $x303 (not $x408))) (unit-resolution ((_ th-lemma arith) (or false $x304)) @x26 $x304) @x715 $x514)))
(let (($x41 (= ?x39 1)))
(let (($x169 (not $x41)))
(let ((?x42 (mod$ m$ 2)))
(let (($x43 (= ?x42 1)))
(let ((?x29 (+ n$ m$)))
(let ((?x214 (mod ?x29 2)))
(let ((?x253 (* (- 1) ?x214)))
(let ((?x31 (mod$ ?x29 2)))
(let ((?x603 (+ n$ m$ ?x31 ?x35 ?x253 (* (- 1) (div ?x29 2)) ?x363 ?x601 (* (- 1) (div m$ 2)))))
(let (($x604 (>= ?x603 2)))
(let (($x523 (>= ?x42 1)))
(let (($x609 (not $x523)))
(let (($x522 (<= ?x42 1)))
(let ((?x439 (mod m$ 2)))
(let ((?x466 (* (- 1) ?x439)))
(let ((?x467 (+ ?x42 ?x466)))
(let (($x482 (<= ?x467 0)))
(let (($x468 (= ?x467 0)))
(let (($x473 (or $x260 $x468)))
(let ((?x440 (ite $x209 (* (- 1) (mod (* (- 1) m$) ?x211)) ?x439)))
(let ((?x441 (ite $x208 m$ ?x440)))
(let (($x442 (= ?x42 ?x441)))
(let ((@x453 (rewrite (= (ite false (* (- 1) (mod (* (- 1) m$) (- 2))) ?x439) ?x439))))
(let (($x447 (= (* (- 1) (mod (* (- 1) m$) ?x211)) (* (- 1) (mod (* (- 1) m$) (- 2))))))
(let ((@x229 (rewrite (= ?x211 (- 2)))))
(let ((@x445 (monotonicity @x229 (= (mod (* (- 1) m$) ?x211) (mod (* (- 1) m$) (- 2))))))
(let ((@x451 (monotonicity @x221 (monotonicity @x445 $x447) (= ?x440 (ite false (* (- 1) (mod (* (- 1) m$) (- 2))) ?x439)))))
(let ((@x458 (monotonicity @x219 (trans @x451 @x453 (= ?x440 ?x439)) (= ?x441 (ite false m$ ?x439)))))
(let ((@x465 (monotonicity (trans @x458 (rewrite (= (ite false m$ ?x439) ?x439)) (= ?x441 ?x439)) (= $x442 (= ?x42 ?x439)))))
(let ((@x477 (monotonicity (trans @x465 (rewrite (= (= ?x42 ?x439) $x468)) (= $x442 $x468)) (= (or $x260 $x442) $x473))))
(let ((@x481 (mp ((_ quant-inst m$ 2) (or $x260 $x442)) (trans @x477 (rewrite (= $x473 $x473)) (= (or $x260 $x442) $x473)) $x473)))
(let ((@x277 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x468) $x482)) (unit-resolution @x481 @x196 $x468) $x482)))
(let ((@x386 (unit-resolution ((_ th-lemma arith) (or false (not (>= ?x439 2)))) @x26 (not (>= ?x439 2)))))
(let ((@x384 (unit-resolution ((_ th-lemma arith assign-bounds 1 1) (or $x522 (>= ?x439 2) (not $x482))) @x386 @x277 $x522)))
(let ((@x564 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x43 (not $x522) $x609)) (hypothesis (not $x43)) (or (not $x522) $x609))))
(let ((?x272 (div ?x29 2)))
(let ((?x288 (* (- 2) ?x272)))
(let ((?x289 (+ n$ m$ ?x253 ?x288)))
(let (($x294 (<= ?x289 0)))
(let (($x287 (= ?x289 0)))
(let ((@x617 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x287) $x294)) (unit-resolution ((_ th-lemma arith) (or false $x287)) @x26 $x287) $x294)))
(let (($x433 (<= ?x31 0)))
(let (($x32 (= ?x31 0)))
(let ((@x33 (asserted $x32)))
(let ((?x254 (+ ?x31 ?x253)))
(let (($x270 (<= ?x254 0)))
(let (($x255 (= ?x254 0)))
(let (($x261 (or $x260 $x255)))
(let ((?x215 (ite $x209 (* (- 1) (mod (* (- 1) ?x29) ?x211)) ?x214)))
(let ((?x216 (ite $x208 ?x29 ?x215)))
(let (($x217 (= ?x31 ?x216)))
(let (($x239 (= (ite false (* (- 1) (mod (+ ?x222 (* (- 1) m$)) (- 2))) ?x214) ?x214)))
(let (($x237 (= ?x215 (ite false (* (- 1) (mod (+ ?x222 (* (- 1) m$)) (- 2))) ?x214))))
(let (($x234 (= (* (- 1) (mod (* (- 1) ?x29) ?x211)) (* (- 1) (mod (+ ?x222 (* (- 1) m$)) (- 2))))))
(let ((@x232 (monotonicity (rewrite (= (* (- 1) ?x29) (+ ?x222 (* (- 1) m$)))) @x229 (= (mod (* (- 1) ?x29) ?x211) (mod (+ ?x222 (* (- 1) m$)) (- 2))))))
(let ((@x242 (trans (monotonicity @x221 (monotonicity @x232 $x234) $x237) (rewrite $x239) (= ?x215 ?x214))))
(let ((@x249 (trans (monotonicity @x219 @x242 (= ?x216 (ite false ?x29 ?x214))) (rewrite (= (ite false ?x29 ?x214) ?x214)) (= ?x216 ?x214))))
(let ((@x259 (trans (monotonicity @x249 (= $x217 (= ?x31 ?x214))) (rewrite (= (= ?x31 ?x214) $x255)) (= $x217 $x255))))
(let ((@x268 (trans (monotonicity @x259 (= (or $x260 $x217) $x261)) (rewrite (= $x261 $x261)) (= (or $x260 $x217) $x261))))
(let ((@x269 (mp ((_ quant-inst (+ n$ m$) 2) (or $x260 $x217)) @x268 $x261)))
(let ((@x626 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x255) $x270)) (unit-resolution @x269 @x196 $x255) $x270)))
(let ((?x498 (+ m$ ?x466 (* (- 2) (div m$ 2)))))
(let (($x496 (= ?x498 0)))
(let ((@x633 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x496) (<= ?x498 0))) (unit-resolution ((_ th-lemma arith) (or false $x496)) @x26 $x496) (<= ?x498 0))))
(let ((?x397 (* (- 4) ?x381)))
(let ((?x398 (+ n$ ?x363 ?x397)))
(let (($x403 (<= ?x398 0)))
(let (($x396 (= ?x398 0)))
(let ((@x640 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x396) $x403)) (unit-resolution ((_ th-lemma arith) (or false $x396)) @x26 $x396) $x403)))
(let ((?x364 (+ ?x35 ?x363)))
(let (($x379 (<= ?x364 0)))
(let (($x365 (= ?x364 0)))
(let (($x370 (or $x260 $x365)))
(let ((?x330 (ite (<= 4 0) (* (- 1) (mod ?x222 (* (- 1) 4))) ?x329)))
(let ((?x331 (ite (= 4 0) n$ ?x330)))
(let (($x332 (= ?x35 ?x331)))
(let ((@x342 (monotonicity (rewrite (= (* (- 1) 4) (- 4))) (= (mod ?x222 (* (- 1) 4)) (mod ?x222 (- 4))))))
(let ((@x345 (monotonicity @x342 (= (* (- 1) (mod ?x222 (* (- 1) 4))) (* (- 1) (mod ?x222 (- 4)))))))
(let ((@x348 (monotonicity (rewrite (= (<= 4 0) false)) @x345 (= ?x330 (ite false (* (- 1) (mod ?x222 (- 4))) ?x329)))))
(let ((@x352 (trans @x348 (rewrite (= (ite false (* (- 1) (mod ?x222 (- 4))) ?x329) ?x329)) (= ?x330 ?x329))))
(let ((@x355 (monotonicity (rewrite (= (= 4 0) false)) @x352 (= ?x331 (ite false n$ ?x329)))))
(let ((@x362 (monotonicity (trans @x355 (rewrite (= (ite false n$ ?x329) ?x329)) (= ?x331 ?x329)) (= $x332 (= ?x35 ?x329)))))
(let ((@x374 (monotonicity (trans @x362 (rewrite (= (= ?x35 ?x329) $x365)) (= $x332 $x365)) (= (or $x260 $x332) $x370))))
(let ((@x378 (mp ((_ quant-inst n$ 4) (or $x260 $x332)) (trans @x374 (rewrite (= $x370 $x370)) (= (or $x260 $x332) $x370)) $x370)))
(let ((@x645 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x365) $x379)) (unit-resolution @x378 @x196 $x365) $x379)))
(let (($x435 (<= ?x35 3)))
(let (($x37 (= ?x35 3)))
(let ((@x38 (asserted $x37)))
(let ((@x655 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x468) (>= ?x467 0))) (unit-resolution @x481 @x196 $x468) (>= ?x467 0))))
(let ((@x656 ((_ th-lemma arith farkas -1 1 -2 1 1 1 1 1 1 1) @x655 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x37) $x435)) @x38 $x435) (hypothesis $x604) @x645 @x640 @x633 @x626 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x32) $x433)) @x33 $x433) @x617 (hypothesis $x609) false)))
(let ((@x565 (unit-resolution (lemma @x656 (or (not $x604) $x523)) (unit-resolution @x564 @x384 $x609) (not $x604))))
(let (($x295 (>= ?x289 0)))
(let ((@x566 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x287) $x295)) (unit-resolution ((_ th-lemma arith) (or false $x287)) @x26 $x287) $x295)))
(let (($x434 (>= ?x31 0)))
(let (($x271 (>= ?x254 0)))
(let ((@x531 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x255) $x271)) (unit-resolution @x269 @x196 $x255) $x271)))
(let ((@x537 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x496) (>= ?x498 0))) (unit-resolution ((_ th-lemma arith) (or false $x496)) @x26 $x496) (>= ?x498 0))))
(let ((@x549 (unit-resolution ((_ th-lemma arith) (or false (>= ?x439 0))) @x26 (>= ?x439 0))))
(let (($x404 (>= ?x398 0)))
(let ((@x552 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x396) $x404)) (unit-resolution ((_ th-lemma arith) (or false $x396)) @x26 $x396) $x404)))
(let (($x380 (>= ?x364 0)))
(let ((@x273 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x365) $x380)) (unit-resolution @x378 @x196 $x365) $x380)))
(let (($x436 (>= ?x35 3)))
(let ((@x545 ((_ th-lemma arith farkas -1/2 -1/2 -1/2 -1/2 -1/2 -1/2 -1/2 -1/2 1) (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x37) $x436)) @x38 $x436) @x273 @x552 @x549 @x537 @x531 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x32) $x434)) @x33 $x434) @x566 @x565 false)))
(let (($x171 (or $x169 (not $x43))))
(let ((@x177 (monotonicity (rewrite (= (and $x41 $x43) (not $x171))) (= (not (and $x41 $x43)) (not (not $x171))))))
(let ((@x181 (trans @x177 (rewrite (= (not (not $x171)) $x171)) (= (not (and $x41 $x43)) $x171))))
(let ((@x182 (mp (asserted (not (and $x41 $x43))) @x181 $x171)))
(let ((@x729 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x41 (not $x514) $x725)) (unit-resolution @x182 (lemma @x545 $x43) $x169) (or (not $x514) $x725))))
(let ((?x420 (* (- 2) ?x410)))
(let ((?x421 (+ n$ ?x420 ?x534)))
(let (($x426 (<= ?x421 0)))
(let (($x419 (= ?x421 0)))
(let ((@x737 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x419) $x426)) (unit-resolution ((_ th-lemma arith) (or false $x419)) @x26 $x419) $x426)))
(let (($x409 (>= ?x535 0)))
(let ((@x741 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x490) $x409)) (unit-resolution @x407 @x196 $x490) $x409)))
(let ((@x742 ((_ th-lemma arith farkas -1 1 -2 1 1 1 1) @x741 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x37) $x435)) @x38 $x435) (hypothesis $x706) @x640 @x737 @x645 (unit-resolution @x729 @x722 $x725) false)))
(let (($x427 (>= ?x421 0)))
(let ((@x584 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x419) $x427)) (unit-resolution ((_ th-lemma arith) (or false $x419)) @x26 $x419) $x427)))
(let (($x542 (>= ?x519 0)))
((_ th-lemma arith farkas -1/2 -1/2 -1/2 -1/2 -1/2 1) (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x37) $x436)) @x38 $x436) @x552 (unit-resolution ((_ th-lemma arith) (or false $x542)) @x26 $x542) @x584 @x273 (lemma @x742 (not $x706)) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

f6a4c40290fd6742c0b08a1fe90b3664e90c2143 336 0
unsat
((set-logic <null>)
(proof
(let ((?x99 (mod$ l$ 2)))
(let ((?x96 (map$ uu$ xs$)))
(let ((?x97 (eval_dioph$ ks$ ?x96)))
(let ((?x98 (mod$ ?x97 2)))
(let (($x100 (= ?x98 ?x99)))
(let ((?x93 (eval_dioph$ ks$ xs$)))
(let (($x95 (= ?x93 l$)))
(let ((?x110 (* (- 1) ?x97)))
(let ((?x111 (+ l$ ?x110)))
(let ((?x114 (divide$ ?x111 2)))
(let ((?x101 (map$ uua$ xs$)))
(let ((?x102 (eval_dioph$ ks$ ?x101)))
(let (($x117 (= ?x102 ?x114)))
(let (($x282 (not $x117)))
(let (($x281 (not $x100)))
(let (($x283 (or $x281 $x282)))
(let ((?x744 (div ?x93 2)))
(let ((?x970 (* (- 1) ?x744)))
(let ((?x699 (mod ?x93 2)))
(let ((?x726 (* (- 1) ?x699)))
(let ((?x516 (mod l$ 2)))
(let ((?x543 (* (- 1) ?x516)))
(let (($x972 (>= (+ l$ ?x99 ?x543 (* (- 1) (div l$ 2)) ?x726 ?x970) 1)))
(let ((?x369 (* (- 1) l$)))
(let ((?x693 (+ ?x93 ?x369)))
(let (($x695 (>= ?x693 0)))
(let (($x861 (not $x695)))
(let (($x694 (<= ?x693 0)))
(let ((?x686 (+ ?x102 (* (- 1) ?x114))))
(let (($x687 (<= ?x686 0)))
(let (($x284 (not $x283)))
(let ((@x466 (hypothesis $x284)))
(let ((@x856 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x282 $x687)) (unit-resolution (def-axiom (or $x283 $x117)) @x466 $x117) $x687)))
(let ((?x437 (+ l$ ?x110 (* (- 2) (div ?x111 2)) (* (- 1) (mod (+ l$ ?x97) 2)))))
(let (($x443 (>= ?x437 0)))
(let (($x434 (= ?x437 0)))
(let ((@x26 (true-axiom true)))
(let ((@x793 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x434) $x443)) (unit-resolution ((_ th-lemma arith) (or false $x434)) @x26 $x434) $x443)))
(let ((?x501 (* (- 2) ?x102)))
(let ((?x502 (+ ?x93 ?x110 ?x501)))
(let (($x509 (<= ?x502 0)))
(let (($x503 (= ?x502 0)))
(let (($x304 (forall ((?v0 Int_list$) (?v1 Int_list$) )(!(let ((?x45 (eval_dioph$ ?v0 ?v1)))
(let ((?x83 (+ ?x45 (* (- 1) (eval_dioph$ ?v0 (map$ uu$ ?v1))) (* (- 2) (eval_dioph$ ?v0 (map$ uua$ ?v1))))))
(= ?x83 0))) :pattern ( (eval_dioph$ ?v0 (map$ uu$ ?v1)) ) :pattern ( (eval_dioph$ ?v0 (map$ uua$ ?v1)) )))
))
(let (($x85 (forall ((?v0 Int_list$) (?v1 Int_list$) )(let ((?x45 (eval_dioph$ ?v0 ?v1)))
(let ((?x83 (+ ?x45 (* (- 1) (eval_dioph$ ?v0 (map$ uu$ ?v1))) (* (- 2) (eval_dioph$ ?v0 (map$ uua$ ?v1))))))
(= ?x83 0))))
))
(let ((?x45 (eval_dioph$ ?1 ?0)))
(let ((?x83 (+ ?x45 (* (- 1) (eval_dioph$ ?1 (map$ uu$ ?0))) (* (- 2) (eval_dioph$ ?1 (map$ uua$ ?0))))))
(let (($x79 (= ?x83 0)))
(let (($x58 (forall ((?v0 Int_list$) (?v1 Int_list$) )(let ((?x45 (eval_dioph$ ?v0 ?v1)))
(let ((?x48 (eval_dioph$ ?v0 (map$ uu$ ?v1))))
(let ((?x56 (+ (* (eval_dioph$ ?v0 (map$ uua$ ?v1)) 2) ?x48)))
(= ?x56 ?x45)))))
))
(let (($x74 (forall ((?v0 Int_list$) (?v1 Int_list$) )(let ((?x45 (eval_dioph$ ?v0 ?v1)))
(let ((?x54 (eval_dioph$ ?v0 (map$ uua$ ?v1))))
(let ((?x60 (* 2 ?x54)))
(let ((?x48 (eval_dioph$ ?v0 (map$ uu$ ?v1))))
(let ((?x66 (+ ?x48 ?x60)))
(= ?x66 ?x45)))))))
))
(let ((?x54 (eval_dioph$ ?1 (map$ uua$ ?0))))
(let ((?x60 (* 2 ?x54)))
(let ((?x48 (eval_dioph$ ?1 (map$ uu$ ?0))))
(let ((?x66 (+ ?x48 ?x60)))
(let (($x71 (= ?x66 ?x45)))
(let ((@x65 (monotonicity (rewrite (= (* ?x54 2) ?x60)) (= (+ (* ?x54 2) ?x48) (+ ?x60 ?x48)))))
(let ((@x70 (trans @x65 (rewrite (= (+ ?x60 ?x48) ?x66)) (= (+ (* ?x54 2) ?x48) ?x66))))
(let ((@x76 (quant-intro (monotonicity @x70 (= (= (+ (* ?x54 2) ?x48) ?x45) $x71)) (= $x58 $x74))))
(let ((@x89 (trans @x76 (quant-intro (rewrite (= $x71 $x79)) (= $x74 $x85)) (= $x58 $x85))))
(let ((@x270 (mp~ (mp (asserted $x58) @x89 $x85) (nnf-pos (refl (~ $x79 $x79)) (~ $x85 $x85)) $x85)))
(let ((@x309 (mp @x270 (quant-intro (refl (= $x79 $x79)) (= $x85 $x304)) $x304)))
(let (($x507 (or (not $x304) $x503)))
(let ((@x508 ((_ quant-inst ks$ xs$) $x507)))
(let ((@x800 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x503) $x509)) (unit-resolution @x508 @x309 $x503) $x509)))
(let ((?x396 (+ ?x114 (* (- 1) (div ?x111 2)))))
(let (($x413 (<= ?x396 0)))
(let (($x397 (= ?x396 0)))
(let (($x311 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x145 (div ?v0 ?v1)))
(let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x160 (div ?x154 ?x157)))
(let (($x175 (<= ?v1 0)))
(let ((?x182 (ite $x175 ?x160 ?x145)))
(let (($x143 (= ?v1 0)))
(let ((?x141 (divide$ ?v0 ?v1)))
(= ?x141 (ite $x143 0 ?x182)))))))))) :pattern ( (divide$ ?v0 ?v1) )))
))
(let (($x193 (forall ((?v0 Int) (?v1 Int) )(let ((?x145 (div ?v0 ?v1)))
(let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x160 (div ?x154 ?x157)))
(let (($x175 (<= ?v1 0)))
(let ((?x182 (ite $x175 ?x160 ?x145)))
(let (($x143 (= ?v1 0)))
(let ((?x141 (divide$ ?v0 ?v1)))
(= ?x141 (ite $x143 0 ?x182)))))))))))
))
(let ((?x145 (div ?1 ?0)))
(let ((?x157 (* (- 1) ?0)))
(let ((?x154 (* (- 1) ?1)))
(let ((?x160 (div ?x154 ?x157)))
(let (($x175 (<= ?0 0)))
(let ((?x182 (ite $x175 ?x160 ?x145)))
(let (($x143 (= ?0 0)))
(let ((?x141 (divide$ ?1 ?0)))
(let (($x190 (= ?x141 (ite $x143 0 ?x182))))
(let (($x152 (forall ((?v0 Int) (?v1 Int) )(let (($x143 (= ?v1 0)))
(let ((?x150 (ite $x143 0 (ite (< 0 ?v1) (div ?v0 ?v1) (div (- ?v0) (- ?v1))))))
(let ((?x141 (divide$ ?v0 ?v1)))
(= ?x141 ?x150)))))
))
(let (($x172 (forall ((?v0 Int) (?v1 Int) )(let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x160 (div ?x154 ?x157)))
(let ((?x145 (div ?v0 ?v1)))
(let (($x144 (< 0 ?v1)))
(let ((?x163 (ite $x144 ?x145 ?x160)))
(let (($x143 (= ?v1 0)))
(let ((?x166 (ite $x143 0 ?x163)))
(let ((?x141 (divide$ ?v0 ?v1)))
(= ?x141 ?x166)))))))))))
))
(let (($x144 (< 0 ?0)))
(let ((?x163 (ite $x144 ?x145 ?x160)))
(let ((?x166 (ite $x143 0 ?x163)))
(let ((@x181 (monotonicity (rewrite (= $x144 (not $x175))) (= ?x163 (ite (not $x175) ?x145 ?x160)))))
(let ((@x186 (trans @x181 (rewrite (= (ite (not $x175) ?x145 ?x160) ?x182)) (= ?x163 ?x182))))
(let ((@x192 (monotonicity (monotonicity @x186 (= ?x166 (ite $x143 0 ?x182))) (= (= ?x141 ?x166) $x190))))
(let (($x169 (= ?x141 ?x166)))
(let (($x170 (= (= ?x141 (ite $x143 0 (ite $x144 ?x145 (div (- ?1) (- ?0))))) $x169)))
(let ((@x162 (monotonicity (rewrite (= (- ?1) ?x154)) (rewrite (= (- ?0) ?x157)) (= (div (- ?1) (- ?0)) ?x160))))
(let ((@x168 (monotonicity (monotonicity @x162 (= (ite $x144 ?x145 (div (- ?1) (- ?0))) ?x163)) (= (ite $x143 0 (ite $x144 ?x145 (div (- ?1) (- ?0)))) ?x166))))
(let ((@x197 (trans (quant-intro (monotonicity @x168 $x170) (= $x152 $x172)) (quant-intro @x192 (= $x172 $x193)) (= $x152 $x193))))
(let ((@x275 (mp~ (mp (asserted $x152) @x197 $x193) (nnf-pos (refl (~ $x190 $x190)) (~ $x193 $x193)) $x193)))
(let ((@x316 (mp @x275 (quant-intro (refl (= $x190 $x190)) (= $x193 $x311)) $x311)))
(let (($x403 (or (not $x311) $x397)))
(let ((?x361 (div ?x111 2)))
(let (($x357 (<= 2 0)))
(let ((?x362 (ite $x357 (div (* (- 1) ?x111) (* (- 1) 2)) ?x361)))
(let (($x356 (= 2 0)))
(let ((?x363 (ite $x356 0 ?x362)))
(let (($x364 (= ?x114 ?x363)))
(let ((@x374 (rewrite (= (* (- 1) 2) (- 2)))))
(let ((@x377 (monotonicity (rewrite (= (* (- 1) ?x111) (+ ?x369 ?x97))) @x374 (= (div (* (- 1) ?x111) (* (- 1) 2)) (div (+ ?x369 ?x97) (- 2))))))
(let ((@x368 (rewrite (= $x357 false))))
(let ((@x380 (monotonicity @x368 @x377 (= ?x362 (ite false (div (+ ?x369 ?x97) (- 2)) ?x361)))))
(let ((@x384 (trans @x380 (rewrite (= (ite false (div (+ ?x369 ?x97) (- 2)) ?x361) ?x361)) (= ?x362 ?x361))))
(let ((@x366 (rewrite (= $x356 false))))
(let ((@x391 (trans (monotonicity @x366 @x384 (= ?x363 (ite false 0 ?x361))) (rewrite (= (ite false 0 ?x361) ?x361)) (= ?x363 ?x361))))
(let ((@x401 (trans (monotonicity @x391 (= $x364 (= ?x114 ?x361))) (rewrite (= (= ?x114 ?x361) $x397)) (= $x364 $x397))))
(let ((@x410 (trans (monotonicity @x401 (= (or (not $x311) $x364) $x403)) (rewrite (= $x403 $x403)) (= (or (not $x311) $x364) $x403))))
(let ((@x802 (unit-resolution (mp ((_ quant-inst (+ l$ ?x110) 2) (or (not $x311) $x364)) @x410 $x403) @x316 $x397)))
(let ((?x425 (mod (+ l$ ?x97) 2)))
(let (($x465 (>= ?x425 0)))
(let ((@x810 ((_ th-lemma arith farkas 1 -2 -2 -1 1 1) (unit-resolution ((_ th-lemma arith) (or false $x465)) @x26 $x465) (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x397) $x413)) @x802 $x413) (hypothesis $x687) @x800 (hypothesis (not $x694)) @x793 false)))
(let (($x134 (not $x95)))
(let (($x290 (= $x95 $x283)))
(let ((@x289 (monotonicity (rewrite (= (and $x100 $x117) $x284)) (= (= $x134 (and $x100 $x117)) (= $x134 $x284)))))
(let ((@x294 (trans @x289 (rewrite (= (= $x134 $x284) $x290)) (= (= $x134 (and $x100 $x117)) $x290))))
(let (($x120 (and $x100 $x117)))
(let (($x135 (= $x134 $x120)))
(let (($x107 (= $x95 (and $x100 (= ?x102 (divide$ (- l$ ?x97) 2))))))
(let (($x108 (not $x107)))
(let ((@x116 (monotonicity (rewrite (= (- l$ ?x97) ?x111)) (= (divide$ (- l$ ?x97) 2) ?x114))))
(let ((@x122 (monotonicity (monotonicity @x116 (= (= ?x102 (divide$ (- l$ ?x97) 2)) $x117)) (= (and $x100 (= ?x102 (divide$ (- l$ ?x97) 2))) $x120))))
(let ((@x130 (trans (monotonicity @x122 (= $x107 (= $x95 $x120))) (rewrite (= (= $x95 $x120) (= $x95 $x120))) (= $x107 (= $x95 $x120)))))
(let ((@x139 (trans (monotonicity @x130 (= $x108 (not (= $x95 $x120)))) (rewrite (= (not (= $x95 $x120)) $x135)) (= $x108 $x135))))
(let ((@x295 (mp (mp (asserted $x108) @x139 $x135) @x294 $x290)))
(let ((@x344 (unit-resolution (def-axiom (or $x134 $x283 (not $x290))) @x295 (or $x134 $x283))))
(let ((@x898 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x95 (not $x694) $x861)) (unit-resolution @x344 @x466 $x134) (or (not $x694) $x861))))
(let ((@x899 (unit-resolution @x898 (unit-resolution (lemma @x810 (or $x694 (not $x687))) @x856 $x694) $x861)))
(let ((?x544 (+ ?x99 ?x543)))
(let (($x561 (>= ?x544 0)))
(let (($x545 (= ?x544 0)))
(let (($x318 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x200 (mod ?v0 ?v1)))
(let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x208 (mod ?x154 ?x157)))
(let ((?x214 (* (- 1) ?x208)))
(let (($x175 (<= ?v1 0)))
(let ((?x234 (ite $x175 ?x214 ?x200)))
(let (($x143 (= ?v1 0)))
(let ((?x239 (ite $x143 ?v0 ?x234)))
(let ((?x199 (mod$ ?v0 ?v1)))
(= ?x199 ?x239))))))))))) :pattern ( (mod$ ?v0 ?v1) )))
))
(let (($x245 (forall ((?v0 Int) (?v1 Int) )(let ((?x200 (mod ?v0 ?v1)))
(let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x208 (mod ?x154 ?x157)))
(let ((?x214 (* (- 1) ?x208)))
(let (($x175 (<= ?v1 0)))
(let ((?x234 (ite $x175 ?x214 ?x200)))
(let (($x143 (= ?v1 0)))
(let ((?x239 (ite $x143 ?v0 ?x234)))
(let ((?x199 (mod$ ?v0 ?v1)))
(= ?x199 ?x239))))))))))))
))
(let ((?x200 (mod ?1 ?0)))
(let ((?x208 (mod ?x154 ?x157)))
(let ((?x214 (* (- 1) ?x208)))
(let ((?x234 (ite $x175 ?x214 ?x200)))
(let ((?x239 (ite $x143 ?1 ?x234)))
(let ((?x199 (mod$ ?1 ?0)))
(let (($x242 (= ?x199 ?x239)))
(let (($x206 (forall ((?v0 Int) (?v1 Int) )(let (($x143 (= ?v1 0)))
(let ((?x204 (ite $x143 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
(let ((?x199 (mod$ ?v0 ?v1)))
(= ?x199 ?x204)))))
))
(let (($x228 (forall ((?v0 Int) (?v1 Int) )(let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x208 (mod ?x154 ?x157)))
(let ((?x214 (* (- 1) ?x208)))
(let ((?x200 (mod ?v0 ?v1)))
(let (($x144 (< 0 ?v1)))
(let ((?x219 (ite $x144 ?x200 ?x214)))
(let (($x143 (= ?v1 0)))
(let ((?x222 (ite $x143 ?v0 ?x219)))
(let ((?x199 (mod$ ?v0 ?v1)))
(= ?x199 ?x222))))))))))))
))
(let ((@x233 (monotonicity (rewrite (= $x144 (not $x175))) (= (ite $x144 ?x200 ?x214) (ite (not $x175) ?x200 ?x214)))))
(let ((@x238 (trans @x233 (rewrite (= (ite (not $x175) ?x200 ?x214) ?x234)) (= (ite $x144 ?x200 ?x214) ?x234))))
(let ((@x244 (monotonicity (monotonicity @x238 (= (ite $x143 ?1 (ite $x144 ?x200 ?x214)) ?x239)) (= (= ?x199 (ite $x143 ?1 (ite $x144 ?x200 ?x214))) $x242))))
(let ((?x219 (ite $x144 ?x200 ?x214)))
(let ((?x222 (ite $x143 ?1 ?x219)))
(let (($x225 (= ?x199 ?x222)))
(let (($x226 (= (= ?x199 (ite $x143 ?1 (ite $x144 ?x200 (- (mod (- ?1) (- ?0)))))) $x225)))
(let ((@x210 (monotonicity (rewrite (= (- ?1) ?x154)) (rewrite (= (- ?0) ?x157)) (= (mod (- ?1) (- ?0)) ?x208))))
(let ((@x218 (trans (monotonicity @x210 (= (- (mod (- ?1) (- ?0))) (- ?x208))) (rewrite (= (- ?x208) ?x214)) (= (- (mod (- ?1) (- ?0))) ?x214))))
(let ((@x221 (monotonicity @x218 (= (ite $x144 ?x200 (- (mod (- ?1) (- ?0)))) ?x219))))
(let ((@x224 (monotonicity @x221 (= (ite $x143 ?1 (ite $x144 ?x200 (- (mod (- ?1) (- ?0))))) ?x222))))
(let ((@x249 (trans (quant-intro (monotonicity @x224 $x226) (= $x206 $x228)) (quant-intro @x244 (= $x228 $x245)) (= $x206 $x245))))
(let ((@x280 (mp~ (mp (asserted $x206) @x249 $x245) (nnf-pos (refl (~ $x242 $x242)) (~ $x245 $x245)) $x245)))
(let ((@x323 (mp @x280 (quant-intro (refl (= $x242 $x242)) (= $x245 $x318)) $x318)))
(let (($x550 (not $x318)))
(let (($x551 (or $x550 $x545)))
(let ((?x359 (* (- 1) 2)))
(let ((?x511 (mod ?x369 ?x359)))
(let ((?x512 (* (- 1) ?x511)))
(let ((?x517 (ite $x357 ?x512 ?x516)))
(let ((?x518 (ite $x356 l$ ?x517)))
(let (($x519 (= ?x99 ?x518)))
(let ((@x525 (monotonicity (monotonicity @x374 (= ?x511 (mod ?x369 (- 2)))) (= ?x512 (* (- 1) (mod ?x369 (- 2)))))))
(let ((@x528 (monotonicity @x368 @x525 (= ?x517 (ite false (* (- 1) (mod ?x369 (- 2))) ?x516)))))
(let ((@x532 (trans @x528 (rewrite (= (ite false (* (- 1) (mod ?x369 (- 2))) ?x516) ?x516)) (= ?x517 ?x516))))
(let ((@x539 (trans (monotonicity @x366 @x532 (= ?x518 (ite false l$ ?x516))) (rewrite (= (ite false l$ ?x516) ?x516)) (= ?x518 ?x516))))
(let ((@x549 (trans (monotonicity @x539 (= $x519 (= ?x99 ?x516))) (rewrite (= (= ?x99 ?x516) $x545)) (= $x519 $x545))))
(let ((@x558 (trans (monotonicity @x549 (= (or $x550 $x519) $x551)) (rewrite (= $x551 $x551)) (= (or $x550 $x519) $x551))))
(let ((@x559 (mp ((_ quant-inst l$ 2) (or $x550 $x519)) @x558 $x551)))
(let ((@x902 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x545) $x561)) (unit-resolution @x559 @x323 $x545) $x561)))
(let ((?x757 (* (- 2) ?x744)))
(let ((?x758 (+ ?x93 ?x726 ?x757)))
(let (($x764 (>= ?x758 0)))
(let (($x756 (= ?x758 0)))
(let ((@x872 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x756) $x764)) (unit-resolution ((_ th-lemma arith) (or false $x756)) @x26 $x756) $x764)))
(let ((?x562 (div l$ 2)))
(let ((?x575 (* (- 2) ?x562)))
(let ((?x576 (+ l$ ?x543 ?x575)))
(let (($x582 (>= ?x576 0)))
(let (($x574 (= ?x576 0)))
(let ((@x880 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x574) $x582)) (unit-resolution ((_ th-lemma arith) (or false $x574)) @x26 $x574) $x582)))
(let ((?x504 (mod$ ?x93 2)))
(let ((?x727 (+ ?x504 ?x726)))
(let (($x728 (= ?x727 0)))
(let (($x733 (or $x550 $x728)))
(let ((?x696 (* (- 1) ?x93)))
(let ((?x697 (mod ?x696 ?x359)))
(let ((?x698 (* (- 1) ?x697)))
(let ((?x700 (ite $x357 ?x698 ?x699)))
(let ((?x701 (ite $x356 ?x93 ?x700)))
(let (($x702 (= ?x504 ?x701)))
(let ((@x708 (monotonicity (monotonicity @x374 (= ?x697 (mod ?x696 (- 2)))) (= ?x698 (* (- 1) (mod ?x696 (- 2)))))))
(let ((@x711 (monotonicity @x368 @x708 (= ?x700 (ite false (* (- 1) (mod ?x696 (- 2))) ?x699)))))
(let ((@x715 (trans @x711 (rewrite (= (ite false (* (- 1) (mod ?x696 (- 2))) ?x699) ?x699)) (= ?x700 ?x699))))
(let ((@x722 (trans (monotonicity @x366 @x715 (= ?x701 (ite false ?x93 ?x699))) (rewrite (= (ite false ?x93 ?x699) ?x699)) (= ?x701 ?x699))))
(let ((@x732 (trans (monotonicity @x722 (= $x702 (= ?x504 ?x699))) (rewrite (= (= ?x504 ?x699) $x728)) (= $x702 $x728))))
(let ((@x740 (trans (monotonicity @x732 (= (or $x550 $x702) $x733)) (rewrite (= $x733 $x733)) (= (or $x550 $x702) $x733))))
(let ((@x427 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x728) (>= ?x727 0))) (unit-resolution (mp ((_ quant-inst (eval_dioph$ ks$ xs$) 2) (or $x550 $x702)) @x740 $x733) @x323 $x728) (>= ?x727 0))))
(let ((?x783 (* (- 1) ?x504)))
(let ((?x784 (+ ?x99 ?x783)))
(let (($x786 (>= ?x784 0)))
(let (($x782 (= ?x99 ?x504)))
(let (($x821 (= ?x98 ?x504)))
(let (($x505 (= ?x504 ?x98)))
(let (($x297 (forall ((?v0 Int_list$) (?v1 Int_list$) )(!(= (mod$ (eval_dioph$ ?v0 ?v1) 2) (mod$ (eval_dioph$ ?v0 (map$ uu$ ?v1)) 2)) :pattern ( (eval_dioph$ ?v0 (map$ uu$ ?v1)) )))
))
(let (($x51 (forall ((?v0 Int_list$) (?v1 Int_list$) )(= (mod$ (eval_dioph$ ?v0 ?v1) 2) (mod$ (eval_dioph$ ?v0 (map$ uu$ ?v1)) 2)))
))
(let (($x50 (= (mod$ ?x45 2) (mod$ ?x48 2))))
(let ((@x265 (mp~ (asserted $x51) (nnf-pos (refl (~ $x50 $x50)) (~ $x51 $x51)) $x51)))
(let ((@x302 (mp @x265 (quant-intro (refl (= $x50 $x50)) (= $x51 $x297)) $x297)))
(let (($x514 (or (not $x297) $x505)))
(let ((@x515 ((_ quant-inst ks$ xs$) $x514)))
(let ((@x824 (symm (unit-resolution (def-axiom (or $x283 $x100)) @x466 $x100) (= ?x99 ?x98))))
(let ((@x939 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x782) $x786)) (trans @x824 (symm (unit-resolution @x515 @x302 $x505) $x821) $x782) $x786)))
(let (($x785 (<= ?x784 0)))
(let ((@x887 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x782) $x785)) (trans @x824 (symm (unit-resolution @x515 @x302 $x505) $x821) $x782) $x785)))
(let (($x688 (>= ?x686 0)))
(let ((@x855 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x282 $x688)) (unit-resolution (def-axiom (or $x283 $x117)) @x466 $x117) $x688)))
(let ((@x979 (unit-resolution ((_ th-lemma arith) (or false (not (>= ?x425 2)))) @x26 (not (>= ?x425 2)))))
(let (($x560 (<= ?x544 0)))
(let ((@x461 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x545) $x560)) (unit-resolution @x559 @x323 $x545) $x560)))
(let (($x763 (<= ?x758 0)))
(let ((@x658 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x756) $x763)) (unit-resolution ((_ th-lemma arith) (or false $x756)) @x26 $x756) $x763)))
(let (($x581 (<= ?x576 0)))
(let ((@x986 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x574) $x581)) (unit-resolution ((_ th-lemma arith) (or false $x574)) @x26 $x574) $x581)))
(let ((@x989 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x728) (<= ?x727 0))) (unit-resolution (mp ((_ quant-inst (eval_dioph$ ks$ xs$) 2) (or $x550 $x702)) @x740 $x733) @x323 $x728) (<= ?x727 0))))
(let (($x510 (>= ?x502 0)))
(let ((@x994 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x503) $x510)) (unit-resolution @x508 @x309 $x503) $x510)))
(let ((@x998 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x397) (>= ?x396 0))) @x802 (>= ?x396 0))))
(let ((@x1001 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x434) (<= ?x437 0))) (unit-resolution ((_ th-lemma arith) (or false $x434)) @x26 $x434) (<= ?x437 0))))
(let ((@x1002 ((_ th-lemma arith farkas 1 -2 -2 -1 -2 1 1 1 1 1 1) @x1001 @x998 (hypothesis $x688) @x994 (hypothesis $x972) (hypothesis $x785) @x989 @x986 @x658 @x461 @x979 false)))
(let ((@x474 (unit-resolution (lemma @x1002 (or (not $x972) (not $x688) (not $x785))) @x855 @x887 (not $x972))))
(let ((@x941 (unit-resolution @x474 ((_ th-lemma arith) @x939 @x427 @x880 @x872 @x902 @x899 $x972) false)))
(let ((@x942 (lemma @x941 $x283)))
(let ((@x340 (unit-resolution (def-axiom (or $x95 $x284 (not $x290))) @x295 (or $x95 $x284))))
(let ((@x679 (unit-resolution @x340 @x942 $x95)))
(let ((@x889 (trans (symm (unit-resolution @x515 @x302 $x505) $x821) (monotonicity @x679 (= ?x504 ?x99)) $x100)))
(let (($x811 (not $x687)))
(let ((@x845 ((_ th-lemma arith assign-bounds 1 -1/2 -1/2 1/2 -1/2) (or $x688 (not $x413) (not $x465) (not $x443) (not $x509) $x861))))
(let ((@x892 (unit-resolution @x845 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x397) $x413)) @x802 $x413) (unit-resolution ((_ th-lemma arith triangle-eq) (or $x134 $x695)) @x679 $x695) @x793 (unit-resolution ((_ th-lemma arith) (or false $x465)) @x26 $x465) @x800 $x688)))
(let ((@x935 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x117 $x811 (not $x688))) (hypothesis $x282) (or $x811 (not $x688)))))
(let ((@x955 ((_ th-lemma arith farkas -2 -2 1 -1 1 1) (unit-resolution @x935 @x892 $x811) @x998 @x1001 @x994 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x134 $x694)) @x679 $x694) @x979 false)))
(let ((@x472 (unit-resolution (unit-resolution (def-axiom (or $x284 $x281 $x282)) @x942 $x283) (lemma @x955 $x117) $x281)))
(unit-resolution @x472 @x889 false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

0f7f4a10f8a84029fd3a6efddc4408fa429b0cda 113 0
unsat
((set-logic <null>)
(proof
(let ((?x228 (mod x$ 2)))
(let ((?x262 (* (- 1) ?x228)))
(let ((?x31 (mod$ x$ 2)))
(let ((?x263 (+ ?x31 ?x262)))
(let (($x280 (>= ?x263 0)))
(let (($x264 (= ?x263 0)))
(let (($x205 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x136 (mod ?v0 ?v1)))
(let ((?x93 (* (- 1) ?v1)))
(let ((?x90 (* (- 1) ?v0)))
(let ((?x144 (mod ?x90 ?x93)))
(let ((?x150 (* (- 1) ?x144)))
(let (($x111 (<= ?v1 0)))
(let ((?x170 (ite $x111 ?x150 ?x136)))
(let (($x78 (= ?v1 0)))
(let ((?x175 (ite $x78 ?v0 ?x170)))
(let ((?x135 (mod$ ?v0 ?v1)))
(= ?x135 ?x175))))))))))) :pattern ( (mod$ ?v0 ?v1) )))
))
(let (($x181 (forall ((?v0 Int) (?v1 Int) )(let ((?x136 (mod ?v0 ?v1)))
(let ((?x93 (* (- 1) ?v1)))
(let ((?x90 (* (- 1) ?v0)))
(let ((?x144 (mod ?x90 ?x93)))
(let ((?x150 (* (- 1) ?x144)))
(let (($x111 (<= ?v1 0)))
(let ((?x170 (ite $x111 ?x150 ?x136)))
(let (($x78 (= ?v1 0)))
(let ((?x175 (ite $x78 ?v0 ?x170)))
(let ((?x135 (mod$ ?v0 ?v1)))
(= ?x135 ?x175))))))))))))
))
(let ((?x136 (mod ?1 ?0)))
(let ((?x93 (* (- 1) ?0)))
(let ((?x90 (* (- 1) ?1)))
(let ((?x144 (mod ?x90 ?x93)))
(let ((?x150 (* (- 1) ?x144)))
(let (($x111 (<= ?0 0)))
(let ((?x170 (ite $x111 ?x150 ?x136)))
(let (($x78 (= ?0 0)))
(let ((?x175 (ite $x78 ?1 ?x170)))
(let ((?x135 (mod$ ?1 ?0)))
(let (($x178 (= ?x135 ?x175)))
(let (($x142 (forall ((?v0 Int) (?v1 Int) )(let (($x78 (= ?v1 0)))
(let ((?x140 (ite $x78 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
(let ((?x135 (mod$ ?v0 ?v1)))
(= ?x135 ?x140)))))
))
(let (($x164 (forall ((?v0 Int) (?v1 Int) )(let ((?x93 (* (- 1) ?v1)))
(let ((?x90 (* (- 1) ?v0)))
(let ((?x144 (mod ?x90 ?x93)))
(let ((?x150 (* (- 1) ?x144)))
(let ((?x136 (mod ?v0 ?v1)))
(let (($x79 (< 0 ?v1)))
(let ((?x155 (ite $x79 ?x136 ?x150)))
(let (($x78 (= ?v1 0)))
(let ((?x158 (ite $x78 ?v0 ?x155)))
(let ((?x135 (mod$ ?v0 ?v1)))
(= ?x135 ?x158))))))))))))
))
(let ((@x169 (monotonicity (rewrite (= (< 0 ?0) (not $x111))) (= (ite (< 0 ?0) ?x136 ?x150) (ite (not $x111) ?x136 ?x150)))))
(let ((@x174 (trans @x169 (rewrite (= (ite (not $x111) ?x136 ?x150) ?x170)) (= (ite (< 0 ?0) ?x136 ?x150) ?x170))))
(let ((@x177 (monotonicity @x174 (= (ite $x78 ?1 (ite (< 0 ?0) ?x136 ?x150)) ?x175))))
(let ((@x180 (monotonicity @x177 (= (= ?x135 (ite $x78 ?1 (ite (< 0 ?0) ?x136 ?x150))) $x178))))
(let (($x79 (< 0 ?0)))
(let ((?x155 (ite $x79 ?x136 ?x150)))
(let ((?x158 (ite $x78 ?1 ?x155)))
(let (($x161 (= ?x135 ?x158)))
(let (($x162 (= (= ?x135 (ite $x78 ?1 (ite $x79 ?x136 (- (mod (- ?1) (- ?0)))))) $x161)))
(let ((@x146 (monotonicity (rewrite (= (- ?1) ?x90)) (rewrite (= (- ?0) ?x93)) (= (mod (- ?1) (- ?0)) ?x144))))
(let ((@x154 (trans (monotonicity @x146 (= (- (mod (- ?1) (- ?0))) (- ?x144))) (rewrite (= (- ?x144) ?x150)) (= (- (mod (- ?1) (- ?0))) ?x150))))
(let ((@x157 (monotonicity @x154 (= (ite $x79 ?x136 (- (mod (- ?1) (- ?0)))) ?x155))))
(let ((@x160 (monotonicity @x157 (= (ite $x78 ?1 (ite $x79 ?x136 (- (mod (- ?1) (- ?0))))) ?x158))))
(let ((@x185 (trans (quant-intro (monotonicity @x160 $x162) (= $x142 $x164)) (quant-intro @x180 (= $x164 $x181)) (= $x142 $x181))))
(let ((@x196 (mp~ (mp (asserted $x142) @x185 $x181) (nnf-pos (refl (~ $x178 $x178)) (~ $x181 $x181)) $x181)))
(let ((@x210 (mp @x196 (quant-intro (refl (= $x178 $x178)) (= $x181 $x205)) $x205)))
(let (($x270 (or (not $x205) $x264)))
(let ((?x225 (* (- 1) 2)))
(let ((?x224 (* (- 1) x$)))
(let ((?x226 (mod ?x224 ?x225)))
(let ((?x227 (* (- 1) ?x226)))
(let (($x223 (<= 2 0)))
(let ((?x229 (ite $x223 ?x227 ?x228)))
(let (($x222 (= 2 0)))
(let ((?x230 (ite $x222 x$ ?x229)))
(let (($x231 (= ?x31 ?x230)))
(let ((@x244 (monotonicity (monotonicity (rewrite (= ?x225 (- 2))) (= ?x226 (mod ?x224 (- 2)))) (= ?x227 (* (- 1) (mod ?x224 (- 2)))))))
(let ((@x247 (monotonicity (rewrite (= $x223 false)) @x244 (= ?x229 (ite false (* (- 1) (mod ?x224 (- 2))) ?x228)))))
(let ((@x251 (trans @x247 (rewrite (= (ite false (* (- 1) (mod ?x224 (- 2))) ?x228) ?x228)) (= ?x229 ?x228))))
(let ((@x254 (monotonicity (rewrite (= $x222 false)) @x251 (= ?x230 (ite false x$ ?x228)))))
(let ((@x261 (monotonicity (trans @x254 (rewrite (= (ite false x$ ?x228) ?x228)) (= ?x230 ?x228)) (= $x231 (= ?x31 ?x228)))))
(let ((@x274 (monotonicity (trans @x261 (rewrite (= (= ?x31 ?x228) $x264)) (= $x231 $x264)) (= (or (not $x205) $x231) $x270))))
(let ((@x277 (trans @x274 (rewrite (= $x270 $x270)) (= (or (not $x205) $x231) $x270))))
(let ((@x278 (mp ((_ quant-inst x$ 2) (or (not $x205) $x231)) @x277 $x270)))
(let ((@x337 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x264) $x280)) (unit-resolution @x278 @x210 $x264) $x280)))
(let (($x305 (>= ?x228 0)))
(let (($x64 (>= ?x31 0)))
(let (($x67 (not $x64)))
(let (($x36 (not (<= (+ x$ 1) (+ x$ (+ (* 2 ?x31) 1))))))
(let ((@x69 (monotonicity (rewrite (= (>= (* 2 ?x31) 0) $x64)) (= (not (>= (* 2 ?x31) 0)) $x67))))
(let ((?x32 (* 2 ?x31)))
(let ((?x47 (+ 1 x$ ?x32)))
(let (($x52 (<= (+ 1 x$) ?x47)))
(let (($x55 (not $x52)))
(let ((@x63 (monotonicity (rewrite (= $x52 (>= ?x32 0))) (= $x55 (not (>= ?x32 0))))))
(let ((@x46 (monotonicity (rewrite (= (+ ?x32 1) (+ 1 ?x32))) (= (+ x$ (+ ?x32 1)) (+ x$ (+ 1 ?x32))))))
(let ((@x51 (trans @x46 (rewrite (= (+ x$ (+ 1 ?x32)) ?x47)) (= (+ x$ (+ ?x32 1)) ?x47))))
(let ((@x54 (monotonicity (rewrite (= (+ x$ 1) (+ 1 x$))) @x51 (= (<= (+ x$ 1) (+ x$ (+ ?x32 1))) $x52))))
(let ((@x73 (trans (monotonicity @x54 (= $x36 $x55)) (trans @x63 @x69 (= $x55 $x67)) (= $x36 $x67))))
(let ((@x74 (mp (asserted $x36) @x73 $x67)))
((_ th-lemma arith farkas -1 1 1) @x74 (unit-resolution ((_ th-lemma arith) (or false $x305)) (true-axiom true) $x305) @x337 false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

fa5abc269019f00f5093218b287856c2a08c0adf 112 0
unsat
((set-logic <null>)
(proof
(let ((?x224 (mod x$ 2)))
(let (($x318 (>= ?x224 2)))
(let (($x319 (not $x318)))
(let ((?x258 (* (- 1) ?x224)))
(let ((?x29 (mod$ x$ 2)))
(let ((?x259 (+ ?x29 ?x258)))
(let (($x275 (<= ?x259 0)))
(let (($x260 (= ?x259 0)))
(let (($x201 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x132 (mod ?v0 ?v1)))
(let ((?x89 (* (- 1) ?v1)))
(let ((?x86 (* (- 1) ?v0)))
(let ((?x140 (mod ?x86 ?x89)))
(let ((?x146 (* (- 1) ?x140)))
(let (($x107 (<= ?v1 0)))
(let ((?x166 (ite $x107 ?x146 ?x132)))
(let (($x74 (= ?v1 0)))
(let ((?x171 (ite $x74 ?v0 ?x166)))
(let ((?x131 (mod$ ?v0 ?v1)))
(= ?x131 ?x171))))))))))) :pattern ( (mod$ ?v0 ?v1) )))
))
(let (($x177 (forall ((?v0 Int) (?v1 Int) )(let ((?x132 (mod ?v0 ?v1)))
(let ((?x89 (* (- 1) ?v1)))
(let ((?x86 (* (- 1) ?v0)))
(let ((?x140 (mod ?x86 ?x89)))
(let ((?x146 (* (- 1) ?x140)))
(let (($x107 (<= ?v1 0)))
(let ((?x166 (ite $x107 ?x146 ?x132)))
(let (($x74 (= ?v1 0)))
(let ((?x171 (ite $x74 ?v0 ?x166)))
(let ((?x131 (mod$ ?v0 ?v1)))
(= ?x131 ?x171))))))))))))
))
(let ((?x132 (mod ?1 ?0)))
(let ((?x89 (* (- 1) ?0)))
(let ((?x86 (* (- 1) ?1)))
(let ((?x140 (mod ?x86 ?x89)))
(let ((?x146 (* (- 1) ?x140)))
(let (($x107 (<= ?0 0)))
(let ((?x166 (ite $x107 ?x146 ?x132)))
(let (($x74 (= ?0 0)))
(let ((?x171 (ite $x74 ?1 ?x166)))
(let ((?x131 (mod$ ?1 ?0)))
(let (($x174 (= ?x131 ?x171)))
(let (($x138 (forall ((?v0 Int) (?v1 Int) )(let (($x74 (= ?v1 0)))
(let ((?x136 (ite $x74 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
(let ((?x131 (mod$ ?v0 ?v1)))
(= ?x131 ?x136)))))
))
(let (($x160 (forall ((?v0 Int) (?v1 Int) )(let ((?x89 (* (- 1) ?v1)))
(let ((?x86 (* (- 1) ?v0)))
(let ((?x140 (mod ?x86 ?x89)))
(let ((?x146 (* (- 1) ?x140)))
(let ((?x132 (mod ?v0 ?v1)))
(let (($x75 (< 0 ?v1)))
(let ((?x151 (ite $x75 ?x132 ?x146)))
(let (($x74 (= ?v1 0)))
(let ((?x154 (ite $x74 ?v0 ?x151)))
(let ((?x131 (mod$ ?v0 ?v1)))
(= ?x131 ?x154))))))))))))
))
(let ((@x165 (monotonicity (rewrite (= (< 0 ?0) (not $x107))) (= (ite (< 0 ?0) ?x132 ?x146) (ite (not $x107) ?x132 ?x146)))))
(let ((@x170 (trans @x165 (rewrite (= (ite (not $x107) ?x132 ?x146) ?x166)) (= (ite (< 0 ?0) ?x132 ?x146) ?x166))))
(let ((@x173 (monotonicity @x170 (= (ite $x74 ?1 (ite (< 0 ?0) ?x132 ?x146)) ?x171))))
(let ((@x176 (monotonicity @x173 (= (= ?x131 (ite $x74 ?1 (ite (< 0 ?0) ?x132 ?x146))) $x174))))
(let (($x75 (< 0 ?0)))
(let ((?x151 (ite $x75 ?x132 ?x146)))
(let ((?x154 (ite $x74 ?1 ?x151)))
(let (($x157 (= ?x131 ?x154)))
(let (($x158 (= (= ?x131 (ite $x74 ?1 (ite $x75 ?x132 (- (mod (- ?1) (- ?0)))))) $x157)))
(let ((@x142 (monotonicity (rewrite (= (- ?1) ?x86)) (rewrite (= (- ?0) ?x89)) (= (mod (- ?1) (- ?0)) ?x140))))
(let ((@x150 (trans (monotonicity @x142 (= (- (mod (- ?1) (- ?0))) (- ?x140))) (rewrite (= (- ?x140) ?x146)) (= (- (mod (- ?1) (- ?0))) ?x146))))
(let ((@x153 (monotonicity @x150 (= (ite $x75 ?x132 (- (mod (- ?1) (- ?0)))) ?x151))))
(let ((@x156 (monotonicity @x153 (= (ite $x74 ?1 (ite $x75 ?x132 (- (mod (- ?1) (- ?0))))) ?x154))))
(let ((@x181 (trans (quant-intro (monotonicity @x156 $x158) (= $x138 $x160)) (quant-intro @x176 (= $x160 $x177)) (= $x138 $x177))))
(let ((@x192 (mp~ (mp (asserted $x138) @x181 $x177) (nnf-pos (refl (~ $x174 $x174)) (~ $x177 $x177)) $x177)))
(let ((@x206 (mp @x192 (quant-intro (refl (= $x174 $x174)) (= $x177 $x201)) $x201)))
(let (($x266 (or (not $x201) $x260)))
(let ((?x221 (* (- 1) 2)))
(let ((?x220 (* (- 1) x$)))
(let ((?x222 (mod ?x220 ?x221)))
(let ((?x223 (* (- 1) ?x222)))
(let (($x219 (<= 2 0)))
(let ((?x225 (ite $x219 ?x223 ?x224)))
(let (($x218 (= 2 0)))
(let ((?x226 (ite $x218 x$ ?x225)))
(let (($x227 (= ?x29 ?x226)))
(let ((@x240 (monotonicity (monotonicity (rewrite (= ?x221 (- 2))) (= ?x222 (mod ?x220 (- 2)))) (= ?x223 (* (- 1) (mod ?x220 (- 2)))))))
(let ((@x243 (monotonicity (rewrite (= $x219 false)) @x240 (= ?x225 (ite false (* (- 1) (mod ?x220 (- 2))) ?x224)))))
(let ((@x247 (trans @x243 (rewrite (= (ite false (* (- 1) (mod ?x220 (- 2))) ?x224) ?x224)) (= ?x225 ?x224))))
(let ((@x250 (monotonicity (rewrite (= $x218 false)) @x247 (= ?x226 (ite false x$ ?x224)))))
(let ((@x257 (monotonicity (trans @x250 (rewrite (= (ite false x$ ?x224) ?x224)) (= ?x226 ?x224)) (= $x227 (= ?x29 ?x224)))))
(let ((@x270 (monotonicity (trans @x257 (rewrite (= (= ?x29 ?x224) $x260)) (= $x227 $x260)) (= (or (not $x201) $x227) $x266))))
(let ((@x273 (trans @x270 (rewrite (= $x266 $x266)) (= (or (not $x201) $x227) $x266))))
(let ((@x274 (mp ((_ quant-inst x$ 2) (or (not $x201) $x227)) @x273 $x266)))
(let ((@x336 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x260) $x275)) (unit-resolution @x274 @x206 $x260) $x275)))
(let (($x63 (>= ?x29 2)))
(let ((?x37 (* 2 ?x29)))
(let (($x56 (>= ?x37 3)))
(let (($x46 (< (+ x$ ?x37) (+ 3 x$))))
(let (($x49 (not $x46)))
(let ((@x58 (monotonicity (rewrite (= $x46 (not $x56))) (= $x49 (not (not $x56))))))
(let ((@x67 (trans (trans @x58 (rewrite (= (not (not $x56)) $x56)) (= $x49 $x56)) (rewrite (= $x56 $x63)) (= $x49 $x63))))
(let ((@x42 (monotonicity (rewrite (= (+ ?x29 ?x29) ?x37)) (= (+ x$ (+ ?x29 ?x29)) (+ x$ ?x37)))))
(let ((@x48 (monotonicity @x42 (rewrite (= (+ x$ 3) (+ 3 x$))) (= (< (+ x$ (+ ?x29 ?x29)) (+ x$ 3)) $x46))))
(let ((@x51 (monotonicity @x48 (= (not (< (+ x$ (+ ?x29 ?x29)) (+ x$ 3))) $x49))))
(let ((@x69 (trans @x51 @x67 (= (not (< (+ x$ (+ ?x29 ?x29)) (+ x$ 3))) $x63))))
(let ((@x70 (mp (asserted (not (< (+ x$ (+ ?x29 ?x29)) (+ x$ 3)))) @x69 $x63)))
((_ th-lemma arith farkas -1 1 1) @x70 @x336 (unit-resolution ((_ th-lemma arith) (or false $x319)) (true-axiom true) $x319) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

1880f0ed1cb3d1cfa006dff17f1b5553ce3a5158 236 0
unsat
((set-logic <null>)
(proof
(let ((?x410 (div n$ 2)))
(let ((?x704 (* (- 1) ?x410)))
(let ((?x381 (div n$ 4)))
(let ((?x601 (* (- 2) ?x381)))
(let ((?x329 (mod n$ 4)))
(let ((?x363 (* (- 1) ?x329)))
(let ((?x35 (mod$ n$ 4)))
(let ((?x705 (+ n$ ?x35 ?x363 ?x601 ?x704)))
(let (($x706 (>= ?x705 2)))
(let ((?x39 (mod$ n$ 2)))
(let (($x515 (>= ?x39 1)))
(let (($x725 (not $x515)))
(let (($x514 (<= ?x39 1)))
(let ((?x519 (mod n$ 2)))
(let ((?x534 (* (- 1) ?x519)))
(let ((?x535 (+ ?x39 ?x534)))
(let (($x408 (<= ?x535 0)))
(let (($x490 (= ?x535 0)))
(let (($x191 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x108 (mod ?v0 ?v1)))
(let ((?x65 (* (- 1) ?v1)))
(let ((?x62 (* (- 1) ?v0)))
(let ((?x116 (mod ?x62 ?x65)))
(let ((?x122 (* (- 1) ?x116)))
(let (($x83 (<= ?v1 0)))
(let ((?x142 (ite $x83 ?x122 ?x108)))
(let (($x50 (= ?v1 0)))
(let ((?x147 (ite $x50 ?v0 ?x142)))
(let ((?x107 (mod$ ?v0 ?v1)))
(= ?x107 ?x147))))))))))) :pattern ( (mod$ ?v0 ?v1) )))
))
(let (($x153 (forall ((?v0 Int) (?v1 Int) )(let ((?x108 (mod ?v0 ?v1)))
(let ((?x65 (* (- 1) ?v1)))
(let ((?x62 (* (- 1) ?v0)))
(let ((?x116 (mod ?x62 ?x65)))
(let ((?x122 (* (- 1) ?x116)))
(let (($x83 (<= ?v1 0)))
(let ((?x142 (ite $x83 ?x122 ?x108)))
(let (($x50 (= ?v1 0)))
(let ((?x147 (ite $x50 ?v0 ?x142)))
(let ((?x107 (mod$ ?v0 ?v1)))
(= ?x107 ?x147))))))))))))
))
(let ((?x108 (mod ?1 ?0)))
(let ((?x65 (* (- 1) ?0)))
(let ((?x62 (* (- 1) ?1)))
(let ((?x116 (mod ?x62 ?x65)))
(let ((?x122 (* (- 1) ?x116)))
(let (($x83 (<= ?0 0)))
(let ((?x142 (ite $x83 ?x122 ?x108)))
(let (($x50 (= ?0 0)))
(let ((?x147 (ite $x50 ?1 ?x142)))
(let ((?x107 (mod$ ?1 ?0)))
(let (($x150 (= ?x107 ?x147)))
(let (($x114 (forall ((?v0 Int) (?v1 Int) )(let (($x50 (= ?v1 0)))
(let ((?x112 (ite $x50 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
(let ((?x107 (mod$ ?v0 ?v1)))
(= ?x107 ?x112)))))
))
(let (($x136 (forall ((?v0 Int) (?v1 Int) )(let ((?x65 (* (- 1) ?v1)))
(let ((?x62 (* (- 1) ?v0)))
(let ((?x116 (mod ?x62 ?x65)))
(let ((?x122 (* (- 1) ?x116)))
(let ((?x108 (mod ?v0 ?v1)))
(let (($x51 (< 0 ?v1)))
(let ((?x127 (ite $x51 ?x108 ?x122)))
(let (($x50 (= ?v1 0)))
(let ((?x130 (ite $x50 ?v0 ?x127)))
(let ((?x107 (mod$ ?v0 ?v1)))
(= ?x107 ?x130))))))))))))
))
(let ((@x141 (monotonicity (rewrite (= (< 0 ?0) (not $x83))) (= (ite (< 0 ?0) ?x108 ?x122) (ite (not $x83) ?x108 ?x122)))))
(let ((@x146 (trans @x141 (rewrite (= (ite (not $x83) ?x108 ?x122) ?x142)) (= (ite (< 0 ?0) ?x108 ?x122) ?x142))))
(let ((@x149 (monotonicity @x146 (= (ite $x50 ?1 (ite (< 0 ?0) ?x108 ?x122)) ?x147))))
(let ((@x152 (monotonicity @x149 (= (= ?x107 (ite $x50 ?1 (ite (< 0 ?0) ?x108 ?x122))) $x150))))
(let (($x51 (< 0 ?0)))
(let ((?x127 (ite $x51 ?x108 ?x122)))
(let ((?x130 (ite $x50 ?1 ?x127)))
(let (($x133 (= ?x107 ?x130)))
(let (($x134 (= (= ?x107 (ite $x50 ?1 (ite $x51 ?x108 (- (mod (- ?1) (- ?0)))))) $x133)))
(let ((@x118 (monotonicity (rewrite (= (- ?1) ?x62)) (rewrite (= (- ?0) ?x65)) (= (mod (- ?1) (- ?0)) ?x116))))
(let ((@x126 (trans (monotonicity @x118 (= (- (mod (- ?1) (- ?0))) (- ?x116))) (rewrite (= (- ?x116) ?x122)) (= (- (mod (- ?1) (- ?0))) ?x122))))
(let ((@x129 (monotonicity @x126 (= (ite $x51 ?x108 (- (mod (- ?1) (- ?0)))) ?x127))))
(let ((@x132 (monotonicity @x129 (= (ite $x50 ?1 (ite $x51 ?x108 (- (mod (- ?1) (- ?0))))) ?x130))))
(let ((@x157 (trans (quant-intro (monotonicity @x132 $x134) (= $x114 $x136)) (quant-intro @x152 (= $x136 $x153)) (= $x114 $x153))))
(let ((@x168 (mp~ (mp (asserted $x114) @x157 $x153) (nnf-pos (refl (~ $x150 $x150)) (~ $x153 $x153)) $x153)))
(let ((@x196 (mp @x168 (quant-intro (refl (= $x150 $x150)) (= $x153 $x191)) $x191)))
(let (($x260 (not $x191)))
(let (($x541 (or $x260 $x490)))
(let ((?x211 (* (- 1) 2)))
(let ((?x222 (* (- 1) n$)))
(let ((?x517 (mod ?x222 ?x211)))
(let ((?x518 (* (- 1) ?x517)))
(let (($x209 (<= 2 0)))
(let ((?x520 (ite $x209 ?x518 ?x519)))
(let (($x208 (= 2 0)))
(let ((?x521 (ite $x208 n$ ?x520)))
(let (($x485 (= ?x39 ?x521)))
(let ((@x593 (monotonicity (monotonicity (rewrite (= ?x211 (- 2))) (= ?x517 (mod ?x222 (- 2)))) (= ?x518 (* (- 1) (mod ?x222 (- 2)))))))
(let ((@x221 (rewrite (= $x209 false))))
(let ((@x596 (monotonicity @x221 @x593 (= ?x520 (ite false (* (- 1) (mod ?x222 (- 2))) ?x519)))))
(let ((@x599 (trans @x596 (rewrite (= (ite false (* (- 1) (mod ?x222 (- 2))) ?x519) ?x519)) (= ?x520 ?x519))))
(let ((@x219 (rewrite (= $x208 false))))
(let ((@x487 (trans (monotonicity @x219 @x599 (= ?x521 (ite false n$ ?x519))) (rewrite (= (ite false n$ ?x519) ?x519)) (= ?x521 ?x519))))
(let ((@x538 (trans (monotonicity @x487 (= $x485 (= ?x39 ?x519))) (rewrite (= (= ?x39 ?x519) $x490)) (= $x485 $x490))))
(let ((@x406 (trans (monotonicity @x538 (= (or $x260 $x485) $x541)) (rewrite (= $x541 $x541)) (= (or $x260 $x485) $x541))))
(let ((@x407 (mp ((_ quant-inst n$ 2) (or $x260 $x485)) @x406 $x541)))
(let ((@x715 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x490) $x408)) (unit-resolution @x407 @x196 $x490) $x408)))
(let (($x303 (>= ?x519 2)))
(let (($x304 (not $x303)))
(let ((@x26 (true-axiom true)))
(let ((@x722 (unit-resolution ((_ th-lemma arith assign-bounds 1 1) (or $x514 $x303 (not $x408))) (unit-resolution ((_ th-lemma arith) (or false $x304)) @x26 $x304) @x715 $x514)))
(let (($x41 (= ?x39 1)))
(let (($x169 (not $x41)))
(let ((?x42 (mod$ m$ 2)))
(let (($x43 (= ?x42 1)))
(let ((?x29 (+ n$ m$)))
(let ((?x214 (mod ?x29 2)))
(let ((?x253 (* (- 1) ?x214)))
(let ((?x31 (mod$ ?x29 2)))
(let ((?x603 (+ n$ m$ ?x31 ?x35 ?x253 (* (- 1) (div ?x29 2)) ?x363 ?x601 (* (- 1) (div m$ 2)))))
(let (($x604 (>= ?x603 2)))
(let (($x523 (>= ?x42 1)))
(let (($x609 (not $x523)))
(let (($x522 (<= ?x42 1)))
(let ((?x439 (mod m$ 2)))
(let ((?x466 (* (- 1) ?x439)))
(let ((?x467 (+ ?x42 ?x466)))
(let (($x482 (<= ?x467 0)))
(let (($x468 (= ?x467 0)))
(let (($x473 (or $x260 $x468)))
(let ((?x440 (ite $x209 (* (- 1) (mod (* (- 1) m$) ?x211)) ?x439)))
(let ((?x441 (ite $x208 m$ ?x440)))
(let (($x442 (= ?x42 ?x441)))
(let ((@x453 (rewrite (= (ite false (* (- 1) (mod (* (- 1) m$) (- 2))) ?x439) ?x439))))
(let (($x447 (= (* (- 1) (mod (* (- 1) m$) ?x211)) (* (- 1) (mod (* (- 1) m$) (- 2))))))
(let ((@x229 (rewrite (= ?x211 (- 2)))))
(let ((@x445 (monotonicity @x229 (= (mod (* (- 1) m$) ?x211) (mod (* (- 1) m$) (- 2))))))
(let ((@x451 (monotonicity @x221 (monotonicity @x445 $x447) (= ?x440 (ite false (* (- 1) (mod (* (- 1) m$) (- 2))) ?x439)))))
(let ((@x458 (monotonicity @x219 (trans @x451 @x453 (= ?x440 ?x439)) (= ?x441 (ite false m$ ?x439)))))
(let ((@x465 (monotonicity (trans @x458 (rewrite (= (ite false m$ ?x439) ?x439)) (= ?x441 ?x439)) (= $x442 (= ?x42 ?x439)))))
(let ((@x477 (monotonicity (trans @x465 (rewrite (= (= ?x42 ?x439) $x468)) (= $x442 $x468)) (= (or $x260 $x442) $x473))))
(let ((@x481 (mp ((_ quant-inst m$ 2) (or $x260 $x442)) (trans @x477 (rewrite (= $x473 $x473)) (= (or $x260 $x442) $x473)) $x473)))
(let ((@x277 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x468) $x482)) (unit-resolution @x481 @x196 $x468) $x482)))
(let ((@x386 (unit-resolution ((_ th-lemma arith) (or false (not (>= ?x439 2)))) @x26 (not (>= ?x439 2)))))
(let ((@x384 (unit-resolution ((_ th-lemma arith assign-bounds 1 1) (or $x522 (>= ?x439 2) (not $x482))) @x386 @x277 $x522)))
(let ((@x564 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x43 (not $x522) $x609)) (hypothesis (not $x43)) (or (not $x522) $x609))))
(let ((?x272 (div ?x29 2)))
(let ((?x288 (* (- 2) ?x272)))
(let ((?x289 (+ n$ m$ ?x253 ?x288)))
(let (($x294 (<= ?x289 0)))
(let (($x287 (= ?x289 0)))
(let ((@x617 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x287) $x294)) (unit-resolution ((_ th-lemma arith) (or false $x287)) @x26 $x287) $x294)))
(let (($x433 (<= ?x31 0)))
(let (($x32 (= ?x31 0)))
(let ((@x33 (asserted $x32)))
(let ((?x254 (+ ?x31 ?x253)))
(let (($x270 (<= ?x254 0)))
(let (($x255 (= ?x254 0)))
(let (($x261 (or $x260 $x255)))
(let ((?x215 (ite $x209 (* (- 1) (mod (* (- 1) ?x29) ?x211)) ?x214)))
(let ((?x216 (ite $x208 ?x29 ?x215)))
(let (($x217 (= ?x31 ?x216)))
(let (($x239 (= (ite false (* (- 1) (mod (+ ?x222 (* (- 1) m$)) (- 2))) ?x214) ?x214)))
(let (($x237 (= ?x215 (ite false (* (- 1) (mod (+ ?x222 (* (- 1) m$)) (- 2))) ?x214))))
(let (($x234 (= (* (- 1) (mod (* (- 1) ?x29) ?x211)) (* (- 1) (mod (+ ?x222 (* (- 1) m$)) (- 2))))))
(let ((@x232 (monotonicity (rewrite (= (* (- 1) ?x29) (+ ?x222 (* (- 1) m$)))) @x229 (= (mod (* (- 1) ?x29) ?x211) (mod (+ ?x222 (* (- 1) m$)) (- 2))))))
(let ((@x242 (trans (monotonicity @x221 (monotonicity @x232 $x234) $x237) (rewrite $x239) (= ?x215 ?x214))))
(let ((@x249 (trans (monotonicity @x219 @x242 (= ?x216 (ite false ?x29 ?x214))) (rewrite (= (ite false ?x29 ?x214) ?x214)) (= ?x216 ?x214))))
(let ((@x259 (trans (monotonicity @x249 (= $x217 (= ?x31 ?x214))) (rewrite (= (= ?x31 ?x214) $x255)) (= $x217 $x255))))
(let ((@x268 (trans (monotonicity @x259 (= (or $x260 $x217) $x261)) (rewrite (= $x261 $x261)) (= (or $x260 $x217) $x261))))
(let ((@x269 (mp ((_ quant-inst (+ n$ m$) 2) (or $x260 $x217)) @x268 $x261)))
(let ((@x626 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x255) $x270)) (unit-resolution @x269 @x196 $x255) $x270)))
(let ((?x498 (+ m$ ?x466 (* (- 2) (div m$ 2)))))
(let (($x496 (= ?x498 0)))
(let ((@x633 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x496) (<= ?x498 0))) (unit-resolution ((_ th-lemma arith) (or false $x496)) @x26 $x496) (<= ?x498 0))))
(let ((?x397 (* (- 4) ?x381)))
(let ((?x398 (+ n$ ?x363 ?x397)))
(let (($x403 (<= ?x398 0)))
(let (($x396 (= ?x398 0)))
(let ((@x640 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x396) $x403)) (unit-resolution ((_ th-lemma arith) (or false $x396)) @x26 $x396) $x403)))
(let ((?x364 (+ ?x35 ?x363)))
(let (($x379 (<= ?x364 0)))
(let (($x365 (= ?x364 0)))
(let (($x370 (or $x260 $x365)))
(let ((?x330 (ite (<= 4 0) (* (- 1) (mod ?x222 (* (- 1) 4))) ?x329)))
(let ((?x331 (ite (= 4 0) n$ ?x330)))
(let (($x332 (= ?x35 ?x331)))
(let ((@x342 (monotonicity (rewrite (= (* (- 1) 4) (- 4))) (= (mod ?x222 (* (- 1) 4)) (mod ?x222 (- 4))))))
(let ((@x345 (monotonicity @x342 (= (* (- 1) (mod ?x222 (* (- 1) 4))) (* (- 1) (mod ?x222 (- 4)))))))
(let ((@x348 (monotonicity (rewrite (= (<= 4 0) false)) @x345 (= ?x330 (ite false (* (- 1) (mod ?x222 (- 4))) ?x329)))))
(let ((@x352 (trans @x348 (rewrite (= (ite false (* (- 1) (mod ?x222 (- 4))) ?x329) ?x329)) (= ?x330 ?x329))))
(let ((@x355 (monotonicity (rewrite (= (= 4 0) false)) @x352 (= ?x331 (ite false n$ ?x329)))))
(let ((@x362 (monotonicity (trans @x355 (rewrite (= (ite false n$ ?x329) ?x329)) (= ?x331 ?x329)) (= $x332 (= ?x35 ?x329)))))
(let ((@x374 (monotonicity (trans @x362 (rewrite (= (= ?x35 ?x329) $x365)) (= $x332 $x365)) (= (or $x260 $x332) $x370))))
(let ((@x378 (mp ((_ quant-inst n$ 4) (or $x260 $x332)) (trans @x374 (rewrite (= $x370 $x370)) (= (or $x260 $x332) $x370)) $x370)))
(let ((@x645 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x365) $x379)) (unit-resolution @x378 @x196 $x365) $x379)))
(let (($x435 (<= ?x35 3)))
(let (($x37 (= ?x35 3)))
(let ((@x38 (asserted $x37)))
(let ((@x655 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x468) (>= ?x467 0))) (unit-resolution @x481 @x196 $x468) (>= ?x467 0))))
(let ((@x656 ((_ th-lemma arith farkas -1 1 -2 1 1 1 1 1 1 1) @x655 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x37) $x435)) @x38 $x435) (hypothesis $x604) @x645 @x640 @x633 @x626 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x32) $x433)) @x33 $x433) @x617 (hypothesis $x609) false)))
(let ((@x565 (unit-resolution (lemma @x656 (or (not $x604) $x523)) (unit-resolution @x564 @x384 $x609) (not $x604))))
(let (($x295 (>= ?x289 0)))
(let ((@x566 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x287) $x295)) (unit-resolution ((_ th-lemma arith) (or false $x287)) @x26 $x287) $x295)))
(let (($x434 (>= ?x31 0)))
(let (($x271 (>= ?x254 0)))
(let ((@x531 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x255) $x271)) (unit-resolution @x269 @x196 $x255) $x271)))
(let ((@x537 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x496) (>= ?x498 0))) (unit-resolution ((_ th-lemma arith) (or false $x496)) @x26 $x496) (>= ?x498 0))))
(let ((@x549 (unit-resolution ((_ th-lemma arith) (or false (>= ?x439 0))) @x26 (>= ?x439 0))))
(let (($x404 (>= ?x398 0)))
(let ((@x552 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x396) $x404)) (unit-resolution ((_ th-lemma arith) (or false $x396)) @x26 $x396) $x404)))
(let (($x380 (>= ?x364 0)))
(let ((@x273 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x365) $x380)) (unit-resolution @x378 @x196 $x365) $x380)))
(let (($x436 (>= ?x35 3)))
(let ((@x545 ((_ th-lemma arith farkas -1/2 -1/2 -1/2 -1/2 -1/2 -1/2 -1/2 -1/2 1) (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x37) $x436)) @x38 $x436) @x273 @x552 @x549 @x537 @x531 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x32) $x434)) @x33 $x434) @x566 @x565 false)))
(let (($x171 (or $x169 (not $x43))))
(let ((@x177 (monotonicity (rewrite (= (and $x41 $x43) (not $x171))) (= (not (and $x41 $x43)) (not (not $x171))))))
(let ((@x181 (trans @x177 (rewrite (= (not (not $x171)) $x171)) (= (not (and $x41 $x43)) $x171))))
(let ((@x182 (mp (asserted (not (and $x41 $x43))) @x181 $x171)))
(let ((@x729 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x41 (not $x514) $x725)) (unit-resolution @x182 (lemma @x545 $x43) $x169) (or (not $x514) $x725))))
(let ((?x420 (* (- 2) ?x410)))
(let ((?x421 (+ n$ ?x420 ?x534)))
(let (($x426 (<= ?x421 0)))
(let (($x419 (= ?x421 0)))
(let ((@x737 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x419) $x426)) (unit-resolution ((_ th-lemma arith) (or false $x419)) @x26 $x419) $x426)))
(let (($x409 (>= ?x535 0)))
(let ((@x741 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x490) $x409)) (unit-resolution @x407 @x196 $x490) $x409)))
(let ((@x742 ((_ th-lemma arith farkas -1 1 -2 1 1 1 1) @x741 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x37) $x435)) @x38 $x435) (hypothesis $x706) @x640 @x737 @x645 (unit-resolution @x729 @x722 $x725) false)))
(let (($x427 (>= ?x421 0)))
(let ((@x584 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x419) $x427)) (unit-resolution ((_ th-lemma arith) (or false $x419)) @x26 $x419) $x427)))
(let (($x542 (>= ?x519 0)))
((_ th-lemma arith farkas -1/2 -1/2 -1/2 -1/2 -1/2 1) (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x37) $x436)) @x38 $x436) @x552 (unit-resolution ((_ th-lemma arith) (or false $x542)) @x26 $x542) @x584 @x273 (lemma @x742 (not $x706)) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

f6a4c40290fd6742c0b08a1fe90b3664e90c2143 336 0
unsat
((set-logic <null>)
(proof
(let ((?x99 (mod$ l$ 2)))
(let ((?x96 (map$ uu$ xs$)))
(let ((?x97 (eval_dioph$ ks$ ?x96)))
(let ((?x98 (mod$ ?x97 2)))
(let (($x100 (= ?x98 ?x99)))
(let ((?x93 (eval_dioph$ ks$ xs$)))
(let (($x95 (= ?x93 l$)))
(let ((?x110 (* (- 1) ?x97)))
(let ((?x111 (+ l$ ?x110)))
(let ((?x114 (divide$ ?x111 2)))
(let ((?x101 (map$ uua$ xs$)))
(let ((?x102 (eval_dioph$ ks$ ?x101)))
(let (($x117 (= ?x102 ?x114)))
(let (($x282 (not $x117)))
(let (($x281 (not $x100)))
(let (($x283 (or $x281 $x282)))
(let ((?x744 (div ?x93 2)))
(let ((?x970 (* (- 1) ?x744)))
(let ((?x699 (mod ?x93 2)))
(let ((?x726 (* (- 1) ?x699)))
(let ((?x516 (mod l$ 2)))
(let ((?x543 (* (- 1) ?x516)))
(let (($x972 (>= (+ l$ ?x99 ?x543 (* (- 1) (div l$ 2)) ?x726 ?x970) 1)))
(let ((?x369 (* (- 1) l$)))
(let ((?x693 (+ ?x93 ?x369)))
(let (($x695 (>= ?x693 0)))
(let (($x861 (not $x695)))
(let (($x694 (<= ?x693 0)))
(let ((?x686 (+ ?x102 (* (- 1) ?x114))))
(let (($x687 (<= ?x686 0)))
(let (($x284 (not $x283)))
(let ((@x466 (hypothesis $x284)))
(let ((@x856 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x282 $x687)) (unit-resolution (def-axiom (or $x283 $x117)) @x466 $x117) $x687)))
(let ((?x437 (+ l$ ?x110 (* (- 2) (div ?x111 2)) (* (- 1) (mod (+ l$ ?x97) 2)))))
(let (($x443 (>= ?x437 0)))
(let (($x434 (= ?x437 0)))
(let ((@x26 (true-axiom true)))
(let ((@x793 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x434) $x443)) (unit-resolution ((_ th-lemma arith) (or false $x434)) @x26 $x434) $x443)))
(let ((?x501 (* (- 2) ?x102)))
(let ((?x502 (+ ?x93 ?x110 ?x501)))
(let (($x509 (<= ?x502 0)))
(let (($x503 (= ?x502 0)))
(let (($x304 (forall ((?v0 Int_list$) (?v1 Int_list$) )(!(let ((?x45 (eval_dioph$ ?v0 ?v1)))
(let ((?x83 (+ ?x45 (* (- 1) (eval_dioph$ ?v0 (map$ uu$ ?v1))) (* (- 2) (eval_dioph$ ?v0 (map$ uua$ ?v1))))))
(= ?x83 0))) :pattern ( (eval_dioph$ ?v0 (map$ uu$ ?v1)) ) :pattern ( (eval_dioph$ ?v0 (map$ uua$ ?v1)) )))
))
(let (($x85 (forall ((?v0 Int_list$) (?v1 Int_list$) )(let ((?x45 (eval_dioph$ ?v0 ?v1)))
(let ((?x83 (+ ?x45 (* (- 1) (eval_dioph$ ?v0 (map$ uu$ ?v1))) (* (- 2) (eval_dioph$ ?v0 (map$ uua$ ?v1))))))
(= ?x83 0))))
))
(let ((?x45 (eval_dioph$ ?1 ?0)))
(let ((?x83 (+ ?x45 (* (- 1) (eval_dioph$ ?1 (map$ uu$ ?0))) (* (- 2) (eval_dioph$ ?1 (map$ uua$ ?0))))))
(let (($x79 (= ?x83 0)))
(let (($x58 (forall ((?v0 Int_list$) (?v1 Int_list$) )(let ((?x45 (eval_dioph$ ?v0 ?v1)))
(let ((?x48 (eval_dioph$ ?v0 (map$ uu$ ?v1))))
(let ((?x56 (+ (* (eval_dioph$ ?v0 (map$ uua$ ?v1)) 2) ?x48)))
(= ?x56 ?x45)))))
))
(let (($x74 (forall ((?v0 Int_list$) (?v1 Int_list$) )(let ((?x45 (eval_dioph$ ?v0 ?v1)))
(let ((?x54 (eval_dioph$ ?v0 (map$ uua$ ?v1))))
(let ((?x60 (* 2 ?x54)))
(let ((?x48 (eval_dioph$ ?v0 (map$ uu$ ?v1))))
(let ((?x66 (+ ?x48 ?x60)))
(= ?x66 ?x45)))))))
))
(let ((?x54 (eval_dioph$ ?1 (map$ uua$ ?0))))
(let ((?x60 (* 2 ?x54)))
(let ((?x48 (eval_dioph$ ?1 (map$ uu$ ?0))))
(let ((?x66 (+ ?x48 ?x60)))
(let (($x71 (= ?x66 ?x45)))
(let ((@x65 (monotonicity (rewrite (= (* ?x54 2) ?x60)) (= (+ (* ?x54 2) ?x48) (+ ?x60 ?x48)))))
(let ((@x70 (trans @x65 (rewrite (= (+ ?x60 ?x48) ?x66)) (= (+ (* ?x54 2) ?x48) ?x66))))
(let ((@x76 (quant-intro (monotonicity @x70 (= (= (+ (* ?x54 2) ?x48) ?x45) $x71)) (= $x58 $x74))))
(let ((@x89 (trans @x76 (quant-intro (rewrite (= $x71 $x79)) (= $x74 $x85)) (= $x58 $x85))))
(let ((@x270 (mp~ (mp (asserted $x58) @x89 $x85) (nnf-pos (refl (~ $x79 $x79)) (~ $x85 $x85)) $x85)))
(let ((@x309 (mp @x270 (quant-intro (refl (= $x79 $x79)) (= $x85 $x304)) $x304)))
(let (($x507 (or (not $x304) $x503)))
(let ((@x508 ((_ quant-inst ks$ xs$) $x507)))
(let ((@x800 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x503) $x509)) (unit-resolution @x508 @x309 $x503) $x509)))
(let ((?x396 (+ ?x114 (* (- 1) (div ?x111 2)))))
(let (($x413 (<= ?x396 0)))
(let (($x397 (= ?x396 0)))
(let (($x311 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x145 (div ?v0 ?v1)))
(let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x160 (div ?x154 ?x157)))
(let (($x175 (<= ?v1 0)))
(let ((?x182 (ite $x175 ?x160 ?x145)))
(let (($x143 (= ?v1 0)))
(let ((?x141 (divide$ ?v0 ?v1)))
(= ?x141 (ite $x143 0 ?x182)))))))))) :pattern ( (divide$ ?v0 ?v1) )))
))
(let (($x193 (forall ((?v0 Int) (?v1 Int) )(let ((?x145 (div ?v0 ?v1)))
(let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x160 (div ?x154 ?x157)))
(let (($x175 (<= ?v1 0)))
(let ((?x182 (ite $x175 ?x160 ?x145)))
(let (($x143 (= ?v1 0)))
(let ((?x141 (divide$ ?v0 ?v1)))
(= ?x141 (ite $x143 0 ?x182)))))))))))
))
(let ((?x145 (div ?1 ?0)))
(let ((?x157 (* (- 1) ?0)))
(let ((?x154 (* (- 1) ?1)))
(let ((?x160 (div ?x154 ?x157)))
(let (($x175 (<= ?0 0)))
(let ((?x182 (ite $x175 ?x160 ?x145)))
(let (($x143 (= ?0 0)))
(let ((?x141 (divide$ ?1 ?0)))
(let (($x190 (= ?x141 (ite $x143 0 ?x182))))
(let (($x152 (forall ((?v0 Int) (?v1 Int) )(let (($x143 (= ?v1 0)))
(let ((?x150 (ite $x143 0 (ite (< 0 ?v1) (div ?v0 ?v1) (div (- ?v0) (- ?v1))))))
(let ((?x141 (divide$ ?v0 ?v1)))
(= ?x141 ?x150)))))
))
(let (($x172 (forall ((?v0 Int) (?v1 Int) )(let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x160 (div ?x154 ?x157)))
(let ((?x145 (div ?v0 ?v1)))
(let (($x144 (< 0 ?v1)))
(let ((?x163 (ite $x144 ?x145 ?x160)))
(let (($x143 (= ?v1 0)))
(let ((?x166 (ite $x143 0 ?x163)))
(let ((?x141 (divide$ ?v0 ?v1)))
(= ?x141 ?x166)))))))))))
))
(let (($x144 (< 0 ?0)))
(let ((?x163 (ite $x144 ?x145 ?x160)))
(let ((?x166 (ite $x143 0 ?x163)))
(let ((@x181 (monotonicity (rewrite (= $x144 (not $x175))) (= ?x163 (ite (not $x175) ?x145 ?x160)))))
(let ((@x186 (trans @x181 (rewrite (= (ite (not $x175) ?x145 ?x160) ?x182)) (= ?x163 ?x182))))
(let ((@x192 (monotonicity (monotonicity @x186 (= ?x166 (ite $x143 0 ?x182))) (= (= ?x141 ?x166) $x190))))
(let (($x169 (= ?x141 ?x166)))
(let (($x170 (= (= ?x141 (ite $x143 0 (ite $x144 ?x145 (div (- ?1) (- ?0))))) $x169)))
(let ((@x162 (monotonicity (rewrite (= (- ?1) ?x154)) (rewrite (= (- ?0) ?x157)) (= (div (- ?1) (- ?0)) ?x160))))
(let ((@x168 (monotonicity (monotonicity @x162 (= (ite $x144 ?x145 (div (- ?1) (- ?0))) ?x163)) (= (ite $x143 0 (ite $x144 ?x145 (div (- ?1) (- ?0)))) ?x166))))
(let ((@x197 (trans (quant-intro (monotonicity @x168 $x170) (= $x152 $x172)) (quant-intro @x192 (= $x172 $x193)) (= $x152 $x193))))
(let ((@x275 (mp~ (mp (asserted $x152) @x197 $x193) (nnf-pos (refl (~ $x190 $x190)) (~ $x193 $x193)) $x193)))
(let ((@x316 (mp @x275 (quant-intro (refl (= $x190 $x190)) (= $x193 $x311)) $x311)))
(let (($x403 (or (not $x311) $x397)))
(let ((?x361 (div ?x111 2)))
(let (($x357 (<= 2 0)))
(let ((?x362 (ite $x357 (div (* (- 1) ?x111) (* (- 1) 2)) ?x361)))
(let (($x356 (= 2 0)))
(let ((?x363 (ite $x356 0 ?x362)))
(let (($x364 (= ?x114 ?x363)))
(let ((@x374 (rewrite (= (* (- 1) 2) (- 2)))))
(let ((@x377 (monotonicity (rewrite (= (* (- 1) ?x111) (+ ?x369 ?x97))) @x374 (= (div (* (- 1) ?x111) (* (- 1) 2)) (div (+ ?x369 ?x97) (- 2))))))
(let ((@x368 (rewrite (= $x357 false))))
(let ((@x380 (monotonicity @x368 @x377 (= ?x362 (ite false (div (+ ?x369 ?x97) (- 2)) ?x361)))))
(let ((@x384 (trans @x380 (rewrite (= (ite false (div (+ ?x369 ?x97) (- 2)) ?x361) ?x361)) (= ?x362 ?x361))))
(let ((@x366 (rewrite (= $x356 false))))
(let ((@x391 (trans (monotonicity @x366 @x384 (= ?x363 (ite false 0 ?x361))) (rewrite (= (ite false 0 ?x361) ?x361)) (= ?x363 ?x361))))
(let ((@x401 (trans (monotonicity @x391 (= $x364 (= ?x114 ?x361))) (rewrite (= (= ?x114 ?x361) $x397)) (= $x364 $x397))))
(let ((@x410 (trans (monotonicity @x401 (= (or (not $x311) $x364) $x403)) (rewrite (= $x403 $x403)) (= (or (not $x311) $x364) $x403))))
(let ((@x802 (unit-resolution (mp ((_ quant-inst (+ l$ ?x110) 2) (or (not $x311) $x364)) @x410 $x403) @x316 $x397)))
(let ((?x425 (mod (+ l$ ?x97) 2)))
(let (($x465 (>= ?x425 0)))
(let ((@x810 ((_ th-lemma arith farkas 1 -2 -2 -1 1 1) (unit-resolution ((_ th-lemma arith) (or false $x465)) @x26 $x465) (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x397) $x413)) @x802 $x413) (hypothesis $x687) @x800 (hypothesis (not $x694)) @x793 false)))
(let (($x134 (not $x95)))
(let (($x290 (= $x95 $x283)))
(let ((@x289 (monotonicity (rewrite (= (and $x100 $x117) $x284)) (= (= $x134 (and $x100 $x117)) (= $x134 $x284)))))
(let ((@x294 (trans @x289 (rewrite (= (= $x134 $x284) $x290)) (= (= $x134 (and $x100 $x117)) $x290))))
(let (($x120 (and $x100 $x117)))
(let (($x135 (= $x134 $x120)))
(let (($x107 (= $x95 (and $x100 (= ?x102 (divide$ (- l$ ?x97) 2))))))
(let (($x108 (not $x107)))
(let ((@x116 (monotonicity (rewrite (= (- l$ ?x97) ?x111)) (= (divide$ (- l$ ?x97) 2) ?x114))))
(let ((@x122 (monotonicity (monotonicity @x116 (= (= ?x102 (divide$ (- l$ ?x97) 2)) $x117)) (= (and $x100 (= ?x102 (divide$ (- l$ ?x97) 2))) $x120))))
(let ((@x130 (trans (monotonicity @x122 (= $x107 (= $x95 $x120))) (rewrite (= (= $x95 $x120) (= $x95 $x120))) (= $x107 (= $x95 $x120)))))
(let ((@x139 (trans (monotonicity @x130 (= $x108 (not (= $x95 $x120)))) (rewrite (= (not (= $x95 $x120)) $x135)) (= $x108 $x135))))
(let ((@x295 (mp (mp (asserted $x108) @x139 $x135) @x294 $x290)))
(let ((@x344 (unit-resolution (def-axiom (or $x134 $x283 (not $x290))) @x295 (or $x134 $x283))))
(let ((@x898 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x95 (not $x694) $x861)) (unit-resolution @x344 @x466 $x134) (or (not $x694) $x861))))
(let ((@x899 (unit-resolution @x898 (unit-resolution (lemma @x810 (or $x694 (not $x687))) @x856 $x694) $x861)))
(let ((?x544 (+ ?x99 ?x543)))
(let (($x561 (>= ?x544 0)))
(let (($x545 (= ?x544 0)))
(let (($x318 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x200 (mod ?v0 ?v1)))
(let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x208 (mod ?x154 ?x157)))
(let ((?x214 (* (- 1) ?x208)))
(let (($x175 (<= ?v1 0)))
(let ((?x234 (ite $x175 ?x214 ?x200)))
(let (($x143 (= ?v1 0)))
(let ((?x239 (ite $x143 ?v0 ?x234)))
(let ((?x199 (mod$ ?v0 ?v1)))
(= ?x199 ?x239))))))))))) :pattern ( (mod$ ?v0 ?v1) )))
))
(let (($x245 (forall ((?v0 Int) (?v1 Int) )(let ((?x200 (mod ?v0 ?v1)))
(let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x208 (mod ?x154 ?x157)))
(let ((?x214 (* (- 1) ?x208)))
(let (($x175 (<= ?v1 0)))
(let ((?x234 (ite $x175 ?x214 ?x200)))
(let (($x143 (= ?v1 0)))
(let ((?x239 (ite $x143 ?v0 ?x234)))
(let ((?x199 (mod$ ?v0 ?v1)))
(= ?x199 ?x239))))))))))))
))
(let ((?x200 (mod ?1 ?0)))
(let ((?x208 (mod ?x154 ?x157)))
(let ((?x214 (* (- 1) ?x208)))
(let ((?x234 (ite $x175 ?x214 ?x200)))
(let ((?x239 (ite $x143 ?1 ?x234)))
(let ((?x199 (mod$ ?1 ?0)))
(let (($x242 (= ?x199 ?x239)))
(let (($x206 (forall ((?v0 Int) (?v1 Int) )(let (($x143 (= ?v1 0)))
(let ((?x204 (ite $x143 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
(let ((?x199 (mod$ ?v0 ?v1)))
(= ?x199 ?x204)))))
))
(let (($x228 (forall ((?v0 Int) (?v1 Int) )(let ((?x157 (* (- 1) ?v1)))
(let ((?x154 (* (- 1) ?v0)))
(let ((?x208 (mod ?x154 ?x157)))
(let ((?x214 (* (- 1) ?x208)))
(let ((?x200 (mod ?v0 ?v1)))
(let (($x144 (< 0 ?v1)))
(let ((?x219 (ite $x144 ?x200 ?x214)))
(let (($x143 (= ?v1 0)))
(let ((?x222 (ite $x143 ?v0 ?x219)))
(let ((?x199 (mod$ ?v0 ?v1)))
(= ?x199 ?x222))))))))))))
))
(let ((@x233 (monotonicity (rewrite (= $x144 (not $x175))) (= (ite $x144 ?x200 ?x214) (ite (not $x175) ?x200 ?x214)))))
(let ((@x238 (trans @x233 (rewrite (= (ite (not $x175) ?x200 ?x214) ?x234)) (= (ite $x144 ?x200 ?x214) ?x234))))
(let ((@x244 (monotonicity (monotonicity @x238 (= (ite $x143 ?1 (ite $x144 ?x200 ?x214)) ?x239)) (= (= ?x199 (ite $x143 ?1 (ite $x144 ?x200 ?x214))) $x242))))
(let ((?x219 (ite $x144 ?x200 ?x214)))
(let ((?x222 (ite $x143 ?1 ?x219)))
(let (($x225 (= ?x199 ?x222)))
(let (($x226 (= (= ?x199 (ite $x143 ?1 (ite $x144 ?x200 (- (mod (- ?1) (- ?0)))))) $x225)))
(let ((@x210 (monotonicity (rewrite (= (- ?1) ?x154)) (rewrite (= (- ?0) ?x157)) (= (mod (- ?1) (- ?0)) ?x208))))
(let ((@x218 (trans (monotonicity @x210 (= (- (mod (- ?1) (- ?0))) (- ?x208))) (rewrite (= (- ?x208) ?x214)) (= (- (mod (- ?1) (- ?0))) ?x214))))
(let ((@x221 (monotonicity @x218 (= (ite $x144 ?x200 (- (mod (- ?1) (- ?0)))) ?x219))))
(let ((@x224 (monotonicity @x221 (= (ite $x143 ?1 (ite $x144 ?x200 (- (mod (- ?1) (- ?0))))) ?x222))))
(let ((@x249 (trans (quant-intro (monotonicity @x224 $x226) (= $x206 $x228)) (quant-intro @x244 (= $x228 $x245)) (= $x206 $x245))))
(let ((@x280 (mp~ (mp (asserted $x206) @x249 $x245) (nnf-pos (refl (~ $x242 $x242)) (~ $x245 $x245)) $x245)))
(let ((@x323 (mp @x280 (quant-intro (refl (= $x242 $x242)) (= $x245 $x318)) $x318)))
(let (($x550 (not $x318)))
(let (($x551 (or $x550 $x545)))
(let ((?x359 (* (- 1) 2)))
(let ((?x511 (mod ?x369 ?x359)))
(let ((?x512 (* (- 1) ?x511)))
(let ((?x517 (ite $x357 ?x512 ?x516)))
(let ((?x518 (ite $x356 l$ ?x517)))
(let (($x519 (= ?x99 ?x518)))
(let ((@x525 (monotonicity (monotonicity @x374 (= ?x511 (mod ?x369 (- 2)))) (= ?x512 (* (- 1) (mod ?x369 (- 2)))))))
(let ((@x528 (monotonicity @x368 @x525 (= ?x517 (ite false (* (- 1) (mod ?x369 (- 2))) ?x516)))))
(let ((@x532 (trans @x528 (rewrite (= (ite false (* (- 1) (mod ?x369 (- 2))) ?x516) ?x516)) (= ?x517 ?x516))))
(let ((@x539 (trans (monotonicity @x366 @x532 (= ?x518 (ite false l$ ?x516))) (rewrite (= (ite false l$ ?x516) ?x516)) (= ?x518 ?x516))))
(let ((@x549 (trans (monotonicity @x539 (= $x519 (= ?x99 ?x516))) (rewrite (= (= ?x99 ?x516) $x545)) (= $x519 $x545))))
(let ((@x558 (trans (monotonicity @x549 (= (or $x550 $x519) $x551)) (rewrite (= $x551 $x551)) (= (or $x550 $x519) $x551))))
(let ((@x559 (mp ((_ quant-inst l$ 2) (or $x550 $x519)) @x558 $x551)))
(let ((@x902 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x545) $x561)) (unit-resolution @x559 @x323 $x545) $x561)))
(let ((?x757 (* (- 2) ?x744)))
(let ((?x758 (+ ?x93 ?x726 ?x757)))
(let (($x764 (>= ?x758 0)))
(let (($x756 (= ?x758 0)))
(let ((@x872 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x756) $x764)) (unit-resolution ((_ th-lemma arith) (or false $x756)) @x26 $x756) $x764)))
(let ((?x562 (div l$ 2)))
(let ((?x575 (* (- 2) ?x562)))
(let ((?x576 (+ l$ ?x543 ?x575)))
(let (($x582 (>= ?x576 0)))
(let (($x574 (= ?x576 0)))
(let ((@x880 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x574) $x582)) (unit-resolution ((_ th-lemma arith) (or false $x574)) @x26 $x574) $x582)))
(let ((?x504 (mod$ ?x93 2)))
(let ((?x727 (+ ?x504 ?x726)))
(let (($x728 (= ?x727 0)))
(let (($x733 (or $x550 $x728)))
(let ((?x696 (* (- 1) ?x93)))
(let ((?x697 (mod ?x696 ?x359)))
(let ((?x698 (* (- 1) ?x697)))
(let ((?x700 (ite $x357 ?x698 ?x699)))
(let ((?x701 (ite $x356 ?x93 ?x700)))
(let (($x702 (= ?x504 ?x701)))
(let ((@x708 (monotonicity (monotonicity @x374 (= ?x697 (mod ?x696 (- 2)))) (= ?x698 (* (- 1) (mod ?x696 (- 2)))))))
(let ((@x711 (monotonicity @x368 @x708 (= ?x700 (ite false (* (- 1) (mod ?x696 (- 2))) ?x699)))))
(let ((@x715 (trans @x711 (rewrite (= (ite false (* (- 1) (mod ?x696 (- 2))) ?x699) ?x699)) (= ?x700 ?x699))))
(let ((@x722 (trans (monotonicity @x366 @x715 (= ?x701 (ite false ?x93 ?x699))) (rewrite (= (ite false ?x93 ?x699) ?x699)) (= ?x701 ?x699))))
(let ((@x732 (trans (monotonicity @x722 (= $x702 (= ?x504 ?x699))) (rewrite (= (= ?x504 ?x699) $x728)) (= $x702 $x728))))
(let ((@x740 (trans (monotonicity @x732 (= (or $x550 $x702) $x733)) (rewrite (= $x733 $x733)) (= (or $x550 $x702) $x733))))
(let ((@x427 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x728) (>= ?x727 0))) (unit-resolution (mp ((_ quant-inst (eval_dioph$ ks$ xs$) 2) (or $x550 $x702)) @x740 $x733) @x323 $x728) (>= ?x727 0))))
(let ((?x783 (* (- 1) ?x504)))
(let ((?x784 (+ ?x99 ?x783)))
(let (($x786 (>= ?x784 0)))
(let (($x782 (= ?x99 ?x504)))
(let (($x821 (= ?x98 ?x504)))
(let (($x505 (= ?x504 ?x98)))
(let (($x297 (forall ((?v0 Int_list$) (?v1 Int_list$) )(!(= (mod$ (eval_dioph$ ?v0 ?v1) 2) (mod$ (eval_dioph$ ?v0 (map$ uu$ ?v1)) 2)) :pattern ( (eval_dioph$ ?v0 (map$ uu$ ?v1)) )))
))
(let (($x51 (forall ((?v0 Int_list$) (?v1 Int_list$) )(= (mod$ (eval_dioph$ ?v0 ?v1) 2) (mod$ (eval_dioph$ ?v0 (map$ uu$ ?v1)) 2)))
))
(let (($x50 (= (mod$ ?x45 2) (mod$ ?x48 2))))
(let ((@x265 (mp~ (asserted $x51) (nnf-pos (refl (~ $x50 $x50)) (~ $x51 $x51)) $x51)))
(let ((@x302 (mp @x265 (quant-intro (refl (= $x50 $x50)) (= $x51 $x297)) $x297)))
(let (($x514 (or (not $x297) $x505)))
(let ((@x515 ((_ quant-inst ks$ xs$) $x514)))
(let ((@x824 (symm (unit-resolution (def-axiom (or $x283 $x100)) @x466 $x100) (= ?x99 ?x98))))
(let ((@x939 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x782) $x786)) (trans @x824 (symm (unit-resolution @x515 @x302 $x505) $x821) $x782) $x786)))
(let (($x785 (<= ?x784 0)))
(let ((@x887 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x782) $x785)) (trans @x824 (symm (unit-resolution @x515 @x302 $x505) $x821) $x782) $x785)))
(let (($x688 (>= ?x686 0)))
(let ((@x855 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x282 $x688)) (unit-resolution (def-axiom (or $x283 $x117)) @x466 $x117) $x688)))
(let ((@x979 (unit-resolution ((_ th-lemma arith) (or false (not (>= ?x425 2)))) @x26 (not (>= ?x425 2)))))
(let (($x560 (<= ?x544 0)))
(let ((@x461 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x545) $x560)) (unit-resolution @x559 @x323 $x545) $x560)))
(let (($x763 (<= ?x758 0)))
(let ((@x658 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x756) $x763)) (unit-resolution ((_ th-lemma arith) (or false $x756)) @x26 $x756) $x763)))
(let (($x581 (<= ?x576 0)))
(let ((@x986 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x574) $x581)) (unit-resolution ((_ th-lemma arith) (or false $x574)) @x26 $x574) $x581)))
(let ((@x989 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x728) (<= ?x727 0))) (unit-resolution (mp ((_ quant-inst (eval_dioph$ ks$ xs$) 2) (or $x550 $x702)) @x740 $x733) @x323 $x728) (<= ?x727 0))))
(let (($x510 (>= ?x502 0)))
(let ((@x994 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x503) $x510)) (unit-resolution @x508 @x309 $x503) $x510)))
(let ((@x998 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x397) (>= ?x396 0))) @x802 (>= ?x396 0))))
(let ((@x1001 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x434) (<= ?x437 0))) (unit-resolution ((_ th-lemma arith) (or false $x434)) @x26 $x434) (<= ?x437 0))))
(let ((@x1002 ((_ th-lemma arith farkas 1 -2 -2 -1 -2 1 1 1 1 1 1) @x1001 @x998 (hypothesis $x688) @x994 (hypothesis $x972) (hypothesis $x785) @x989 @x986 @x658 @x461 @x979 false)))
(let ((@x474 (unit-resolution (lemma @x1002 (or (not $x972) (not $x688) (not $x785))) @x855 @x887 (not $x972))))
(let ((@x941 (unit-resolution @x474 ((_ th-lemma arith) @x939 @x427 @x880 @x872 @x902 @x899 $x972) false)))
(let ((@x942 (lemma @x941 $x283)))
(let ((@x340 (unit-resolution (def-axiom (or $x95 $x284 (not $x290))) @x295 (or $x95 $x284))))
(let ((@x679 (unit-resolution @x340 @x942 $x95)))
(let ((@x889 (trans (symm (unit-resolution @x515 @x302 $x505) $x821) (monotonicity @x679 (= ?x504 ?x99)) $x100)))
(let (($x811 (not $x687)))
(let ((@x845 ((_ th-lemma arith assign-bounds 1 -1/2 -1/2 1/2 -1/2) (or $x688 (not $x413) (not $x465) (not $x443) (not $x509) $x861))))
(let ((@x892 (unit-resolution @x845 (unit-resolution ((_ th-lemma arith triangle-eq) (or (not $x397) $x413)) @x802 $x413) (unit-resolution ((_ th-lemma arith triangle-eq) (or $x134 $x695)) @x679 $x695) @x793 (unit-resolution ((_ th-lemma arith) (or false $x465)) @x26 $x465) @x800 $x688)))
(let ((@x935 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x117 $x811 (not $x688))) (hypothesis $x282) (or $x811 (not $x688)))))
(let ((@x955 ((_ th-lemma arith farkas -2 -2 1 -1 1 1) (unit-resolution @x935 @x892 $x811) @x998 @x1001 @x994 (unit-resolution ((_ th-lemma arith triangle-eq) (or $x134 $x694)) @x679 $x694) @x979 false)))
(let ((@x472 (unit-resolution (unit-resolution (def-axiom (or $x284 $x281 $x282)) @x942 $x283) (lemma @x955 $x117) $x281)))
(unit-resolution @x472 @x889 false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

785615f585a02b3e6ed8608ecc9660ba5c4025e2 2 0
sat
(error "line 9 column 10: proof is not available")
c4e20de399740e8f0c9a87abad030298d74bc47b 12 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x31 (p$ true)))
(let (($x29 (< 2 3)))
(let ((?x30 (p$ $x29)))
(let (($x32 (= ?x30 ?x31)))
(let ((@x42 (monotonicity (monotonicity (rewrite (= $x29 true)) $x32) (= $x32 (= ?x31 ?x31)))))
(let ((@x49 (monotonicity (trans @x42 (rewrite (= (= ?x31 ?x31) true)) (= $x32 true)) (= (not $x32) (not true)))))
(let ((@x53 (trans @x49 (rewrite (= (not true) false)) (= (not $x32) false))))
(mp (asserted (not $x32)) @x53 false))))))))))

23f5eb3b530a4577da2f8947333286ff70ed557f 11 0
unsat
((set-logic AUFLIA)
(proof
(let (($x29 (exists ((?v0 A$) )(! (g$ ?v0) :qid k!7))
))
(let (($x30 (f$ $x29)))
(let (($x31 (=> $x30 true)))
(let (($x32 (not $x31)))
(let ((@x42 (trans (monotonicity (rewrite (= $x31 true)) (= $x32 (not true))) (rewrite (= (not true) false)) (= $x32 false))))
(mp (asserted $x32) @x42 false))))))))

60f1b32e9c6a2229b64c85dcfb0bde9c2bd5433a 11 0
unsat
((set-logic AUFLIA)
(proof
(let (($x29 (forall ((?v0 A$) )(! (g$ ?v0) :qid k!7))
))
(let (($x30 (f$ $x29)))
(let (($x31 (=> $x30 true)))
(let (($x32 (not $x31)))
(let ((@x42 (trans (monotonicity (rewrite (= $x31 true)) (= $x32 (not true))) (rewrite (= (not true) false)) (= $x32 false))))
(mp (asserted $x32) @x42 false))))))))