src/HOL/SMT_Examples/SMT_Examples.certs2

more explicit Command.Chunk types, less ooddities;
tuned;

7a16ef230bca5702aa346494226903ec25809d32 6 0
unsat
((set-logic AUFLIA)
(proof
(let ((@x28 (rewrite (= (not true) false))))
(mp (asserted (not true)) @x28 false))))

27731fc512042f0ea1785a47796a8bfd64c4a8cf 7 0
unsat
((set-logic AUFLIA)
(proof
(let ((@x34 (monotonicity (rewrite (= (or |p$| (not |p$|)) true)) (= (not (or |p$| (not |p$|))) (not true)))))
(let ((@x38 (trans @x34 (rewrite (= (not true) false)) (= (not (or |p$| (not |p$|))) false))))
(mp (asserted (not (or |p$| (not |p$|)))) @x38 false)))))

5330fb77bfecb903300c8a50f577df102088abaa 9 0
unsat
((set-logic AUFLIA)
(proof
(let ((@x34 (monotonicity (rewrite (= (and |p$| true) |p$|)) (= (= (and |p$| true) |p$|) (= |p$| |p$|)))))
(let ((@x38 (trans @x34 (rewrite (= (= |p$| |p$|) true)) (= (= (and |p$| true) |p$|) true))))
(let ((@x41 (monotonicity @x38 (= (not (= (and |p$| true) |p$|)) (not true)))))
(let ((@x45 (trans @x41 (rewrite (= (not true) false)) (= (not (= (and |p$| true) |p$|)) false))))
(mp (asserted (not (= (and |p$| true) |p$|))) @x45 false)))))))

c2e74b12f4c731d0ea3ac811d94ac5a723029e93 13 0
unsat
((set-logic AUFLIA)
(proof
(let (($x8 (not |p$|)))
(let (($x7 (or |p$| |q$|)))
(let (($x9 (and $x7 $x8)))
(let ((@x39 (monotonicity (rewrite (= (=> $x9 |q$|) (or (not $x9) |q$|))) (= (not (=> $x9 |q$|)) (not (or (not $x9) |q$|))))))
(let ((@x40 (|not-or-elim| (mp (asserted (not (=> $x9 |q$|))) @x39 (not (or (not $x9) |q$|))) $x9)))
(let ((@x43 (|and-elim| @x40 $x8)))
(let ((@x45 (|not-or-elim| (mp (asserted (not (=> $x9 |q$|))) @x39 (not (or (not $x9) |q$|))) (not |q$|))))
(let ((@x41 (|and-elim| @x40 $x7)))
(|unit-resolution| @x41 @x45 @x43 false)))))))))))

800409db22b453674c1b66520bda2d5bafbf81b4 11 0
unsat
((set-logic AUFLIA)
(proof
(let (($x10 (and |c$| |d$|)))
(let (($x7 (and |a$| |b$|)))
(let (($x11 (or $x7 $x10)))
(let (($x12 (=> $x11 $x11)))
(let (($x13 (not $x12)))
(let ((@x43 (trans (monotonicity (rewrite (= $x12 true)) (= $x13 (not true))) (rewrite (= (not true) false)) (= $x13 false))))
(mp (asserted $x13) @x43 false)))))))))

8ba22a36afac456bfdc7db71e8b371143686dc86 23 0
unsat
((set-logic AUFLIA)
(proof
(let (($x11 (and |p1$| |p3$|)))
(let (($x10 (and |p3$| |p2$|)))
(let (($x12 (or $x10 $x11)))
(let (($x13 (=> |p1$| $x12)))
(let (($x14 (or $x13 |p1$|)))
(let (($x7 (and |p1$| |p2$|)))
(let (($x9 (or $x7 |p3$|)))
(let (($x15 (=> $x9 $x14)))
(let (($x16 (not $x15)))
(let (($x38 (not |p1$|)))
(let (($x39 (or $x38 $x12)))
(let (($x42 (or $x39 |p1$|)))
(let (($x48 (not $x9)))
(let (($x49 (or $x48 $x42)))
(let (($x54 (not $x49)))
(let ((@x65 (trans (monotonicity (rewrite (= $x49 true)) (= $x54 (not true))) (rewrite (= (not true) false)) (= $x54 false))))
(let ((@x47 (monotonicity (monotonicity (rewrite (= $x13 $x39)) (= $x14 $x42)) (= $x15 (=> $x9 $x42)))))
(let ((@x56 (monotonicity (trans @x47 (rewrite (= (=> $x9 $x42) $x49)) (= $x15 $x49)) (= $x16 $x54))))
(mp (asserted $x16) (trans @x56 @x65 (= $x16 false)) false)))))))))))))))))))))

9d0d2643780c0052a3bf06c1fd96112084da5890 24 0
unsat
((set-logic AUFLIA)
(proof
(let (($x6 (= |p$| |p$|)))
(let (($x7 (= $x6 |p$|)))
(let (($x8 (= $x7 |p$|)))
(let (($x9 (= $x8 |p$|)))
(let (($x10 (= $x9 |p$|)))
(let (($x11 (= $x10 |p$|)))
(let (($x12 (= $x11 |p$|)))
(let (($x13 (= $x12 |p$|)))
(let (($x14 (= $x13 |p$|)))
(let (($x15 (not $x14)))
(let ((@x38 (rewrite (= $x6 true))))
(let ((@x43 (rewrite (= (= true |p$|) |p$|))))
(let ((@x45 (trans (monotonicity @x38 (= $x7 (= true |p$|))) @x43 (= $x7 |p$|))))
(let ((@x51 (monotonicity (trans (monotonicity @x45 (= $x8 $x6)) @x38 (= $x8 true)) (= $x9 (= true |p$|)))))
(let ((@x57 (trans (monotonicity (trans @x51 @x43 (= $x9 |p$|)) (= $x10 $x6)) @x38 (= $x10 true))))
(let ((@x61 (trans (monotonicity @x57 (= $x11 (= true |p$|))) @x43 (= $x11 |p$|))))
(let ((@x67 (monotonicity (trans (monotonicity @x61 (= $x12 $x6)) @x38 (= $x12 true)) (= $x13 (= true |p$|)))))
(let ((@x73 (trans (monotonicity (trans @x67 @x43 (= $x13 |p$|)) (= $x14 $x6)) @x38 (= $x14 true))))
(let ((@x80 (trans (monotonicity @x73 (= $x15 (not true))) (rewrite (= (not true) false)) (= $x15 false))))
(mp (asserted $x15) @x80 false))))))))))))))))))))))

63439e1fd6656fc5a2376d7e5f00d0dd92c536a2 34 0
unsat
((set-logic AUFLIA)
(proof
(let (($x98 (not |b$|)))
(let (($x17 (not |c$|)))
(let (($x36 (or |p$| (and |q$| (not |q$|)))))
(let (($x37 (and (not |p$|) $x36)))
(let (($x38 (or |c$| $x37)))
(let (($x39 (not $x38)))
(let ((@x120 (monotonicity (rewrite (= (and |q$| (not |q$|)) false)) (= $x36 (or |p$| false)))))
(let ((@x127 (monotonicity (trans @x120 (rewrite (= (or |p$| false) |p$|)) (= $x36 |p$|)) (= $x37 (and (not |p$|) |p$|)))))
(let ((@x131 (trans @x127 (rewrite (= (and (not |p$|) |p$|) false)) (= $x37 false))))
(let ((@x138 (trans (monotonicity @x131 (= $x38 (or |c$| false))) (rewrite (= (or |c$| false) |c$|)) (= $x38 |c$|))))
(let ((@x143 (mp (asserted $x39) (monotonicity @x138 (= $x39 $x17)) $x17)))
(let (($x101 (or $x98 |c$|)))
(let ((@x93 (monotonicity (rewrite (= (or |x$| (not |x$|)) true)) (= (and |b$| (or |x$| (not |x$|))) (and |b$| true)))))
(let ((@x97 (trans @x93 (rewrite (= (and |b$| true) |b$|)) (= (and |b$| (or |x$| (not |x$|))) |b$|))))
(let ((@x103 (monotonicity (monotonicity @x97 (= (not (and |b$| (or |x$| (not |x$|)))) $x98)) (= (or (not (and |b$| (or |x$| (not |x$|)))) |c$|) $x101))))
(let ((@x106 (mp (asserted (or (not (and |b$| (or |x$| (not |x$|)))) |c$|)) @x103 $x101)))
(let (($x108 (not |d$|)))
(let (($x111 (or $x108 |c$|)))
(let ((@x110 (monotonicity (rewrite (= (or |d$| false) |d$|)) (= (not (or |d$| false)) $x108))))
(let ((@x116 (mp (asserted (or (not (or |d$| false)) |c$|)) (monotonicity @x110 (= (or (not (or |d$| false)) |c$|) $x111)) $x111)))
(let (($x64 (or |a$| |b$| |c$| |d$|)))
(let ((@x67 (mp (asserted (or |a$| (or |b$| (or |c$| |d$|)))) (rewrite (= (or |a$| (or |b$| (or |c$| |d$|))) $x64)) $x64)))
(let ((@x160 (|unit-resolution| @x67 (|unit-resolution| @x106 @x143 $x98) @x143 (|unit-resolution| @x116 @x143 $x108) |a$|)))
(let (($x81 (not |a$|)))
(let (($x84 (or $x81 |b$|)))
(let ((@x76 (monotonicity (rewrite (= (and |c$| $x17) false)) (= (or |a$| (and |c$| $x17)) (or |a$| false)))))
(let ((@x80 (trans @x76 (rewrite (= (or |a$| false) |a$|)) (= (or |a$| (and |c$| $x17)) |a$|))))
(let ((@x86 (monotonicity (monotonicity @x80 (= (not (or |a$| (and |c$| $x17))) $x81)) (= (or (not (or |a$| (and |c$| $x17))) |b$|) $x84))))
(let ((@x89 (mp (asserted (or (not (or |a$| (and |c$| $x17))) |b$|)) @x86 $x84)))
(|unit-resolution| @x89 @x160 (|unit-resolution| @x106 @x143 $x98) false))))))))))))))))))))))))))))))))

c1a1d5a3f58100ecdaa72705a063eeccc5044c46 27 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x15 (|symm_f$| |b$| |a$|)))
(let ((?x14 (|symm_f$| |a$| |b$|)))
(let (($x16 (= ?x14 ?x15)))
(let (($x50 (not $x16)))
(let ((@x45 (monotonicity (rewrite (= (= |a$| |a$|) true)) (= (and (= |a$| |a$|) $x16) (and true $x16)))))
(let ((@x49 (trans @x45 (rewrite (= (and true $x16) $x16)) (= (and (= |a$| |a$|) $x16) $x16))))
(let ((@x55 (mp (asserted (not (and (= |a$| |a$|) $x16))) (monotonicity @x49 (= (not (and (= |a$| |a$|) $x16)) $x50)) $x50)))
(let (($x59 (forall ((?v0 |A$|) (?v1 |A$|) )(!(let ((?x8 (|symm_f$| ?v1 ?v0)))
(let ((?x7 (|symm_f$| ?v0 ?v1)))
(= ?x7 ?x8))) :pattern ( (|symm_f$| ?v0 ?v1) ) :pattern ( (|symm_f$| ?v1 ?v0) )))
))
(let (($x10 (forall ((?v0 |A$|) (?v1 |A$|) )(let ((?x8 (|symm_f$| ?v1 ?v0)))
(let ((?x7 (|symm_f$| ?v0 ?v1)))
(= ?x7 ?x8))))
))
(let ((?x8 (|symm_f$| ?0 ?1)))
(let ((?x7 (|symm_f$| ?1 ?0)))
(let (($x9 (= ?x7 ?x8)))
(let ((@x58 (|mp~| (asserted $x10) (|nnf-pos| (refl (|~| $x9 $x9)) (|~| $x10 $x10)) $x10)))
(let ((@x66 (mp @x58 (|quant-intro| (refl (= $x9 $x9)) (= $x10 $x59)) $x59)))
(let (($x70 (or (not $x59) $x16)))
(let ((@x71 ((_ |quant-inst| |a$| |b$|) $x70)))
(|unit-resolution| @x71 @x66 @x55 false)))))))))))))))))))

d1ba851b4b433507a4e12ae0555630bd23204076 38 0
unsat
((set-logic AUFLIA)
(declare-fun ?v0!0 () Int)
(declare-fun ?v1!1 () Int)
(proof
(let (($x46 (|p$| ?v0!0)))
(let (($x48 (not $x46)))
(let (($x61 (not (or $x46 (|p$| ?v1!1)))))
(let ((@x77 (monotonicity (rewrite (= (not $x48) $x46)) (= (and (not $x48) $x61) (and $x46 $x61)))))
(let (($x55 (not $x48)))
(let (($x65 (and $x55 $x61)))
(let (($x39 (forall ((?v0 Int) )(let (($x10 (forall ((?v1 Int) )(let (($x6 (|p$| ?v1)))
(or (|p$| ?v0) $x6)))
))
(or (not (|p$| ?v0)) $x10)))
))
(let (($x42 (not $x39)))
(let (($x50 (forall ((?v1 Int) )(let (($x6 (|p$| ?v1)))
(let (($x46 (|p$| ?v0!0)))
(or $x46 $x6))))
))
(let ((@x67 (|nnf-neg| (refl (|~| $x55 $x55)) (sk (|~| (not $x50) $x61)) (|~| (not (or $x48 $x50)) $x65))))
(let (($x12 (forall ((?v0 Int) )(let (($x10 (forall ((?v1 Int) )(let (($x6 (|p$| ?v1)))
(or (|p$| ?v0) $x6)))
))
(let (($x6 (|p$| ?v0)))
(=> $x6 $x10))))
))
(let (($x13 (not $x12)))
(let (($x10 (forall ((?v1 Int) )(let (($x6 (|p$| ?v1)))
(or (|p$| ?0) $x6)))
))
(let ((@x41 (|quant-intro| (rewrite (= (=> (|p$| ?0) $x10) (or (not (|p$| ?0)) $x10))) (= $x12 $x39))))
(let ((@x70 (|mp~| (mp (asserted $x13) (monotonicity @x41 (= $x13 $x42)) $x42) (trans (sk (|~| $x42 (not (or $x48 $x50)))) @x67 (|~| $x42 $x65)) $x65)))
(let ((@x79 (|not-or-elim| (|and-elim| (mp @x70 @x77 (and $x46 $x61)) $x61) $x48)))
(let ((@x72 (|and-elim| (mp @x70 @x77 (and $x46 $x61)) $x46)))
(|unit-resolution| @x72 @x79 false))))))))))))))))))))

19f6b54cdb476573f91d167cec6fca10e0e66fc7 27 0
unsat
((set-logic AUFLIA)
(proof
(let (($x72 (forall ((?v0 |A$|) )(!(let (($x8 (|p$| ?v0)))
(not $x8)) :pattern ( (|p$| ?v0) )))
))
(let (($x6 (|p$| |x$|)))
(let ((@x46 (monotonicity (rewrite (= (=> $x6 (|p$| |y$|)) (or (not $x6) (|p$| |y$|)))) (= (not (=> $x6 (|p$| |y$|))) (not (or (not $x6) (|p$| |y$|)))))))
(let ((@x49 (mp (asserted (not (=> $x6 (|p$| |y$|)))) @x46 (not (or (not $x6) (|p$| |y$|))))))
(let ((@x47 (|not-or-elim| @x49 $x6)))
(let (($x40 (not $x6)))
(let (($x75 (or $x40 $x72)))
(let (($x12 (forall ((?v0 |A$|) )(let (($x8 (|p$| ?v0)))
(not $x8)))
))
(let (($x62 (or $x40 $x12)))
(let ((@x74 (|quant-intro| (refl (= (not (|p$| ?0)) (not (|p$| ?0)))) (= $x12 $x72))))
(let (($x9 (exists ((?v0 |A$|) )(|p$| ?v0))
))
(let (($x13 (ite $x6 (not $x9) $x12)))
(let ((@x58 (|nnf-neg| (refl (|~| (not (|p$| ?0)) (not (|p$| ?0)))) (|~| (not $x9) $x12))))
(let ((@x65 (|nnf-pos| (refl (|~| $x6 $x6)) (refl (|~| $x40 $x40)) @x58 (|nnf-pos| (refl (|~| (not (|p$| ?0)) (not (|p$| ?0)))) (|~| $x12 $x12)) (|~| $x13 (and $x62 (or $x6 $x12))))))
(let ((@x78 (mp (|and-elim| (|mp~| (asserted $x13) @x65 (and $x62 (or $x6 $x12))) $x62) (monotonicity @x74 (= $x62 $x75)) $x75)))
(let (($x86 (or (not $x72) $x40)))
(let ((@x87 ((_ |quant-inst| |x$|) $x86)))
(|unit-resolution| @x87 @x47 (|unit-resolution| @x78 @x47 $x72) false))))))))))))))))))))

e86ca8427589ec8e24e5a85d218331bfb59ff385 7 0
unsat
((set-logic AUFLIA)
(proof
(let ((@x33 (monotonicity (rewrite (= (= 3 3) true)) (= (not (= 3 3)) (not true)))))
(let ((@x37 (trans @x33 (rewrite (= (not true) false)) (= (not (= 3 3)) false))))
(mp (asserted (not (= 3 3))) @x37 false)))))

77108fa1aa6a8a356ebdd1a376316f26d90399cb 7 0
unsat
((set-logic AUFLIRA)
(proof
(let ((@x33 (monotonicity (rewrite (= (= 3.0 3.0) true)) (= (not (= 3.0 3.0)) (not true)))))
(let ((@x37 (trans @x33 (rewrite (= (not true) false)) (= (not (= 3.0 3.0)) false))))
(mp (asserted (not (= 3.0 3.0))) @x37 false)))))

98abe835b7d13273c58720c5dadf713cd8637495 9 0
unsat
((set-logic AUFLIA)
(proof
(let ((@x35 (monotonicity (rewrite (= (+ 3 1) 4)) (= (= (+ 3 1) 4) (= 4 4)))))
(let ((@x39 (trans @x35 (rewrite (= (= 4 4) true)) (= (= (+ 3 1) 4) true))))
(let ((@x42 (monotonicity @x39 (= (not (= (+ 3 1) 4)) (not true)))))
(let ((@x46 (trans @x42 (rewrite (= (not true) false)) (= (not (= (+ 3 1) 4)) false))))
(mp (asserted (not (= (+ 3 1) 4))) @x46 false)))))))

0382c7d04a37d9ca60cac3282bc80f6b329ab12f 16 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x10 (+ |z$| |x$|)))
(let ((?x11 (+ |y$| ?x10)))
(let ((?x8 (+ |y$| |z$|)))
(let ((?x9 (+ |x$| ?x8)))
(let (($x12 (= ?x9 ?x11)))
(let (($x13 (not $x12)))
(let ((@x43 (monotonicity (rewrite (= ?x10 (+ |x$| |z$|))) (= ?x11 (+ |y$| (+ |x$| |z$|))))))
(let ((@x47 (trans @x43 (rewrite (= (+ |y$| (+ |x$| |z$|)) (+ |x$| |y$| |z$|))) (= ?x11 (+ |x$| |y$| |z$|)))))
(let ((@x50 (monotonicity (rewrite (= ?x9 (+ |x$| |y$| |z$|))) @x47 (= $x12 (= (+ |x$| |y$| |z$|) (+ |x$| |y$| |z$|))))))
(let ((@x54 (trans @x50 (rewrite (= (= (+ |x$| |y$| |z$|) (+ |x$| |y$| |z$|)) true)) (= $x12 true))))
(let ((@x61 (trans (monotonicity @x54 (= $x13 (not true))) (rewrite (= (not true) false)) (= $x13 false))))
(mp (asserted $x13) @x61 false))))))))))))))

c608fc7154ce1246a30c68f4d20c1d35cedba663 11 0
unsat
((set-logic AUFLIA)
(proof
(let ((@x39 (monotonicity (rewrite (= (<= 3 8) true)) (= (ite (<= 3 8) 8 3) (ite true 8 3)))))
(let ((@x43 (trans @x39 (rewrite (= (ite true 8 3) 8)) (= (ite (<= 3 8) 8 3) 8))))
(let ((@x46 (monotonicity @x43 (= (< 5 (ite (<= 3 8) 8 3)) (< 5 8)))))
(let ((@x50 (trans @x46 (rewrite (= (< 5 8) true)) (= (< 5 (ite (<= 3 8) 8 3)) true))))
(let ((@x53 (monotonicity @x50 (= (not (< 5 (ite (<= 3 8) 8 3))) (not true)))))
(let ((@x57 (trans @x53 (rewrite (= (not true) false)) (= (not (< 5 (ite (<= 3 8) 8 3))) false))))
(mp (asserted (not (< 5 (ite (<= 3 8) 8 3)))) @x57 false)))))))))

4bdd1f2f245666e5db75e9d320ea9e892060d851 88 0
unsat
((set-logic AUFLIRA)
(proof
(let ((?x42 (* (~ 1.0) |x$|)))
(let (($x81 (>= |x$| 0.0)))
(let ((?x88 (ite $x81 |x$| ?x42)))
(let ((?x111 (* (~ 1.0) ?x88)))
(let ((?x146 (+ |x$| ?x111)))
(let (($x147 (<= ?x146 0.0)))
(let (($x131 (= |x$| ?x88)))
(let ((?x43 (* (~ 1.0) |y$|)))
(let ((?x44 (+ ?x42 ?x43)))
(let ((?x7 (+ |x$| |y$|)))
(let (($x69 (>= ?x7 0.0)))
(let ((?x76 (ite $x69 ?x7 ?x44)))
(let ((?x149 (* (~ 1.0) ?x76)))
(let ((?x177 (+ ?x44 ?x149)))
(let (($x179 (>= ?x177 0.0)))
(let (($x128 (= ?x44 ?x76)))
(let (($x70 (not $x69)))
(let (($x93 (>= |y$| 0.0)))
(let (($x94 (not $x93)))
(let (($x152 (>= (+ ?x7 ?x149) 0.0)))
(let (($x127 (= ?x7 ?x76)))
(let (($x188 (not $x179)))
(let ((@x159 (hypothesis $x93)))
(let ((?x100 (ite $x93 |y$| ?x43)))
(let ((?x112 (* (~ 1.0) ?x100)))
(let ((?x113 (+ ?x76 ?x111 ?x112)))
(let (($x114 (<= ?x113 0.0)))
(let (($x119 (not $x114)))
(let ((?x18 (+ (ite (< |x$| 0.0) (- |x$|) |x$|) (ite (< |y$| 0.0) (- |y$|) |y$|))))
(let (($x20 (not (<= (ite (< ?x7 0.0) (- ?x7) ?x7) ?x18))))
(let (($x15 (< |y$| 0.0)))
(let ((?x57 (ite $x15 ?x43 |y$|)))
(let (($x12 (< |x$| 0.0)))
(let ((?x52 (ite $x12 ?x42 |x$|)))
(let ((?x60 (+ ?x52 ?x57)))
(let (($x9 (< ?x7 0.0)))
(let ((?x47 (ite $x9 ?x44 ?x7)))
(let (($x63 (<= ?x47 ?x60)))
(let ((@x104 (trans (monotonicity (rewrite (= $x15 $x94)) (= ?x57 (ite $x94 ?x43 |y$|))) (rewrite (= (ite $x94 ?x43 |y$|) ?x100)) (= ?x57 ?x100))))
(let ((@x87 (monotonicity (rewrite (= $x12 (not $x81))) (= ?x52 (ite (not $x81) ?x42 |x$|)))))
(let ((@x92 (trans @x87 (rewrite (= (ite (not $x81) ?x42 |x$|) ?x88)) (= ?x52 ?x88))))
(let ((@x80 (trans (monotonicity (rewrite (= $x9 $x70)) (= ?x47 (ite $x70 ?x44 ?x7))) (rewrite (= (ite $x70 ?x44 ?x7) ?x76)) (= ?x47 ?x76))))
(let ((@x110 (monotonicity @x80 (monotonicity @x92 @x104 (= ?x60 (+ ?x88 ?x100))) (= $x63 (<= ?x76 (+ ?x88 ?x100))))))
(let ((@x118 (trans @x110 (rewrite (= (<= ?x76 (+ ?x88 ?x100)) $x114)) (= $x63 $x114))))
(let ((@x59 (monotonicity (rewrite (= (- |y$|) ?x43)) (= (ite $x15 (- |y$|) |y$|) ?x57))))
(let ((@x54 (monotonicity (rewrite (= (- |x$|) ?x42)) (= (ite $x12 (- |x$|) |x$|) ?x52))))
(let ((@x49 (monotonicity (rewrite (= (- ?x7) ?x44)) (= (ite $x9 (- ?x7) ?x7) ?x47))))
(let ((@x65 (monotonicity @x49 (monotonicity @x54 @x59 (= ?x18 ?x60)) (= (<= (ite $x9 (- ?x7) ?x7) ?x18) $x63))))
(let ((@x123 (trans (monotonicity @x65 (= $x20 (not $x63))) (monotonicity @x118 (= (not $x63) $x119)) (= $x20 $x119))))
(let ((@x124 (mp (asserted $x20) @x123 $x119)))
(let (($x137 (= |y$| ?x100)))
(let ((@x172 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x137) (<= (+ |y$| ?x112) 0.0))) (|unit-resolution| (|def-axiom| (or $x94 $x137)) @x159 $x137) (<= (+ |y$| ?x112) 0.0))))
(let ((?x148 (+ ?x42 ?x111)))
(let (($x151 (<= ?x148 0.0)))
(let (($x132 (= ?x42 ?x88)))
(let (($x82 (not $x81)))
(let ((@x157 ((_ |th-lemma| arith triangle-eq) (or (not $x131) $x147))))
(let ((@x158 (|unit-resolution| @x157 (|unit-resolution| (|def-axiom| (or $x82 $x131)) (hypothesis $x81) $x131) $x147)))
(let ((@x162 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1) (or $x69 $x82 $x94)) (hypothesis $x81) @x159 $x69)))
(let ((@x126 (|def-axiom| (or $x70 $x127))))
(let ((@x166 ((_ |th-lemma| arith triangle-eq) (or (not $x127) $x152))))
(let ((@x173 ((_ |th-lemma| arith farkas 1 -1 -1 1) @x172 (|unit-resolution| @x166 (|unit-resolution| @x126 @x162 $x127) $x152) @x124 @x158 false)))
(let ((@x136 (|def-axiom| (or $x81 $x132))))
(let ((@x182 (|unit-resolution| @x136 (|unit-resolution| (lemma @x173 (or $x82 $x94)) @x159 $x82) $x132)))
(let ((@x187 ((_ |th-lemma| arith farkas 2 -1 -1 1 1) @x159 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x132) $x151)) @x182 $x151) @x172 @x124 (hypothesis $x179) false)))
(let ((@x196 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x128) $x179)) (hypothesis $x128) (hypothesis $x188) false)))
(let ((@x197 (lemma @x196 (or (not $x128) $x179))))
(let ((@x199 (|unit-resolution| @x197 (|unit-resolution| (lemma @x187 (or $x188 $x94)) @x159 $x188) (not $x128))))
(let ((@x130 (|def-axiom| (or $x69 $x128))))
(let ((@x202 (|unit-resolution| @x166 (|unit-resolution| @x126 (|unit-resolution| @x130 @x199 $x69) $x127) $x152)))
(let ((@x203 ((_ |th-lemma| arith farkas 2 1 1 1 1) (|unit-resolution| (lemma @x173 (or $x82 $x94)) @x159 $x82) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x132) $x151)) @x182 $x151) @x172 @x124 @x202 false)))
(let ((@x204 (lemma @x203 $x94)))
(let ((@x210 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1) (or $x81 $x93 $x70)) (hypothesis $x69) @x204 $x81)))
(let ((@x134 (|def-axiom| (or $x82 $x131))))
(let ((@x214 (|unit-resolution| @x166 (|unit-resolution| @x126 (hypothesis $x69) $x127) $x152)))
(let ((?x145 (+ ?x43 ?x112)))
(let (($x176 (<= ?x145 0.0)))
(let (($x138 (= ?x43 ?x100)))
(let ((@x219 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x138) $x176)) (|unit-resolution| (|def-axiom| (or $x93 $x138)) @x204 $x138) $x176)))
(let ((@x220 ((_ |th-lemma| arith farkas 2 1 1 1 1) @x204 @x219 @x124 @x214 (|unit-resolution| @x157 (|unit-resolution| @x134 @x210 $x131) $x147) false)))
(let ((@x224 (|unit-resolution| @x197 (|unit-resolution| @x130 (lemma @x220 $x70) $x128) $x179)))
(let ((@x229 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x132) $x151)) (hypothesis $x132) (lemma ((_ |th-lemma| arith farkas 1 -1 -1 1) @x219 @x124 @x224 (hypothesis $x151) false) (not $x151)) false)))
(let ((@x232 (|unit-resolution| @x134 (|unit-resolution| @x136 (lemma @x229 (not $x132)) $x81) $x131)))
((_ |th-lemma| arith farkas -2 1 -1 -1 1) (|unit-resolution| @x136 (lemma @x229 (not $x132)) $x81) @x219 @x124 @x224 (|unit-resolution| @x157 @x232 $x147) false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

f8d266138153a7b5a745c746bbb489254a734ae0 16 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x10 (|p$| true)))
(let (($x7 (< 2 3)))
(let (($x8 (ite $x7 true false)))
(let ((?x9 (|p$| $x8)))
(let (($x11 (= ?x9 ?x10)))
(let (($x12 (not $x11)))
(let ((@x50 (monotonicity (monotonicity (rewrite (= $x7 true)) (= (|p$| $x7) ?x10)) (= (= (|p$| $x7) ?x10) (= ?x10 ?x10)))))
(let ((@x54 (trans @x50 (rewrite (= (= ?x10 ?x10) true)) (= (= (|p$| $x7) ?x10) true))))
(let ((@x61 (trans (monotonicity @x54 (= (not (= (|p$| $x7) ?x10)) (not true))) (rewrite (= (not true) false)) (= (not (= (|p$| $x7) ?x10)) false))))
(let ((@x41 (monotonicity (monotonicity (rewrite (= $x8 $x7)) (= ?x9 (|p$| $x7))) (= $x11 (= (|p$| $x7) ?x10)))))
(let ((@x44 (monotonicity @x41 (= $x12 (not (= (|p$| $x7) ?x10))))))
(mp (asserted $x12) (trans @x44 @x61 (= $x12 false)) false))))))))))))))

81a816463ea508b010daafde9e601b0b985afe71 16 0
unsat
((set-logic AUFLIA)
(proof
(let (($x11 (< |x$| 1)))
(let ((?x35 (+ 3 |x$|)))
(let (($x38 (<= 4 ?x35)))
(let (($x41 (or $x38 $x11)))
(let (($x44 (not $x41)))
(let ((@x55 (monotonicity (rewrite (= $x38 (>= |x$| 1))) (rewrite (= $x11 (not (>= |x$| 1)))) (= $x41 (or (>= |x$| 1) (not (>= |x$| 1)))))))
(let ((@x59 (trans @x55 (rewrite (= (or (>= |x$| 1) (not (>= |x$| 1))) true)) (= $x41 true))))
(let ((@x66 (trans (monotonicity @x59 (= $x44 (not true))) (rewrite (= (not true) false)) (= $x44 false))))
(let ((@x40 (monotonicity (rewrite (= (+ |x$| 3) ?x35)) (= (<= 4 (+ |x$| 3)) $x38))))
(let ((@x46 (monotonicity (monotonicity @x40 (= (or (<= 4 (+ |x$| 3)) $x11) $x41)) (= (not (or (<= 4 (+ |x$| 3)) $x11)) $x44))))
(let ((@x68 (trans @x46 @x66 (= (not (or (<= 4 (+ |x$| 3)) $x11)) false))))
(mp (asserted (not (or (<= 4 (+ |x$| 3)) $x11))) @x68 false))))))))))))))

3da41aa632fdaf484d160ab8b5a2c83b931d3de7 18 0
unsat
((set-logic AUFLIA)
(proof
(let (($x52 (= (+ |x$| (* (~ 1) |y$|)) (~ 4))))
(let ((@x46 (monotonicity (rewrite (= (+ |x$| 4) (+ 4 |x$|))) (= (= |y$| (+ |x$| 4)) (= |y$| (+ 4 |x$|))))))
(let ((@x55 (trans @x46 (rewrite (= (= |y$| (+ 4 |x$|)) $x52)) (= (= |y$| (+ |x$| 4)) $x52))))
(let ((@x84 (monotonicity (mp (asserted (= |y$| (+ |x$| 4))) @x55 $x52) (= (>= (+ |x$| (* (~ 1) |y$|)) 0) (>= (~ 4) 0)))))
(let ((@x88 (trans @x84 (rewrite (= (>= (~ 4) 0) false)) (= (>= (+ |x$| (* (~ 1) |y$|)) 0) false))))
(let (($x68 (>= (+ |x$| (* (~ 1) |y$|)) 0)))
(let ((@x74 (monotonicity (rewrite (= (< 0 (+ (* (~ 1) |x$|) |y$|)) (not $x68))) (= (not (< 0 (+ (* (~ 1) |x$|) |y$|))) (not (not $x68))))))
(let ((@x78 (trans @x74 (rewrite (= (not (not $x68)) $x68)) (= (not (< 0 (+ (* (~ 1) |x$|) |y$|))) $x68))))
(let (($x62 (< 0 (+ (* (~ 1) |x$|) |y$|))))
(let (($x65 (not $x62)))
(let (($x15 (not (< 0 (- |y$| |x$|)))))
(let ((@x64 (monotonicity (rewrite (= (- |y$| |x$|) (+ (* (~ 1) |x$|) |y$|))) (= (< 0 (- |y$| |x$|)) $x62))))
(let ((@x81 (mp (asserted $x15) (trans (monotonicity @x64 (= $x15 $x65)) @x78 (= $x15 $x68)) $x68)))
(mp @x81 @x88 false))))))))))))))))

e43b05132d28d45640c9d0131930806093dbb0e2 11 0
unsat
((set-logic AUFLIA)
(proof
(let ((@x37 (monotonicity (rewrite (= (+ 2 2) 4)) (= (= (+ 2 2) 5) (= 4 5)))))
(let ((@x41 (trans @x37 (rewrite (= (= 4 5) false)) (= (= (+ 2 2) 5) false))))
(let ((@x44 (monotonicity @x41 (= (not (= (+ 2 2) 5)) (not false)))))
(let ((@x48 (trans @x44 (rewrite (= (not false) true)) (= (not (= (+ 2 2) 5)) true))))
(let ((@x51 (monotonicity @x48 (= (not (not (= (+ 2 2) 5))) (not true)))))
(let ((@x55 (trans @x51 (rewrite (= (not true) false)) (= (not (not (= (+ 2 2) 5))) false))))
(mp (asserted (not (not (= (+ 2 2) 5)))) @x55 false)))))))))

135df42816691c806246099ddf6fc7f6b81a2f42 19 0
unsat
((set-logic AUFLIRA)
(proof
(let ((?x10 (* 7.0 |a$|)))
(let ((?x7 (* 3.0 |x$|)))
(let ((?x11 (+ ?x7 ?x10)))
(let (($x46 (>= ?x11 4.0)))
(let (($x44 (not $x46)))
(let ((@x43 (mp (asserted (< ?x11 4.0)) (rewrite (= (< ?x11 4.0) $x44)) $x44)))
(let ((?x15 (* 2.0 |x$|)))
(let (($x48 (<= ?x15 3.0)))
(let (($x49 (not $x48)))
(let ((@x52 (mp (asserted (< 3.0 ?x15)) (rewrite (= (< 3.0 ?x15) $x49)) $x49)))
(let (($x56 (>= |a$| 0.0)))
(let ((@x60 (monotonicity (rewrite (= (< |a$| 0.0) (not $x56))) (= (not (< |a$| 0.0)) (not (not $x56))))))
(let ((@x64 (trans @x60 (rewrite (= (not (not $x56)) $x56)) (= (not (< |a$| 0.0)) $x56))))
(let ((@x65 (mp (asserted (not (< |a$| 0.0))) @x64 $x56)))
((_ |th-lemma| arith farkas 7 3/2 1) @x65 @x52 @x43 false)))))))))))))))))

de926642fcc1657dfaa079f1656df9cc74f3caaf 22 0
unsat
((set-logic AUFLIA)
(proof
(let (($x17 (not false)))
(let (($x13 (<= 0 |x$|)))
(let (($x14 (not $x13)))
(let (($x15 (or $x14 $x13)))
(let ((?x8 (- 1)))
(let ((?x10 (* ?x8 |x$|)))
(let ((?x11 (+ |y$| ?x10)))
(let (($x12 (<= 0 ?x11)))
(let (($x16 (or $x12 $x15)))
(let (($x18 (= $x16 $x17)))
(let (($x19 (not $x18)))
(let ((@x58 (rewrite (= (or (<= 0 (+ |y$| (* (~ 1) |x$|))) true) true))))
(let ((@x48 (monotonicity (monotonicity (rewrite (= ?x8 (~ 1))) (= ?x10 (* (~ 1) |x$|))) (= ?x11 (+ |y$| (* (~ 1) |x$|))))))
(let ((@x56 (monotonicity (monotonicity @x48 (= $x12 (<= 0 (+ |y$| (* (~ 1) |x$|))))) (rewrite (= $x15 true)) (= $x16 (or (<= 0 (+ |y$| (* (~ 1) |x$|))) true)))))
(let ((@x65 (monotonicity (trans @x56 @x58 (= $x16 true)) (rewrite (= $x17 true)) (= $x18 (= true true)))))
(let ((@x69 (trans @x65 (rewrite (= (= true true) true)) (= $x18 true))))
(let ((@x76 (trans (monotonicity @x69 (= $x19 (not true))) (rewrite (= (not true) false)) (= $x19 false))))
(mp (asserted $x19) @x76 false))))))))))))))))))))

c19a59241b121ac2665c4fbd7ba1fa2d48fef984 159 0
unsat
((set-logic AUFLIA)
(proof
(let (($x22 (= |m$| |n$|)))
(let ((@x478 (symm (commutativity (= $x22 (= |n$| |m$|))) (= (= |n$| |m$|) $x22))))
(let (($x18 (= |n$| |m$|)))
(let ((?x100 (* (~ 1) |m$|)))
(let ((?x101 (+ |n$| ?x100)))
(let (($x116 (>= ?x101 0)))
(let ((?x76 (* (~ 1) |n$a|)))
(let ((?x94 (+ |m$| ?x76)))
(let (($x125 (<= ?x94 0)))
(let ((?x77 (+ |n$| ?x76)))
(let (($x86 (>= ?x77 0)))
(let (($x259 (or $x86 $x125)))
(let ((@x265 (monotonicity (rewrite (= (and (not $x86) (not $x125)) (not $x259))) (= (not (and (not $x86) (not $x125))) (not (not $x259))))))
(let ((@x269 (trans @x265 (rewrite (= (not (not $x259)) $x259)) (= (not (and (not $x86) (not $x125))) $x259))))
(let (($x126 (not $x125)))
(let (($x85 (not $x86)))
(let (($x141 (and $x85 $x126)))
(let (($x208 (not $x141)))
(let (($x28 (= |n$a| |m$|)))
(let (($x35 (and $x28 $x22)))
(let (($x78 (<= ?x77 0)))
(let (($x79 (not $x78)))
(let (($x11 (= |m$| |n$a|)))
(let (($x82 (and $x11 $x79)))
(let (($x89 (and $x22 $x85)))
(let (($x93 (>= ?x94 0)))
(let (($x92 (not $x93)))
(let (($x97 (and $x92 $x79)))
(let (($x26 (= |n$a| |n$|)))
(let (($x102 (<= ?x101 0)))
(let (($x103 (not $x102)))
(let (($x106 (and $x103 $x26)))
(let (($x109 (and $x103 $x85)))
(let (($x112 (and $x28 $x103)))
(let (($x115 (not $x116)))
(let (($x119 (and $x26 $x115)))
(let (($x122 (and $x79 $x115)))
(let (($x129 (and $x126 $x22)))
(let (($x132 (and $x126 $x103)))
(let (($x135 (and $x18 $x92)))
(let (($x16 (= |n$| |n$a|)))
(let (($x138 (and $x16 $x126)))
(let (($x144 (and $x115 $x11)))
(let (($x147 (and $x115 $x92)))
(let (($x195 (or $x147 $x144 $x141 $x138 $x135 $x132 $x129 $x122 $x119 $x112 $x109 $x106 $x97 $x89 $x82 $x35)))
(let (($x38 (or (and (< |m$| |n$a|) (< |n$a| |n$|)) (or (and $x22 (< |n$| |n$a|)) (or (and $x11 (< |n$a| |n$|)) $x35)))))
(let (($x40 (or (and (< |m$| |n$|) (< |n$| |n$a|)) (or (and (< |m$| |n$|) $x26) $x38))))
(let (($x43 (or (and (< |n$a| |n$|) (< |n$| |m$|)) (or (and $x26 (< |n$| |m$|)) (or (and $x28 (< |m$| |n$|)) $x40)))))
(let (($x45 (or (and (< |n$a| |m$|) (< |m$| |n$|)) (or (and (< |n$a| |m$|) $x22) $x43))))
(let (($x48 (or (and (< |n$| |n$a|) (< |n$a| |m$|)) (or (and $x16 (< |n$a| |m$|)) (or (and $x18 (< |m$| |n$a|)) $x45)))))
(let (($x50 (or (and (< |n$| |m$|) (< |m$| |n$a|)) (or (and (< |n$| |m$|) $x11) $x48))))
(let (($x51 (not $x50)))
(let (($x168 (or $x119 (or $x112 (or $x109 (or $x106 (or $x97 (or $x89 (or $x82 $x35)))))))))
(let (($x189 (or $x144 (or $x141 (or $x138 (or $x135 (or $x132 (or $x129 (or $x122 $x168)))))))))
(let (($x187 (= $x48 (or $x141 (or $x138 (or $x135 (or $x132 (or $x129 (or $x122 $x168)))))))))
(let (($x184 (= (or (and $x16 (< |n$a| |m$|)) (or (and $x18 (< |m$| |n$a|)) $x45)) (or $x138 (or $x135 (or $x132 (or $x129 (or $x122 $x168))))))))
(let (($x181 (= (or (and $x18 (< |m$| |n$a|)) $x45) (or $x135 (or $x132 (or $x129 (or $x122 $x168)))))))
(let (($x169 (= (or (and $x26 (< |n$| |m$|)) (or (and $x28 (< |m$| |n$|)) $x40)) $x168)))
(let (($x166 (= (or (and $x28 (< |m$| |n$|)) $x40) (or $x112 (or $x109 (or $x106 (or $x97 (or $x89 (or $x82 $x35)))))))))
(let (($x160 (= (or (and (< |m$| |n$|) $x26) $x38) (or $x106 (or $x97 (or $x89 (or $x82 $x35)))))))
(let (($x154 (= (or (and $x22 (< |n$| |n$a|)) (or (and $x11 (< |n$a| |n$|)) $x35)) (or $x89 (or $x82 $x35)))))
(let ((@x81 (rewrite (= (< |n$a| |n$|) $x79))))
(let ((@x152 (monotonicity (monotonicity @x81 (= (and $x11 (< |n$a| |n$|)) $x82)) (= (or (and $x11 (< |n$a| |n$|)) $x35) (or $x82 $x35)))))
(let ((@x88 (rewrite (= (< |n$| |n$a|) $x85))))
(let ((@x155 (monotonicity (monotonicity @x88 (= (and $x22 (< |n$| |n$a|)) $x89)) @x152 $x154)))
(let ((@x96 (rewrite (= (< |m$| |n$a|) $x92))))
(let ((@x99 (monotonicity @x96 @x81 (= (and (< |m$| |n$a|) (< |n$a| |n$|)) $x97))))
(let ((@x158 (monotonicity @x99 @x155 (= $x38 (or $x97 (or $x89 (or $x82 $x35)))))))
(let ((@x105 (rewrite (= (< |m$| |n$|) $x103))))
(let ((@x161 (monotonicity (monotonicity @x105 (= (and (< |m$| |n$|) $x26) $x106)) @x158 $x160)))
(let ((@x111 (monotonicity @x105 @x88 (= (and (< |m$| |n$|) (< |n$| |n$a|)) $x109))))
(let ((@x164 (monotonicity @x111 @x161 (= $x40 (or $x109 (or $x106 (or $x97 (or $x89 (or $x82 $x35)))))))))
(let ((@x167 (monotonicity (monotonicity @x105 (= (and $x28 (< |m$| |n$|)) $x112)) @x164 $x166)))
(let ((@x118 (rewrite (= (< |n$| |m$|) $x115))))
(let ((@x170 (monotonicity (monotonicity @x118 (= (and $x26 (< |n$| |m$|)) $x119)) @x167 $x169)))
(let ((@x124 (monotonicity @x81 @x118 (= (and (< |n$a| |n$|) (< |n$| |m$|)) $x122))))
(let ((@x128 (rewrite (= (< |n$a| |m$|) $x126))))
(let ((@x176 (monotonicity (monotonicity @x128 (= (and (< |n$a| |m$|) $x22) $x129)) (monotonicity @x124 @x170 (= $x43 (or $x122 $x168))) (= (or (and (< |n$a| |m$|) $x22) $x43) (or $x129 (or $x122 $x168))))))
(let ((@x134 (monotonicity @x128 @x105 (= (and (< |n$a| |m$|) (< |m$| |n$|)) $x132))))
(let ((@x179 (monotonicity @x134 @x176 (= $x45 (or $x132 (or $x129 (or $x122 $x168)))))))
(let ((@x182 (monotonicity (monotonicity @x96 (= (and $x18 (< |m$| |n$a|)) $x135)) @x179 $x181)))
(let ((@x185 (monotonicity (monotonicity @x128 (= (and $x16 (< |n$a| |m$|)) $x138)) @x182 $x184)))
(let ((@x143 (monotonicity @x88 @x128 (= (and (< |n$| |n$a|) (< |n$a| |m$|)) $x141))))
(let ((@x191 (monotonicity (monotonicity @x118 (= (and (< |n$| |m$|) $x11) $x144)) (monotonicity @x143 @x185 $x187) (= (or (and (< |n$| |m$|) $x11) $x48) $x189))))
(let ((@x149 (monotonicity @x118 @x96 (= (and (< |n$| |m$|) (< |m$| |n$a|)) $x147))))
(let ((@x199 (trans (monotonicity @x149 @x191 (= $x50 (or $x147 $x189))) (rewrite (= (or $x147 $x189) $x195)) (= $x50 $x195))))
(let ((@x203 (mp (asserted $x51) (monotonicity @x199 (= $x51 (not $x195))) (not $x195))))
(let ((@x270 (mp (|not-or-elim| @x203 $x208) @x269 $x259)))
(let (($x271 (not $x16)))
(let (($x272 (or $x271 $x125)))
(let ((@x278 (monotonicity (rewrite (= $x138 (not $x272))) (= (not $x138) (not (not $x272))))))
(let ((@x282 (trans @x278 (rewrite (= (not (not $x272)) $x272)) (= (not $x138) $x272))))
(let ((@x283 (mp (|not-or-elim| @x203 (not $x138)) @x282 $x272)))
(let (($x284 (not $x18)))
(let (($x309 (not $x22)))
(let ((@x432 (hypothesis $x79)))
(let (($x384 (or $x93 $x78)))
(let ((@x390 (monotonicity (rewrite (= $x97 (not $x384))) (= (not $x97) (not (not $x384))))))
(let ((@x394 (trans @x390 (rewrite (= (not (not $x384)) $x384)) (= (not $x97) $x384))))
(let ((@x395 (mp (|not-or-elim| @x203 (not $x97)) @x394 $x384)))
(let (($x246 (not $x11)))
(let (($x408 (or $x246 $x78)))
(let ((@x414 (monotonicity (rewrite (= $x82 (not $x408))) (= (not $x82) (not (not $x408))))))
(let ((@x418 (trans @x414 (rewrite (= (not (not $x408)) $x408)) (= (not $x82) $x408))))
(let ((@x419 (mp (|not-or-elim| @x203 (not $x82)) @x418 $x408)))
(let ((@x437 ((_ |th-lemma| arith triangle-eq) (or $x11 $x126 $x92))))
(let ((@x438 (|unit-resolution| @x437 (|unit-resolution| @x419 @x432 $x246) (|unit-resolution| @x395 @x432 $x93) $x126)))
(let (($x310 (or $x125 $x309)))
(let ((@x316 (monotonicity (rewrite (= $x129 (not $x310))) (= (not $x129) (not (not $x310))))))
(let ((@x320 (trans @x316 (rewrite (= (not (not $x310)) $x310)) (= (not $x129) $x310))))
(let ((@x321 (mp (|not-or-elim| @x203 (not $x129)) @x320 $x310)))
(let ((@x448 (mp (|unit-resolution| @x321 @x438 $x309) (monotonicity (commutativity (= $x22 $x18)) (= $x309 $x284)) $x284)))
(let (($x322 (or $x78 $x116)))
(let ((@x328 (monotonicity (rewrite (= $x122 (not $x322))) (= (not $x122) (not (not $x322))))))
(let ((@x332 (trans @x328 (rewrite (= (not (not $x322)) $x322)) (= (not $x122) $x322))))
(let ((@x333 (mp (|not-or-elim| @x203 (not $x122)) @x332 $x322)))
(let (($x297 (or $x125 $x102)))
(let ((@x303 (monotonicity (rewrite (= $x132 (not $x297))) (= (not $x132) (not (not $x297))))))
(let ((@x307 (trans @x303 (rewrite (= (not (not $x297)) $x297)) (= (not $x132) $x297))))
(let ((@x308 (mp (|not-or-elim| @x203 (not $x132)) @x307 $x297)))
(let ((@x442 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x18 $x103 $x115)) (|unit-resolution| @x308 @x438 $x102) (|unit-resolution| @x333 @x432 $x116) $x18)))
(let ((@x457 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x16 $x79 $x85)) (lemma (|unit-resolution| @x442 @x448 false) $x78) (or $x16 $x85))))
(let ((@x458 (|unit-resolution| @x457 (|unit-resolution| @x283 (hypothesis $x126) $x271) (|unit-resolution| @x270 (hypothesis $x126) $x86) false)))
(let ((@x459 (lemma @x458 $x125)))
(let (($x73 (or $x116 $x93)))
(let ((@x240 (monotonicity (rewrite (= $x147 (not $x73))) (= (not $x147) (not (not $x73))))))
(let ((@x244 (trans @x240 (rewrite (= (not (not $x73)) $x73)) (= (not $x147) $x73))))
(let ((@x245 (mp (|not-or-elim| @x203 (not $x147)) @x244 $x73)))
(let (($x247 (or $x116 $x246)))
(let ((@x253 (monotonicity (rewrite (= $x144 (not $x247))) (= (not $x144) (not (not $x247))))))
(let ((@x257 (trans @x253 (rewrite (= (not (not $x247)) $x247)) (= (not $x144) $x247))))
(let ((@x258 (mp (|not-or-elim| @x203 (not $x144)) @x257 $x247)))
(let ((@x463 (|unit-resolution| @x437 (|unit-resolution| @x258 (hypothesis $x115) $x246) (|unit-resolution| @x245 (hypothesis $x115) $x93) @x459 false)))
(let (($x334 (not $x26)))
(let (($x372 (or $x102 $x334)))
(let ((@x378 (monotonicity (rewrite (= $x106 (not $x372))) (= (not $x106) (not (not $x372))))))
(let ((@x382 (trans @x378 (rewrite (= (not (not $x372)) $x372)) (= (not $x106) $x372))))
(let ((@x383 (mp (|not-or-elim| @x203 (not $x106)) @x382 $x372)))
(let ((@x473 (mp (|unit-resolution| @x383 (hypothesis $x103) $x334) (monotonicity (commutativity (= $x26 $x16)) (= $x334 $x271)) $x271)))
(let (($x360 (or $x102 $x86)))
(let ((@x366 (monotonicity (rewrite (= $x109 (not $x360))) (= (not $x109) (not (not $x360))))))
(let ((@x370 (trans @x366 (rewrite (= (not (not $x360)) $x360)) (= (not $x109) $x360))))
(let ((@x371 (mp (|not-or-elim| @x203 (not $x109)) @x370 $x360)))
(let ((@x467 (|unit-resolution| @x457 (|unit-resolution| @x371 (hypothesis $x103) $x86) $x16)))
(let ((@x476 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x18 $x103 $x115)) (lemma (|unit-resolution| @x467 @x473 false) $x102) (lemma @x463 $x116) $x18)))
(let (($x285 (or $x284 $x93)))
(let ((@x291 (monotonicity (rewrite (= $x135 (not $x285))) (= (not $x135) (not (not $x285))))))
(let ((@x295 (trans @x291 (rewrite (= (not (not $x285)) $x285)) (= (not $x135) $x285))))
(let ((@x296 (mp (|not-or-elim| @x203 (not $x135)) @x295 $x285)))
(let ((@x486 (mp (|unit-resolution| @x437 (|unit-resolution| @x296 @x476 $x93) @x459 $x11) (symm (commutativity (= $x28 $x11)) (= $x11 $x28)) $x28)))
(let (($x420 (or (not $x28) $x309)))
(let ((@x426 (monotonicity (rewrite (= $x35 (not $x420))) (= (not $x35) (not (not $x420))))))
(let ((@x430 (trans @x426 (rewrite (= (not (not $x420)) $x420)) (= (not $x35) $x420))))
(let ((@x431 (mp (|not-or-elim| @x203 (not $x35)) @x430 $x420)))
(|unit-resolution| @x431 @x486 (mp @x476 @x478 $x22) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

ad69b5703e25623b7fccdbcfa3db5949b2899f42 927 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x131 (* (~ 1) |x4$|)))
(let (($x436 (>= |x4$| 0)))
(let ((?x443 (ite $x436 |x4$| ?x131)))
(let ((?x454 (* (~ 1) ?x443)))
(let ((?x675 (+ |x4$| ?x454)))
(let (($x676 (<= ?x675 0)))
(let (($x782 (not $x676)))
(let ((?x672 (+ ?x131 ?x454)))
(let (($x673 (<= ?x672 0)))
(let (($x743 (not $x673)))
(let ((?x653 (* (~ 1) |x11$|)))
(let ((?x654 (+ |x2$| ?x653)))
(let (($x656 (>= ?x654 0)))
(let (($x708 (not $x656)))
(let (($x71 (= |x2$| |x11$|)))
(let ((@x1263 (hypothesis $x656)))
(let (($x655 (<= ?x654 0)))
(let ((?x165 (* (~ 1) |x6$|)))
(let (($x386 (>= |x6$| 0)))
(let ((?x393 (ite $x386 |x6$| ?x165)))
(let ((?x404 (* (~ 1) ?x393)))
(let ((?x669 (+ |x6$| ?x404)))
(let (($x934 (<= ?x669 0)))
(let (($x610 (= |x6$| ?x393)))
(let (($x411 (>= |x5$| 0)))
(let (($x286 (>= |x9$| 0)))
(let (($x671 (>= ?x669 0)))
(let (($x287 (not $x286)))
(let ((@x1426 (hypothesis $x287)))
(let ((?x233 (* (~ 1) |x10$|)))
(let (($x311 (>= |x10$| 0)))
(let ((?x318 (ite $x311 |x10$| ?x233)))
(let ((?x329 (* (~ 1) ?x318)))
(let ((?x660 (+ |x10$| ?x329)))
(let (($x1369 (<= ?x660 0)))
(let (($x642 (= |x10$| ?x318)))
(let (($x643 (= ?x233 ?x318)))
(let (($x1119 (not $x643)))
(let ((?x1101 (+ ?x233 ?x329)))
(let (($x1247 (<= ?x1101 0)))
(let (($x1259 (not $x1247)))
(let ((?x216 (* (~ 1) |x9$|)))
(let ((?x293 (ite $x286 |x9$| ?x216)))
(let ((?x304 (* (~ 1) ?x293)))
(let ((?x1498 (+ ?x216 ?x304)))
(let (($x1543 (>= ?x1498 0)))
(let (($x635 (= ?x216 ?x293)))
(let ((@x639 (|def-axiom| (or $x286 $x635))))
(let ((@x1553 (|unit-resolution| @x639 @x1426 $x635)))
(let ((@x1572 ((_ |th-lemma| arith triangle-eq) (or (not $x635) $x1543))))
(let ((@x1573 (|unit-resolution| @x1572 @x1553 $x1543)))
(let ((?x182 (* (~ 1) |x7$|)))
(let (($x361 (>= |x7$| 0)))
(let ((?x368 (ite $x361 |x7$| ?x182)))
(let ((?x379 (* (~ 1) ?x368)))
(let ((?x666 (+ |x7$| ?x379)))
(let (($x838 (<= ?x666 0)))
(let (($x618 (= |x7$| ?x368)))
(let (($x412 (not $x411)))
(let ((@x842 (hypothesis $x412)))
(let ((?x775 (+ ?x165 ?x404)))
(let (($x778 (<= ?x775 0)))
(let (($x611 (= ?x165 ?x393)))
(let (($x387 (not $x386)))
(let (($x362 (not $x361)))
(let ((@x1025 (hypothesis $x362)))
(let ((@x1024 (hypothesis $x386)))
(let ((?x405 (+ |x5$| |x7$| ?x404)))
(let (($x617 (>= ?x405 0)))
(let (($x406 (= ?x405 0)))
(let ((?x330 (+ |x9$| |x11$| ?x329)))
(let (($x331 (= ?x330 0)))
(let ((?x305 (+ |x8$| |x10$| ?x304)))
(let (($x306 (= ?x305 0)))
(let ((?x199 (* (~ 1) |x8$|)))
(let (($x336 (>= |x8$| 0)))
(let ((?x343 (ite $x336 |x8$| ?x199)))
(let ((?x354 (* (~ 1) ?x343)))
(let ((?x355 (+ |x7$| |x9$| ?x354)))
(let (($x356 (= ?x355 0)))
(let ((?x380 (+ |x6$| |x8$| ?x379)))
(let (($x381 (= ?x380 0)))
(let ((?x148 (* (~ 1) |x5$|)))
(let ((?x418 (ite $x411 |x5$| ?x148)))
(let ((?x429 (* (~ 1) ?x418)))
(let ((?x430 (+ |x4$| |x6$| ?x429)))
(let (($x431 (= ?x430 0)))
(let ((?x455 (+ |x3$| |x5$| ?x454)))
(let (($x456 (= ?x455 0)))
(let ((?x114 (* (~ 1) |x3$|)))
(let (($x461 (>= |x3$| 0)))
(let ((?x468 (ite $x461 |x3$| ?x114)))
(let ((?x479 (* (~ 1) ?x468)))
(let ((?x480 (+ |x2$| |x4$| ?x479)))
(let (($x481 (= ?x480 0)))
(let ((?x96 (* (~ 1) |x2$|)))
(let (($x486 (>= |x2$| 0)))
(let ((?x493 (ite $x486 |x2$| ?x96)))
(let ((?x504 (* (~ 1) ?x493)))
(let ((?x505 (+ |x3$| |x1$| ?x504)))
(let (($x506 (= ?x505 0)))
(let (($x535 (and $x506 $x481 $x456 $x431 $x406 $x381 $x356 $x306 $x331)))
(let (($x546 (not (or (not $x535) (and (= |x1$| |x10$|) $x71)))))
(let (($x70 (= |x1$| |x10$|)))
(let (($x72 (and $x70 $x71)))
(let (($x62 (and (= |x10$| (- (ite (< |x9$| 0) (- |x9$|) |x9$|) |x8$|)) (= |x11$| (- (ite (< |x10$| 0) (- |x10$|) |x10$|) |x9$|)))))
(let (($x64 (and (= |x8$| (- (ite (< |x7$| 0) (- |x7$|) |x7$|) |x6$|)) (and (= |x9$| (- (ite (< |x8$| 0) (- |x8$|) |x8$|) |x7$|)) $x62))))
(let (($x66 (and (= |x6$| (- (ite (< |x5$| 0) (- |x5$|) |x5$|) |x4$|)) (and (= |x7$| (- (ite (< |x6$| 0) (- |x6$|) |x6$|) |x5$|)) $x64))))
(let (($x68 (and (= |x4$| (- (ite (< |x3$| 0) (- |x3$|) |x3$|) |x2$|)) (and (= |x5$| (- (ite (< |x4$| 0) (- |x4$|) |x4$|) |x3$|)) $x66))))
(let (($x73 (=> (and (= |x3$| (- (ite (< |x2$| 0) (- |x2$|) |x2$|) |x1$|)) $x68) $x72)))
(let (($x74 (not $x73)))
(let (($x57 (< |x10$| 0)))
(let ((?x236 (ite $x57 ?x233 |x10$|)))
(let ((?x242 (+ ?x216 ?x236)))
(let (($x247 (= |x11$| ?x242)))
(let (($x51 (< |x9$| 0)))
(let ((?x219 (ite $x51 ?x216 |x9$|)))
(let ((?x225 (+ ?x199 ?x219)))
(let (($x230 (= |x10$| ?x225)))
(let (($x250 (and $x230 $x247)))
(let (($x45 (< |x8$| 0)))
(let ((?x202 (ite $x45 ?x199 |x8$|)))
(let ((?x208 (+ ?x182 ?x202)))
(let (($x213 (= |x9$| ?x208)))
(let (($x253 (and $x213 $x250)))
(let (($x39 (< |x7$| 0)))
(let ((?x185 (ite $x39 ?x182 |x7$|)))
(let ((?x191 (+ ?x165 ?x185)))
(let (($x196 (= |x8$| ?x191)))
(let (($x256 (and $x196 $x253)))
(let (($x33 (< |x6$| 0)))
(let ((?x168 (ite $x33 ?x165 |x6$|)))
(let ((?x174 (+ ?x148 ?x168)))
(let (($x179 (= |x7$| ?x174)))
(let (($x259 (and $x179 $x256)))
(let (($x27 (< |x5$| 0)))
(let ((?x151 (ite $x27 ?x148 |x5$|)))
(let ((?x157 (+ ?x131 ?x151)))
(let (($x162 (= |x6$| ?x157)))
(let (($x262 (and $x162 $x259)))
(let (($x21 (< |x4$| 0)))
(let ((?x134 (ite $x21 ?x131 |x4$|)))
(let ((?x140 (+ ?x114 ?x134)))
(let (($x145 (= |x5$| ?x140)))
(let (($x265 (and $x145 $x262)))
(let (($x15 (< |x3$| 0)))
(let ((?x117 (ite $x15 ?x114 |x3$|)))
(let ((?x123 (+ ?x96 ?x117)))
(let (($x128 (= |x4$| ?x123)))
(let (($x268 (and $x128 $x265)))
(let (($x8 (< |x2$| 0)))
(let ((?x99 (ite $x8 ?x96 |x2$|)))
(let ((?x106 (+ (* (~ 1) |x1$|) ?x99)))
(let (($x111 (= |x3$| ?x106)))
(let (($x271 (and $x111 $x268)))
(let (($x278 (or (not $x271) $x72)))
(let (($x526 (and $x456 (and $x431 (and $x406 (and $x381 (and $x356 (and $x306 $x331))))))))
(let (($x524 (= $x262 (and $x431 (and $x406 (and $x381 (and $x356 (and $x306 $x331))))))))
(let ((@x317 (monotonicity (rewrite (= $x57 (not $x311))) (= ?x236 (ite (not $x311) ?x233 |x10$|)))))
(let ((@x322 (trans @x317 (rewrite (= (ite (not $x311) ?x233 |x10$|) ?x318)) (= ?x236 ?x318))))
(let ((@x328 (monotonicity (monotonicity @x322 (= ?x242 (+ ?x216 ?x318))) (= $x247 (= |x11$| (+ ?x216 ?x318))))))
(let ((@x335 (trans @x328 (rewrite (= (= |x11$| (+ ?x216 ?x318)) $x331)) (= $x247 $x331))))
(let ((@x292 (monotonicity (rewrite (= $x51 $x287)) (= ?x219 (ite $x287 ?x216 |x9$|)))))
(let ((@x300 (monotonicity (trans @x292 (rewrite (= (ite $x287 ?x216 |x9$|) ?x293)) (= ?x219 ?x293)) (= ?x225 (+ ?x199 ?x293)))))
(let ((@x310 (trans (monotonicity @x300 (= $x230 (= |x10$| (+ ?x199 ?x293)))) (rewrite (= (= |x10$| (+ ?x199 ?x293)) $x306)) (= $x230 $x306))))
(let ((@x342 (monotonicity (rewrite (= $x45 (not $x336))) (= ?x202 (ite (not $x336) ?x199 |x8$|)))))
(let ((@x347 (trans @x342 (rewrite (= (ite (not $x336) ?x199 |x8$|) ?x343)) (= ?x202 ?x343))))
(let ((@x353 (monotonicity (monotonicity @x347 (= ?x208 (+ ?x182 ?x343))) (= $x213 (= |x9$| (+ ?x182 ?x343))))))
(let ((@x360 (trans @x353 (rewrite (= (= |x9$| (+ ?x182 ?x343)) $x356)) (= $x213 $x356))))
(let ((@x516 (monotonicity @x360 (monotonicity @x310 @x335 (= $x250 (and $x306 $x331))) (= $x253 (and $x356 (and $x306 $x331))))))
(let ((@x367 (monotonicity (rewrite (= $x39 $x362)) (= ?x185 (ite $x362 ?x182 |x7$|)))))
(let ((@x375 (monotonicity (trans @x367 (rewrite (= (ite $x362 ?x182 |x7$|) ?x368)) (= ?x185 ?x368)) (= ?x191 (+ ?x165 ?x368)))))
(let ((@x385 (trans (monotonicity @x375 (= $x196 (= |x8$| (+ ?x165 ?x368)))) (rewrite (= (= |x8$| (+ ?x165 ?x368)) $x381)) (= $x196 $x381))))
(let ((@x519 (monotonicity @x385 @x516 (= $x256 (and $x381 (and $x356 (and $x306 $x331)))))))
(let ((@x392 (monotonicity (rewrite (= $x33 $x387)) (= ?x168 (ite $x387 ?x165 |x6$|)))))
(let ((@x400 (monotonicity (trans @x392 (rewrite (= (ite $x387 ?x165 |x6$|) ?x393)) (= ?x168 ?x393)) (= ?x174 (+ ?x148 ?x393)))))
(let ((@x410 (trans (monotonicity @x400 (= $x179 (= |x7$| (+ ?x148 ?x393)))) (rewrite (= (= |x7$| (+ ?x148 ?x393)) $x406)) (= $x179 $x406))))
(let ((@x522 (monotonicity @x410 @x519 (= $x259 (and $x406 (and $x381 (and $x356 (and $x306 $x331))))))))
(let ((@x417 (monotonicity (rewrite (= $x27 $x412)) (= ?x151 (ite $x412 ?x148 |x5$|)))))
(let ((@x425 (monotonicity (trans @x417 (rewrite (= (ite $x412 ?x148 |x5$|) ?x418)) (= ?x151 ?x418)) (= ?x157 (+ ?x131 ?x418)))))
(let ((@x435 (trans (monotonicity @x425 (= $x162 (= |x6$| (+ ?x131 ?x418)))) (rewrite (= (= |x6$| (+ ?x131 ?x418)) $x431)) (= $x162 $x431))))
(let ((@x442 (monotonicity (rewrite (= $x21 (not $x436))) (= ?x134 (ite (not $x436) ?x131 |x4$|)))))
(let ((@x447 (trans @x442 (rewrite (= (ite (not $x436) ?x131 |x4$|) ?x443)) (= ?x134 ?x443))))
(let ((@x453 (monotonicity (monotonicity @x447 (= ?x140 (+ ?x114 ?x443))) (= $x145 (= |x5$| (+ ?x114 ?x443))))))
(let ((@x460 (trans @x453 (rewrite (= (= |x5$| (+ ?x114 ?x443)) $x456)) (= $x145 $x456))))
(let ((@x467 (monotonicity (rewrite (= $x15 (not $x461))) (= ?x117 (ite (not $x461) ?x114 |x3$|)))))
(let ((@x472 (trans @x467 (rewrite (= (ite (not $x461) ?x114 |x3$|) ?x468)) (= ?x117 ?x468))))
(let ((@x478 (monotonicity (monotonicity @x472 (= ?x123 (+ ?x96 ?x468))) (= $x128 (= |x4$| (+ ?x96 ?x468))))))
(let ((@x485 (trans @x478 (rewrite (= (= |x4$| (+ ?x96 ?x468)) $x481)) (= $x128 $x481))))
(let ((@x531 (monotonicity @x485 (monotonicity @x460 (monotonicity @x435 @x522 $x524) (= $x265 $x526)) (= $x268 (and $x481 $x526)))))
(let ((@x492 (monotonicity (rewrite (= $x8 (not $x486))) (= ?x99 (ite (not $x486) ?x96 |x2$|)))))
(let ((@x497 (trans @x492 (rewrite (= (ite (not $x486) ?x96 |x2$|) ?x493)) (= ?x99 ?x493))))
(let ((@x503 (monotonicity (monotonicity @x497 (= ?x106 (+ (* (~ 1) |x1$|) ?x493))) (= $x111 (= |x3$| (+ (* (~ 1) |x1$|) ?x493))))))
(let ((@x510 (trans @x503 (rewrite (= (= |x3$| (+ (* (~ 1) |x1$|) ?x493)) $x506)) (= $x111 $x506))))
(let ((@x539 (trans (monotonicity @x510 @x531 (= $x271 (and $x506 (and $x481 $x526)))) (rewrite (= (and $x506 (and $x481 $x526)) $x535)) (= $x271 $x535))))
(let ((@x545 (monotonicity (monotonicity @x539 (= (not $x271) (not $x535))) (= $x278 (or (not $x535) $x72)))))
(let ((@x238 (monotonicity (rewrite (= (- |x10$|) ?x233)) (= (ite $x57 (- |x10$|) |x10$|) ?x236))))
(let ((@x241 (monotonicity @x238 (= (- (ite $x57 (- |x10$|) |x10$|) |x9$|) (- ?x236 |x9$|)))))
(let ((@x246 (trans @x241 (rewrite (= (- ?x236 |x9$|) ?x242)) (= (- (ite $x57 (- |x10$|) |x10$|) |x9$|) ?x242))))
(let ((@x249 (monotonicity @x246 (= (= |x11$| (- (ite $x57 (- |x10$|) |x10$|) |x9$|)) $x247))))
(let ((@x221 (monotonicity (rewrite (= (- |x9$|) ?x216)) (= (ite $x51 (- |x9$|) |x9$|) ?x219))))
(let ((@x224 (monotonicity @x221 (= (- (ite $x51 (- |x9$|) |x9$|) |x8$|) (- ?x219 |x8$|)))))
(let ((@x229 (trans @x224 (rewrite (= (- ?x219 |x8$|) ?x225)) (= (- (ite $x51 (- |x9$|) |x9$|) |x8$|) ?x225))))
(let ((@x232 (monotonicity @x229 (= (= |x10$| (- (ite $x51 (- |x9$|) |x9$|) |x8$|)) $x230))))
(let ((@x204 (monotonicity (rewrite (= (- |x8$|) ?x199)) (= (ite $x45 (- |x8$|) |x8$|) ?x202))))
(let ((@x207 (monotonicity @x204 (= (- (ite $x45 (- |x8$|) |x8$|) |x7$|) (- ?x202 |x7$|)))))
(let ((@x212 (trans @x207 (rewrite (= (- ?x202 |x7$|) ?x208)) (= (- (ite $x45 (- |x8$|) |x8$|) |x7$|) ?x208))))
(let ((@x215 (monotonicity @x212 (= (= |x9$| (- (ite $x45 (- |x8$|) |x8$|) |x7$|)) $x213))))
(let ((@x255 (monotonicity @x215 (monotonicity @x232 @x249 (= $x62 $x250)) (= (and (= |x9$| (- (ite $x45 (- |x8$|) |x8$|) |x7$|)) $x62) $x253))))
(let ((@x187 (monotonicity (rewrite (= (- |x7$|) ?x182)) (= (ite $x39 (- |x7$|) |x7$|) ?x185))))
(let ((@x190 (monotonicity @x187 (= (- (ite $x39 (- |x7$|) |x7$|) |x6$|) (- ?x185 |x6$|)))))
(let ((@x195 (trans @x190 (rewrite (= (- ?x185 |x6$|) ?x191)) (= (- (ite $x39 (- |x7$|) |x7$|) |x6$|) ?x191))))
(let ((@x198 (monotonicity @x195 (= (= |x8$| (- (ite $x39 (- |x7$|) |x7$|) |x6$|)) $x196))))
(let ((@x170 (monotonicity (rewrite (= (- |x6$|) ?x165)) (= (ite $x33 (- |x6$|) |x6$|) ?x168))))
(let ((@x173 (monotonicity @x170 (= (- (ite $x33 (- |x6$|) |x6$|) |x5$|) (- ?x168 |x5$|)))))
(let ((@x178 (trans @x173 (rewrite (= (- ?x168 |x5$|) ?x174)) (= (- (ite $x33 (- |x6$|) |x6$|) |x5$|) ?x174))))
(let ((@x181 (monotonicity @x178 (= (= |x7$| (- (ite $x33 (- |x6$|) |x6$|) |x5$|)) $x179))))
(let ((@x261 (monotonicity @x181 (monotonicity @x198 @x255 (= $x64 $x256)) (= (and (= |x7$| (- (ite $x33 (- |x6$|) |x6$|) |x5$|)) $x64) $x259))))
(let ((@x153 (monotonicity (rewrite (= (- |x5$|) ?x148)) (= (ite $x27 (- |x5$|) |x5$|) ?x151))))
(let ((@x156 (monotonicity @x153 (= (- (ite $x27 (- |x5$|) |x5$|) |x4$|) (- ?x151 |x4$|)))))
(let ((@x161 (trans @x156 (rewrite (= (- ?x151 |x4$|) ?x157)) (= (- (ite $x27 (- |x5$|) |x5$|) |x4$|) ?x157))))
(let ((@x164 (monotonicity @x161 (= (= |x6$| (- (ite $x27 (- |x5$|) |x5$|) |x4$|)) $x162))))
(let ((@x136 (monotonicity (rewrite (= (- |x4$|) ?x131)) (= (ite $x21 (- |x4$|) |x4$|) ?x134))))
(let ((@x139 (monotonicity @x136 (= (- (ite $x21 (- |x4$|) |x4$|) |x3$|) (- ?x134 |x3$|)))))
(let ((@x144 (trans @x139 (rewrite (= (- ?x134 |x3$|) ?x140)) (= (- (ite $x21 (- |x4$|) |x4$|) |x3$|) ?x140))))
(let ((@x147 (monotonicity @x144 (= (= |x5$| (- (ite $x21 (- |x4$|) |x4$|) |x3$|)) $x145))))
(let ((@x267 (monotonicity @x147 (monotonicity @x164 @x261 (= $x66 $x262)) (= (and (= |x5$| (- (ite $x21 (- |x4$|) |x4$|) |x3$|)) $x66) $x265))))
(let ((@x119 (monotonicity (rewrite (= (- |x3$|) ?x114)) (= (ite $x15 (- |x3$|) |x3$|) ?x117))))
(let ((@x122 (monotonicity @x119 (= (- (ite $x15 (- |x3$|) |x3$|) |x2$|) (- ?x117 |x2$|)))))
(let ((@x127 (trans @x122 (rewrite (= (- ?x117 |x2$|) ?x123)) (= (- (ite $x15 (- |x3$|) |x3$|) |x2$|) ?x123))))
(let ((@x130 (monotonicity @x127 (= (= |x4$| (- (ite $x15 (- |x3$|) |x3$|) |x2$|)) $x128))))
(let ((@x101 (monotonicity (rewrite (= (- |x2$|) ?x96)) (= (ite $x8 (- |x2$|) |x2$|) ?x99))))
(let ((@x104 (monotonicity @x101 (= (- (ite $x8 (- |x2$|) |x2$|) |x1$|) (- ?x99 |x1$|)))))
(let ((@x110 (trans @x104 (rewrite (= (- ?x99 |x1$|) ?x106)) (= (- (ite $x8 (- |x2$|) |x2$|) |x1$|) ?x106))))
(let ((@x113 (monotonicity @x110 (= (= |x3$| (- (ite $x8 (- |x2$|) |x2$|) |x1$|)) $x111))))
(let ((@x273 (monotonicity @x113 (monotonicity @x130 @x267 (= $x68 $x268)) (= (and (= |x3$| (- (ite $x8 (- |x2$|) |x2$|) |x1$|)) $x68) $x271))))
(let ((@x282 (trans (monotonicity @x273 (= $x73 (=> $x271 $x72))) (rewrite (= (=> $x271 $x72) $x278)) (= $x73 $x278))))
(let ((@x550 (trans (monotonicity @x282 (= $x74 (not $x278))) (monotonicity @x545 (= (not $x278) $x546)) (= $x74 $x546))))
(let ((@x552 (|not-or-elim| (mp (asserted $x74) @x550 $x546) $x535)))
(let ((@x557 (|and-elim| @x552 $x406)))
(let ((@x851 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x406) $x617)) @x557 $x617)))
(let ((@x948 ((_ |th-lemma| arith triangle-eq) (or (not $x610) $x934))))
(let ((@x1027 (|unit-resolution| @x948 (|unit-resolution| (|def-axiom| (or $x387 $x610)) @x1024 $x610) $x934)))
(let ((@x1030 (lemma ((_ |th-lemma| arith farkas 1 1 1 1 1) @x1027 @x851 @x1025 @x842 @x1024 false) (or $x361 $x411 $x387))))
(let ((@x615 (|def-axiom| (or $x386 $x611))))
(let ((@x1061 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x611) $x778)) (|unit-resolution| @x615 (|unit-resolution| @x1030 @x1025 @x842 $x387) $x611) $x778)))
(let ((@x1062 ((_ |th-lemma| arith farkas 1 1 1 1 1) (|unit-resolution| @x1030 @x1025 @x842 $x387) @x1025 @x851 @x842 @x1061 false)))
(let ((@x1064 (lemma @x1062 (or $x361 $x411))))
(let ((@x621 (|def-axiom| (or $x362 $x618))))
(let ((@x863 ((_ |th-lemma| arith triangle-eq) (or (not $x618) $x838))))
(let ((@x1087 (|unit-resolution| @x863 (|unit-resolution| @x621 (|unit-resolution| @x1064 @x842 $x361) $x618) $x838)))
(let ((?x663 (+ |x8$| ?x354)))
(let (($x661 (<= ?x663 0)))
(let (($x626 (= |x8$| ?x343)))
(let (($x665 (>= ?x663 0)))
(let ((@x1538 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x661 $x665)) (hypothesis (not $x661)) $x665)))
(let (($x627 (= ?x199 ?x343)))
(let (($x337 (not $x336)))
(let ((@x1527 (hypothesis $x337)))
(let ((@x631 (|def-axiom| (or $x336 $x627))))
(let ((@x1528 (|unit-resolution| @x631 @x1527 $x627)))
(let ((?x664 (+ ?x199 ?x354)))
(let (($x873 (<= ?x664 0)))
(let (($x1510 (not $x873)))
(let ((@x856 (hypothesis $x665)))
(let ((@x1516 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x627) $x873)) (hypothesis $x627) (hypothesis $x1510) false)))
(let ((@x1517 (lemma @x1516 (or (not $x627) $x873))))
(let ((@x1532 (|unit-resolution| @x1517 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1) (or (not $x665) $x336 $x1510)) @x1527 @x856 $x1510) @x1528 false)))
(let ((@x629 (|def-axiom| (or $x337 $x626))))
(let ((@x1540 (|unit-resolution| @x629 (|unit-resolution| (lemma @x1532 (or $x336 (not $x665))) @x1538 $x336) $x626)))
(let ((@x1127 ((_ |th-lemma| arith triangle-eq) (or (not $x626) $x661))))
(let ((@x1542 (lemma (|unit-resolution| @x1127 @x1540 (hypothesis (not $x661)) false) $x661)))
(let ((@x1206 (hypothesis $x838)))
(let ((@x1211 (hypothesis $x661)))
(let ((@x843 (hypothesis $x387)))
(let (($x625 (>= ?x380 0)))
(let ((@x558 (|and-elim| @x552 $x381)))
(let ((@x833 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x381) $x625)) @x558 $x625)))
(let (($x633 (>= ?x355 0)))
(let ((@x559 (|and-elim| @x552 $x356)))
(let ((@x1125 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x356) $x633)) @x559 $x633)))
(let ((@x1429 (lemma ((_ |th-lemma| arith farkas 1 1 1 1 1 1) @x1125 @x1426 @x833 @x843 @x1211 @x1206 false) (or $x286 $x386 (not $x661) (not $x838)))))
(let ((@x1915 (|unit-resolution| (|unit-resolution| @x1429 @x1542 (or $x286 $x386 (not $x838))) @x1087 @x1426 $x386)))
(let ((@x613 (|def-axiom| (or $x387 $x610))))
(let ((@x1917 (|unit-resolution| @x948 (|unit-resolution| @x613 @x1915 $x610) $x934)))
(let ((?x678 (+ |x3$| ?x479)))
(let (($x670 (>= ?x678 0)))
(let (($x586 (= |x3$| ?x468)))
(let ((?x929 (+ ?x148 ?x429)))
(let (($x1022 (>= ?x929 0)))
(let (($x603 (= ?x148 ?x418)))
(let ((@x607 (|def-axiom| (or $x411 $x603))))
(let ((@x994 (|unit-resolution| @x607 @x842 $x603)))
(let ((@x1037 ((_ |th-lemma| arith triangle-eq) (or (not $x603) $x1022))))
(let ((@x1038 (|unit-resolution| @x1037 @x994 $x1022)))
(let (($x462 (not $x461)))
(let ((@x686 (hypothesis $x462)))
(let (($x601 (>= ?x455 0)))
(let ((@x555 (|and-elim| @x552 $x456)))
(let ((@x685 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x456) $x601)) @x555 $x601)))
(let (($x608 (<= ?x430 0)))
(let ((@x556 (|and-elim| @x552 $x431)))
(let ((@x810 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x431) $x608)) @x556 $x608)))
(let ((?x755 (+ |x5$| ?x429)))
(let (($x773 (<= ?x755 0)))
(let (($x931 (<= ?x929 0)))
(let ((@x997 ((_ |th-lemma| arith triangle-eq) (or (not $x603) $x931))))
(let ((@x998 (|unit-resolution| @x997 @x994 $x931)))
(let ((@x1067 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x773 (not $x931) $x411)) @x998 @x842 $x773)))
(let (($x609 (>= ?x430 0)))
(let ((@x797 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x431) $x609)) @x556 $x609)))
(let ((@x801 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x386 (not $x773) (not $x601) $x461 $x782 (not $x609)))))
(let (($x594 (= |x4$| ?x443)))
(let ((@x1070 ((_ |th-lemma| arith assign-bounds 1 1 1 1) (or $x436 (not $x931) $x411 (not $x609) $x386))))
(let ((@x597 (|def-axiom| (or (not $x436) $x594))))
(let ((@x1072 (|unit-resolution| @x597 (|unit-resolution| @x1070 @x843 @x797 @x842 @x998 $x436) $x594)))
(let ((@x691 ((_ |th-lemma| arith triangle-eq) (or (not $x594) $x676))))
(let ((@x1073 (|unit-resolution| @x691 @x1072 (|unit-resolution| @x801 @x843 @x797 @x1067 @x686 @x685 $x782) false)))
(let ((@x1081 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 1 -1 1 -1) (or $x743 (not $x601) $x461 (not $x1022) (not $x608) $x387)) (|unit-resolution| (lemma @x1073 (or $x386 $x461 $x411)) @x686 @x842 $x386) @x810 @x685 @x686 @x1038 $x743)))
(let (($x595 (= ?x131 ?x443)))
(let (($x437 (not $x436)))
(let ((@x1082 (|unit-resolution| @x613 (|unit-resolution| (lemma @x1073 (or $x386 $x461 $x411)) @x686 @x842 $x386) $x610)))
(let ((@x806 ((_ |th-lemma| arith triangle-eq) (or (not $x610) $x671))))
(let (($x668 (>= ?x666 0)))
(let ((@x924 ((_ |th-lemma| arith triangle-eq) (or (not $x618) $x668))))
(let ((@x1086 (|unit-resolution| @x924 (|unit-resolution| @x621 (|unit-resolution| @x1064 @x842 $x361) $x618) $x668)))
(let ((@x1092 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x336 (not $x625) (not $x838) (not $x934) (not $x617) $x411))))
(let ((@x1093 (|unit-resolution| @x1092 (|unit-resolution| @x948 @x1082 $x934) @x833 @x842 @x851 @x1087 $x336)))
(let ((@x681 (hypothesis $x668)))
(let ((@x692 (|unit-resolution| @x691 (|unit-resolution| @x597 (hypothesis $x436) $x594) $x676)))
(let ((@x687 (hypothesis $x436)))
(let (($x616 (<= ?x405 0)))
(let ((@x696 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x406) $x616)) @x557 $x616)))
(let ((@x697 (hypothesis $x671)))
(let (($x624 (<= ?x380 0)))
(let ((@x701 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x381) $x624)) @x558 $x624)))
(let ((@x702 (hypothesis $x336)))
(let ((@x707 (lemma ((_ |th-lemma| arith farkas 1 -1 1 -1 1 -1 -1 1 1) @x702 @x701 @x697 @x696 @x687 @x692 @x686 @x685 @x681 false) (or $x461 $x337 (not $x671) $x437 (not $x668)))))
(let ((@x1094 (|unit-resolution| @x707 @x1093 @x1086 @x686 (|unit-resolution| @x806 @x1082 $x671) $x437)))
(let ((@x599 (|def-axiom| (or $x436 $x595))))
(let ((@x738 ((_ |th-lemma| arith triangle-eq) (or (not $x595) $x673))))
(let ((@x1098 (lemma (|unit-resolution| @x738 (|unit-resolution| @x599 @x1094 $x595) @x1081 false) (or $x461 $x411))))
(let ((@x589 (|def-axiom| (or $x462 $x586))))
(let ((@x1268 ((_ |th-lemma| arith triangle-eq) (or (not $x586) $x670))))
(let ((@x1269 (|unit-resolution| @x1268 (|unit-resolution| @x589 (|unit-resolution| @x1098 @x842 $x461) $x586) $x670)))
(let (($x667 (>= ?x675 0)))
(let (($x1499 (<= ?x1498 0)))
(let ((@x1556 ((_ |th-lemma| arith triangle-eq) (or (not $x635) $x1499))))
(let ((@x1557 (|unit-resolution| @x1556 @x1553 $x1499)))
(let (($x930 (>= ?x672 0)))
(let ((@x964 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x595) $x930)) (|unit-resolution| @x599 (hypothesis $x437) $x595) $x930)))
(let ((@x939 (|unit-resolution| @x738 (|unit-resolution| @x599 (hypothesis $x437) $x595) $x673)))
(let ((@x1185 (hypothesis $x411)))
(let (($x1090 (not $x838)))
(let (($x837 (>= ?x775 0)))
(let ((@x890 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x611) $x837)) (hypothesis $x611) (hypothesis (not $x837)) false)))
(let ((@x891 (lemma @x890 (or (not $x611) $x837))))
(let ((@x1133 (|unit-resolution| @x891 (|unit-resolution| @x615 @x843 $x611) $x837)))
(let ((?x776 (+ ?x182 ?x379)))
(let (($x777 (<= ?x776 0)))
(let (($x900 (not $x777)))
(let ((@x904 (hypothesis $x900)))
(let (($x619 (= ?x182 ?x368)))
(let (($x821 (not $x619)))
(let ((@x823 ((_ |th-lemma| arith triangle-eq) (or $x821 $x777))))
(let ((@x907 (lemma (|unit-resolution| @x823 (hypothesis $x619) @x904 false) (or $x821 $x777))))
(let ((@x623 (|def-axiom| (or $x361 $x619))))
(let ((@x1363 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x777 $x362 $x1090)) (|unit-resolution| @x623 (|unit-resolution| @x907 @x904 $x821) $x361) @x904 $x1090)))
(let ((@x1364 (|unit-resolution| @x621 (|unit-resolution| @x623 (|unit-resolution| @x907 @x904 $x821) $x361) $x618)))
(let ((@x1366 (lemma (|unit-resolution| @x863 @x1364 @x1363 false) $x777)))
(let ((@x1447 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 1 -1 1 -1) (or $x900 (not $x625) $x336 (not $x837) (not $x616) $x412)) @x833 @x1366 @x696 (or $x336 (not $x837) $x412))))
(let ((@x1476 (|unit-resolution| @x1127 (|unit-resolution| @x629 (|unit-resolution| @x1447 @x1133 @x1185 $x336) $x626) $x661)))
(let ((?x1358 (+ ?x96 ?x504)))
(let (($x1367 (<= ?x1358 0)))
(let (($x579 (= ?x96 ?x493)))
(let (($x487 (not $x486)))
(let (($x602 (= |x5$| ?x418)))
(let ((@x605 (|def-axiom| (or $x412 $x602))))
(let ((@x792 ((_ |th-lemma| arith triangle-eq) (or (not $x602) $x773))))
(let ((@x1187 (|unit-resolution| @x792 (|unit-resolution| @x605 @x1185 $x602) $x773)))
(let ((@x761 (hypothesis $x437)))
(let ((@x1357 (lemma ((_ |th-lemma| arith farkas 1 1 1 1 1) @x1185 @x797 @x761 @x843 @x1187 false) (or $x436 $x412 $x386))))
(let ((@x826 ((_ |th-lemma| arith triangle-eq) (or (not $x594) $x667))))
(let ((@x1468 (|unit-resolution| @x826 (|unit-resolution| @x597 (|unit-resolution| @x1357 @x843 @x1185 $x436) $x594) $x667)))
(let ((@x1115 ((_ |th-lemma| arith triangle-eq) (or (not $x626) $x665))))
(let ((@x1471 (|unit-resolution| @x1115 (|unit-resolution| @x629 (|unit-resolution| @x1447 @x1133 @x1185 $x336) $x626) $x665)))
(let ((@x1472 (|unit-resolution| @x691 (|unit-resolution| @x597 (|unit-resolution| @x1357 @x843 @x1185 $x436) $x594) $x676)))
(let ((@x1473 (|unit-resolution| (|unit-resolution| @x801 @x797 @x685 (or $x386 (not $x773) $x461 $x782)) @x1472 @x1187 @x843 $x461)))
(let ((@x1475 (|unit-resolution| @x1268 (|unit-resolution| @x589 @x1473 $x586) $x670)))
(let ((@x848 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x611) $x778)) (|unit-resolution| @x615 @x843 $x611) $x778)))
(let ((?x657 (+ |x9$| ?x304)))
(let (($x659 (>= ?x657 0)))
(let (($x634 (= |x9$| ?x293)))
(let (($x774 (>= ?x755 0)))
(let ((@x789 ((_ |th-lemma| arith triangle-eq) (or (not $x602) $x774))))
(let ((@x1477 (|unit-resolution| @x789 (|unit-resolution| @x605 @x1185 $x602) $x774)))
(let (($x858 (not $x665)))
(let (($x901 (not $x667)))
(let (($x815 (not $x774)))
(let (($x1196 (not $x661)))
(let (($x798 (not $x773)))
(let (($x564 (not $x70)))
(let (($x658 (<= ?x657 0)))
(let ((@x1379 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1 1 1 1 1) (or $x286 $x361 (not $x633) $x900 (not $x625) $x386 $x1196)) @x1025 @x833 @x1125 @x843 @x1366 @x1211 $x286)))
(let ((@x637 (|def-axiom| (or $x287 $x634))))
(let ((@x1149 ((_ |th-lemma| arith triangle-eq) (or (not $x634) $x658))))
(let (($x1354 (>= ?x776 0)))
(let ((@x1385 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x821 $x1354)) (|unit-resolution| @x623 @x1025 $x619) $x1354)))
(let ((@x1207 (hypothesis $x773)))
(let ((@x866 (hypothesis $x676)))
(let ((@x1388 (|unit-resolution| (|unit-resolution| @x801 @x797 @x685 (or $x386 $x798 $x461 $x782)) @x866 @x1207 @x843 $x461)))
(let ((@x1390 (|unit-resolution| @x1268 (|unit-resolution| @x589 @x1388 $x586) $x670)))
(let ((@x898 (hypothesis $x667)))
(let (($x641 (>= ?x305 0)))
(let ((@x560 (|and-elim| @x552 $x306)))
(let ((@x1136 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x306) $x641)) @x560 $x641)))
(let ((@x1199 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x361 $x311 $x1196 (not $x633) (not $x658) (not $x641)))))
(let ((@x1393 (|unit-resolution| (|unit-resolution| @x1199 @x1136 @x1125 (or $x361 $x311 $x1196 (not $x658))) (|unit-resolution| @x1149 (|unit-resolution| @x637 @x1379 $x634) $x658) @x1211 @x1025 $x311)))
(let ((@x645 (|def-axiom| (or (not $x311) $x642))))
(let ((@x1396 ((_ |th-lemma| arith triangle-eq) (or (not $x642) $x1369))))
(let (($x1139 (not $x658)))
(let (($x1374 (not $x1354)))
(let (($x1260 (not $x670)))
(let (($x1104 (not $x778)))
(let (($x1373 (not $x1369)))
(let ((@x1137 (hypothesis $x658)))
(let ((@x1370 (hypothesis $x1354)))
(let (($x592 (<= ?x480 0)))
(let ((@x554 (|and-elim| @x552 $x481)))
(let ((@x1252 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x481) $x592)) @x554 $x592)))
(let (($x600 (<= ?x455 0)))
(let ((@x830 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x456) $x600)) @x555 $x600)))
(let ((@x1249 (hypothesis $x670)))
(let ((@x1248 (hypothesis $x778)))
(let (($x764 (not $x655)))
(let ((@x1253 (hypothesis $x764)))
(let (($x649 (>= ?x330 0)))
(let ((@x561 (|and-elim| @x552 $x331)))
(let ((@x1256 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x331) $x649)) @x561 $x649)))
(let ((@x1371 (hypothesis $x1369)))
(let ((@x1372 ((_ |th-lemma| arith farkas -1 1 -1 -1 1 -1 -1 -1 1 1 -1 1 1) @x1136 @x1371 @x1256 @x1253 @x1248 @x851 @x898 @x1249 @x830 @x1252 @x1370 @x701 @x1137 false)))
(let ((@x1376 (lemma @x1372 (or $x655 $x1373 $x1104 $x901 $x1260 $x1374 $x1139))))
(let ((@x1398 (|unit-resolution| @x1376 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x1393 $x642) $x1369) @x848 @x898 @x1390 @x1385 (|unit-resolution| @x1149 (|unit-resolution| @x637 @x1379 $x634) $x658) $x655)))
(let ((@x1277 ((_ |th-lemma| arith triangle-eq) (or $x71 $x764 $x708))))
(let (($x565 (not $x71)))
(let (($x566 (or $x564 $x565)))
(let ((@x572 (monotonicity (rewrite (= $x72 (not $x566))) (= (not $x72) (not (not $x566))))))
(let ((@x576 (trans @x572 (rewrite (= (not (not $x566)) $x566)) (= (not $x72) $x566))))
(let ((@x577 (mp (|not-or-elim| (mp (asserted $x74) @x550 $x546) (not $x72)) @x576 $x566)))
(let ((?x650 (+ |x1$| ?x233)))
(let (($x652 (>= ?x650 0)))
(let (($x632 (<= ?x355 0)))
(let ((@x855 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x356) $x632)) @x559 $x632)))
(let ((@x897 (hypothesis $x774)))
(let (($x585 (>= ?x505 0)))
(let ((@x553 (|and-elim| @x552 $x506)))
(let ((@x1284 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x506) $x585)) @x553 $x585)))
(let ((@x1404 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1 1 1) (or $x487 $x1260 (not $x592) (not $x600) $x901 $x361 (not $x617) $x386 $x1104))))
(let ((@x1406 (|unit-resolution| @x1404 @x830 @x851 @x1252 (or $x487 $x1260 $x901 $x361 $x386 $x1104))))
(let ((@x583 (|def-axiom| (or $x486 $x579))))
(let ((@x1408 (|unit-resolution| @x583 (|unit-resolution| @x1406 @x1025 @x843 @x848 @x898 @x1390 $x487) $x579)))
(let ((@x1411 ((_ |th-lemma| arith triangle-eq) (or (not $x579) $x1367))))
(let ((@x1413 ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 -3 3 2 -2 -2 2 1 -1 -1 1 -1 1 -1) (|unit-resolution| @x1411 @x1408 $x1367) @x1284 @x897 @x810 @x898 @x830 @x848 @x851 @x1390 @x1252 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x1393 $x642) $x1369) @x1256 @x1263 @x855 @x1385 @x701 @x856 $x652)))
(let (($x651 (<= ?x650 0)))
(let (($x648 (<= ?x330 0)))
(let ((@x713 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x331) $x648)) @x561 $x648)))
(let (($x662 (>= ?x660 0)))
(let ((@x1165 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x642) $x662)) (hypothesis $x642) (hypothesis (not $x662)) false)))
(let ((@x1166 (lemma @x1165 (or (not $x642) $x662))))
(let (($x593 (>= ?x480 0)))
(let ((@x718 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x481) $x593)) @x554 $x593)))
(let (($x679 (<= ?x678 0)))
(let ((@x723 ((_ |th-lemma| arith triangle-eq) (or (not $x586) $x679))))
(let (($x584 (<= ?x505 0)))
(let ((@x1296 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x506) $x584)) @x553 $x584)))
(let (($x1368 (>= ?x1358 0)))
(let ((@x1419 ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 -3 3 2 -2 -2 2 1 -1 -1 1 -1 1 -1) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x579) $x1368)) @x1408 $x1368) @x1296 @x1207 @x797 @x866 @x685 @x1133 @x696 (|unit-resolution| @x723 (|unit-resolution| @x589 @x1388 $x586) $x679) @x718 (|unit-resolution| @x1166 (|unit-resolution| @x645 @x1393 $x642) $x662) @x713 @x1398 @x1125 @x1366 @x833 @x1211 $x651)))
(let ((@x1304 ((_ |th-lemma| arith triangle-eq) (or $x70 (not $x651) (not $x652)))))
(let ((@x1420 (|unit-resolution| @x1304 @x1419 @x1413 (|unit-resolution| @x577 (|unit-resolution| @x1277 @x1398 @x1263 $x71) $x564) false)))
(let ((@x1478 (|unit-resolution| (lemma @x1420 (or $x361 $x798 $x782 $x1196 $x815 $x901 $x708 $x858 $x386)) @x1263 @x1472 @x1476 @x1477 @x1468 @x1187 @x1471 @x843 $x361)))
(let ((@x1481 (|unit-resolution| @x1429 (|unit-resolution| @x863 (|unit-resolution| @x621 @x1478 $x618) $x838) @x1476 @x843 $x286)))
(let ((@x1144 ((_ |th-lemma| arith triangle-eq) (or (not $x634) $x659))))
(let ((@x1483 (|unit-resolution| @x1144 (|unit-resolution| @x637 @x1481 $x634) $x659)))
(let (($x1302 (not $x652)))
(let ((@x729 (hypothesis $x659)))
(let (($x640 (<= ?x305 0)))
(let ((@x728 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x306) $x640)) @x560 $x640)))
(let ((@x1258 ((_ |th-lemma| arith farkas 1/2 -1 -1/2 -1/2 1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 1) @x681 @x855 @x701 (hypothesis $x1247) @x1256 @x1253 @x1252 @x1249 @x830 @x729 @x728 @x898 @x1248 @x851 @x856 false)))
(let ((@x1262 (lemma @x1258 (or $x655 (not $x668) $x1259 $x1260 (not $x659) $x901 $x1104 $x858))))
(let ((@x1309 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1119 $x1247)) (hypothesis $x643) (hypothesis $x1259) false)))
(let ((@x1310 (lemma @x1309 (or $x1119 $x1247))))
(let ((@x1424 (|unit-resolution| @x1310 (|unit-resolution| @x1262 @x1253 @x856 @x1249 @x681 @x898 @x1248 @x729 $x1259) $x1119)))
(let ((@x647 (|def-axiom| (or $x311 $x643))))
(let ((@x1431 (|unit-resolution| @x1396 (|unit-resolution| @x645 (|unit-resolution| @x647 @x1424 $x311) $x642) $x1369)))
(let ((@x1432 ((_ |th-lemma| arith farkas -2 -1 2 1 -1 2 -1 1 1 -1 1 1 1 -1 -1 1) @x855 @x701 @x856 @x729 @x728 (|unit-resolution| @x647 @x1424 $x311) @x1431 @x1256 @x1253 @x1248 @x851 @x898 @x1249 @x830 @x1252 @x681 false)))
(let ((@x1485 (|unit-resolution| (lemma @x1432 (or $x655 $x858 (not $x659) $x1104 $x901 $x1260 (not $x668))) @x1483 @x1471 @x848 @x1468 @x1475 (|unit-resolution| @x924 (|unit-resolution| @x621 @x1478 $x618) $x668) $x655)))
(let ((@x1449 (|unit-resolution| @x629 (|unit-resolution| @x1447 (hypothesis $x837) @x1185 $x336) $x626)))
(let ((@x865 (hypothesis $x837)))
(let (($x1301 (not $x651)))
(let ((@x1318 (hypothesis $x1301)))
(let ((?x1142 (+ |x2$| ?x504)))
(let (($x1237 (>= ?x1142 0)))
(let (($x578 (= |x2$| ?x493)))
(let (($x1409 (not $x579)))
(let (($x1437 (not $x1368)))
(let ((@x867 (hypothesis $x679)))
(let ((@x1436 ((_ |th-lemma| arith farkas -1 1 1 -1 -2 -1 2 1 1 -1 -1 1 -1 1 1) @x1137 @x1136 @x865 @x696 @x866 @x867 @x685 @x718 @x1125 @x1211 @x1296 @x1318 @x1207 @x797 (hypothesis $x1368) false)))
(let ((@x1439 (lemma @x1436 (or $x1437 $x1139 (not $x837) $x782 (not $x679) $x1196 $x651 $x798))))
(let ((@x1451 (|unit-resolution| @x1439 @x1318 @x865 @x866 @x867 (|unit-resolution| @x1127 @x1449 $x661) @x1137 @x1187 $x1437)))
(let ((@x1441 (hypothesis $x579)))
(let ((@x1442 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1409 $x1368)) @x1441 (hypothesis $x1437) false)))
(let ((@x1443 (lemma @x1442 (or $x1409 $x1368))))
(let ((@x581 (|def-axiom| (or $x487 $x578))))
(let ((@x1454 (|unit-resolution| @x581 (|unit-resolution| @x583 (|unit-resolution| @x1443 @x1451 $x1409) $x486) $x578)))
(let ((@x1298 ((_ |th-lemma| arith triangle-eq) (or (not $x578) $x1237))))
(let ((@x1456 ((_ |th-lemma| arith farkas 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 1/2 -1/2 1/2 -1/2 1) @x1249 @x1252 (|unit-resolution| @x1298 @x1454 $x1237) @x1296 @x1318 @x1187 @x797 @x1137 @x1136 @x865 @x696 @x1125 (|unit-resolution| @x1127 @x1449 $x661) @x1185 false)))
(let ((@x1490 (|unit-resolution| (lemma @x1456 (or $x651 $x1260 $x1139 (not $x837) $x412 $x782 (not $x679))) (|unit-resolution| @x1149 (|unit-resolution| @x637 @x1481 $x634) $x658) @x1475 @x1133 @x1185 @x1472 (|unit-resolution| @x723 (|unit-resolution| @x589 @x1473 $x586) $x679) $x651)))
(let ((@x1491 (|unit-resolution| @x1304 @x1490 (|unit-resolution| @x577 (|unit-resolution| @x1277 @x1485 @x1263 $x71) $x564) $x1302)))
(let (($x1236 (<= ?x1142 0)))
(let ((@x1291 ((_ |th-lemma| arith triangle-eq) (or (not $x578) $x1236))))
(let ((@x1461 (|unit-resolution| @x1291 (|unit-resolution| @x581 (hypothesis $x486) $x578) $x1236)))
(let ((@x1463 ((_ |th-lemma| arith farkas -1 1 -1 1 -1 1 1 -1 -1 1 1 -1 -2 -2 2 1) @x1284 (hypothesis $x1302) @x897 @x810 @x729 @x728 @x1248 @x851 @x1249 @x1252 @x855 @x856 (hypothesis $x486) @x898 @x830 @x1461 false)))
(let ((@x1465 (lemma @x1463 (or $x487 $x652 $x815 (not $x659) $x1104 $x1260 $x858 $x901))))
(let ((@x1493 (|unit-resolution| @x583 (|unit-resolution| @x1465 @x1491 @x1477 @x1483 @x848 @x1475 @x1471 @x1468 $x487) $x579)))
(let ((@x1495 ((_ |th-lemma| arith farkas -1 1 -1 1 -1 1 1 -1 -1 1 1 -1 -2 2 1) @x1284 @x1491 @x1477 @x810 @x1483 @x728 @x848 @x851 @x1475 @x1252 @x855 @x1471 @x1468 @x830 (|unit-resolution| @x1411 @x1493 $x1367) false)))
(let (($x704 (not $x671)))
(let ((@x1150 (|unit-resolution| @x1149 (|unit-resolution| @x637 (hypothesis $x286) $x634) $x658)))
(let ((@x1076 (hypothesis $x286)))
(let (($x312 (not $x311)))
(let (($x1162 (not $x642)))
(let (($x732 (not $x662)))
(let ((@x1145 (|unit-resolution| @x1144 (|unit-resolution| @x637 @x1076 $x634) $x659)))
(let ((@x709 (hypothesis $x708)))
(let ((@x714 (hypothesis $x662)))
(let (($x845 (not $x611)))
(let (($x870 (not $x837)))
(let ((?x674 (+ ?x114 ?x479)))
(let (($x677 (<= ?x674 0)))
(let (($x587 (= ?x114 ?x468)))
(let ((@x591 (|def-axiom| (or $x461 $x587))))
(let ((@x760 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x587) $x677)) (|unit-resolution| @x591 @x686 $x587) $x677)))
(let ((@x942 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1) (or $x676 $x436 $x743)) @x939 @x761 $x676)))
(let ((@x864 (|unit-resolution| @x863 (|unit-resolution| @x621 (hypothesis $x361) $x618) $x838)))
(let ((@x839 (hypothesis $x361)))
(let ((@x868 ((_ |th-lemma| arith farkas -1 1 -1 1 -1 -1 1 1 -1 1 1 -1 -2 1) @x833 @x867 @x729 @x728 @x718 @x714 @x713 @x709 @x685 @x866 @x696 @x865 @x839 @x864 false)))
(let ((@x877 (|unit-resolution| (lemma @x868 (or $x362 (not $x679) (not $x659) $x732 $x656 $x782 $x870)) @x865 @x729 @x714 @x709 @x866 @x867 $x362)))
(let ((@x880 ((_ |th-lemma| arith farkas -1 1 -1 1 -1 -1 1 1 -1 1 1 -1 1) @x833 @x867 @x729 @x728 @x718 @x714 @x713 @x709 @x685 @x866 @x696 @x865 (|unit-resolution| @x823 (|unit-resolution| @x623 @x877 $x619) $x777) false)))
(let ((@x882 (lemma @x880 (or $x870 (not $x679) (not $x659) $x732 $x656 $x782))))
(let ((@x943 (|unit-resolution| @x882 @x942 @x729 @x714 @x709 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x679 (not $x677) $x461)) @x760 @x686 $x679) $x870)))
(let ((@x946 (|unit-resolution| @x613 (|unit-resolution| @x615 (|unit-resolution| @x891 @x943 $x845) $x386) $x610)))
(let ((@x952 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1) (or $x411 $x743 (not $x601) $x461 $x436)) @x761 @x685 @x686 @x939 $x411)))
(let ((@x958 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x361 (not $x934) (not $x617) $x436 $x798 (not $x609)))))
(let ((@x959 (|unit-resolution| @x958 @x761 @x851 @x797 (|unit-resolution| @x792 (|unit-resolution| @x605 @x952 $x602) $x773) (|unit-resolution| @x948 @x946 $x934) $x361)))
(let ((@x965 ((_ |th-lemma| arith farkas -1 -1 1 1 -1 -1 1 1 1 -1 -1 1 1) @x833 @x729 @x728 @x760 @x718 @x714 @x713 @x709 (|unit-resolution| @x948 @x946 $x934) @x851 @x964 @x830 (|unit-resolution| @x863 (|unit-resolution| @x621 @x959 $x618) $x838) false)))
(let ((@x972 (|unit-resolution| (lemma @x965 (or $x436 (not $x659) $x732 $x656 $x461)) @x686 @x714 @x709 @x729 $x436)))
(let ((@x976 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1) (or $x411 (not $x601) $x461 $x437 $x782)) (|unit-resolution| @x691 (|unit-resolution| @x597 @x972 $x594) $x676) @x685 @x686 @x972 $x411)))
(let ((@x979 (|unit-resolution| @x882 (|unit-resolution| @x691 (|unit-resolution| @x597 @x972 $x594) $x676) @x729 @x714 @x709 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x679 (not $x677) $x461)) @x760 @x686 $x679) $x870)))
(let ((@x982 (|unit-resolution| @x613 (|unit-resolution| @x615 (|unit-resolution| @x891 @x979 $x845) $x386) $x610)))
(let ((@x933 ((_ |th-lemma| arith farkas -1 -1 1 1 -1 -1 1 1 -1 1 -2 2 -1 1 1) @x833 @x729 @x728 (hypothesis $x677) @x718 @x714 @x713 @x709 @x697 @x696 @x897 @x810 @x898 @x830 (hypothesis $x777) false)))
(let ((@x969 (lemma @x933 (or $x900 (not $x659) (not $x677) $x732 $x656 $x704 $x815 $x901))))
(let ((@x984 (|unit-resolution| @x969 @x760 @x729 @x714 @x709 (|unit-resolution| @x806 @x982 $x671) (|unit-resolution| @x789 (|unit-resolution| @x605 @x976 $x602) $x774) (|unit-resolution| @x826 (|unit-resolution| @x597 @x972 $x594) $x667) $x900)))
(let ((@x987 (|unit-resolution| @x621 (|unit-resolution| @x623 (|unit-resolution| @x907 @x984 $x821) $x361) $x618)))
(let ((@x989 ((_ |th-lemma| arith farkas -1 -1 1 1 -1 -1 1 1 -1 1 -2 2 -2 -1 1 1) @x833 @x729 @x728 @x760 @x718 @x714 @x713 @x709 (|unit-resolution| @x806 @x982 $x671) @x696 (|unit-resolution| @x789 (|unit-resolution| @x605 @x976 $x602) $x774) @x810 (|unit-resolution| @x623 (|unit-resolution| @x907 @x984 $x821) $x361) (|unit-resolution| @x826 (|unit-resolution| @x597 @x972 $x594) $x667) @x830 (|unit-resolution| @x863 @x987 $x838) false)))
(let ((@x970 (|unit-resolution| (lemma @x989 (or $x461 (not $x659) $x732 $x656)) @x714 @x729 @x709 $x461)))
(let ((@x992 (|unit-resolution| @x723 (|unit-resolution| @x589 @x970 $x586) $x679)))
(let ((@x1009 (|unit-resolution| @x891 (|unit-resolution| @x882 @x942 @x729 @x714 @x709 @x992 $x870) $x845)))
(let ((@x1012 (|unit-resolution| @x948 (|unit-resolution| @x613 (|unit-resolution| @x615 @x1009 $x386) $x610) $x934)))
(let ((@x751 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x656 $x655)) @x709 $x655)))
(let ((@x999 (hypothesis $x934)))
(let ((@x1002 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 2) (or $x361 (not $x934) (not $x617) $x436 (not $x609) (not $x931) $x411))))
(let ((@x1004 (|unit-resolution| @x621 (|unit-resolution| @x1002 @x842 @x797 @x851 @x761 @x999 @x998 $x361) $x618)))
(let ((@x762 (hypothesis $x655)))
(let ((@x1006 ((_ |th-lemma| arith farkas 1 1 1 2 1 1 1 1 1 1 1 1 1 2 1) @x833 @x999 @x851 @x842 @x729 @x728 @x718 @x714 @x713 @x762 @x685 @x939 @x867 @x761 (|unit-resolution| @x863 @x1004 $x838) false)))
(let ((@x1008 (lemma @x1006 (or $x411 (not $x934) (not $x659) $x732 $x764 (not $x679) $x436))))
(let ((@x1014 (|unit-resolution| @x605 (|unit-resolution| @x1008 @x1012 @x729 @x714 @x751 @x992 @x761 $x411) $x602)))
(let ((@x1016 (|unit-resolution| @x958 (|unit-resolution| @x792 @x1014 $x773) @x851 @x761 @x1012 @x797 $x361)))
(let ((@x1019 ((_ |th-lemma| arith farkas -1/2 1/2 -1/2 1/2 -1/2 1/2 1/2 -1/2 1/2 1/2 -1/2 -1/2 -1/2 1) @x830 @x964 (|unit-resolution| @x863 (|unit-resolution| @x621 @x1016 $x618) $x838) @x833 @x1012 @x851 @x729 @x728 @x718 @x714 @x713 @x709 @x992 @x970 false)))
(let ((@x1023 (|unit-resolution| (lemma @x1019 (or $x436 (not $x659) $x732 $x656)) @x714 @x729 @x709 $x436)))
(let ((@x1033 (|unit-resolution| @x882 (|unit-resolution| @x691 (|unit-resolution| @x597 @x1023 $x594) $x676) @x729 @x714 @x709 @x992 $x870)))
(let ((@x1035 (|unit-resolution| @x615 (|unit-resolution| @x891 @x1033 $x845) $x386)))
(let ((@x1041 (|unit-resolution| @x863 (|unit-resolution| @x621 (|unit-resolution| @x1030 @x842 @x1035 $x361) $x618) $x838)))
(let ((@x1044 ((_ |th-lemma| arith farkas -1 1 -1 1 1 -1 1 1 -1 -1 -1 1 -1 1 1) (|unit-resolution| @x948 (|unit-resolution| @x613 @x1035 $x610) $x934) @x851 @x1041 @x833 @x729 @x728 @x718 @x714 @x713 @x709 @x992 @x1038 @x810 @x970 @x1035 false)))
(let ((@x1049 (|unit-resolution| (lemma @x1044 (or $x411 (not $x659) $x732 $x656)) @x714 @x729 @x709 $x411)))
(let ((@x895 (|unit-resolution| @x723 (|unit-resolution| @x589 (hypothesis $x461) $x586) $x679)))
(let ((@x899 ((_ |th-lemma| arith farkas -1/2 1/2 1 -1 -1/2 1/2 -1/2 1/2 -1/2 1/2 1/2 -1/2 -1/2 -1/2 1/2 1) @x830 @x898 @x897 @x810 (hypothesis $x777) @x833 @x895 @x729 @x728 @x718 @x714 @x713 @x709 @x696 @x697 (hypothesis $x461) false)))
(let ((@x903 (lemma @x899 (or $x900 $x901 $x815 (not $x659) $x732 $x656 $x704 $x462))))
(let ((@x1052 (|unit-resolution| @x903 (|unit-resolution| @x789 (|unit-resolution| @x605 @x1049 $x602) $x774) @x970 @x729 @x714 @x709 (|unit-resolution| @x826 (|unit-resolution| @x597 @x1023 $x594) $x667) (|unit-resolution| @x806 (|unit-resolution| @x613 @x1035 $x610) $x671) $x900)))
(let ((@x1055 (|unit-resolution| @x621 (|unit-resolution| @x623 (|unit-resolution| @x907 @x1052 $x821) $x361) $x618)))
(let ((@x1057 ((_ |th-lemma| arith farkas 1 -1 1/2 -1/2 1 1/2 -1/2 -1/2 1/2 1/2 -1/2 1/2 1/2 -1/2 -1/2 -1/2 1) (|unit-resolution| @x789 (|unit-resolution| @x605 @x1049 $x602) $x774) @x810 (|unit-resolution| @x826 (|unit-resolution| @x597 @x1023 $x594) $x667) @x830 (|unit-resolution| @x623 (|unit-resolution| @x907 @x1052 $x821) $x361) (|unit-resolution| @x806 (|unit-resolution| @x613 @x1035 $x610) $x671) @x696 (|unit-resolution| @x863 @x1055 $x838) @x833 @x729 @x728 @x718 @x714 @x713 @x709 @x992 @x970 false)))
(let ((@x1167 (|unit-resolution| (lemma @x1057 (or $x732 (not $x659) $x656)) @x709 @x1145 $x732)))
(let ((@x1169 (|unit-resolution| @x645 (|unit-resolution| @x1166 @x1167 $x1162) $x312)))
(let ((@x1191 ((_ |th-lemma| arith assign-bounds 1 1 1 1) (or $x336 $x311 $x1139 (not $x641) $x287))))
(let ((@x1216 (|unit-resolution| @x629 (|unit-resolution| @x1191 @x1169 @x1136 @x1076 @x1150 $x336) $x626)))
(let ((@x1217 (|unit-resolution| @x1127 @x1216 $x661)))
(let ((@x1131 (|unit-resolution| @x723 (|unit-resolution| @x589 (|unit-resolution| @x1098 @x842 $x461) $x586) $x679)))
(let (($x1103 (>= ?x1101 0)))
(let ((@x1158 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1119 $x1103)) (hypothesis $x643) (hypothesis (not $x1103)) false)))
(let ((@x1159 (lemma @x1158 (or $x1119 $x1103))))
(let ((@x1110 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x934 $x671)) (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x704 $x1104 $x386)) @x848 @x843 $x704) $x934)))
(let ((@x1112 (|unit-resolution| @x629 (|unit-resolution| @x1092 @x1110 @x833 @x851 @x842 @x1087 $x336) $x626)))
(let ((@x841 (hypothesis $x311)))
(let ((@x860 (lemma ((_ |th-lemma| arith farkas 1 1 1 1 1 1 1 1 1) @x856 @x855 @x851 @x843 @x729 @x728 @x848 @x842 @x841 false) (or $x411 $x858 $x386 (not $x659) $x312))))
(let ((@x1117 (|unit-resolution| @x860 (|unit-resolution| @x1115 @x1112 $x665) @x842 @x729 @x843 $x312)))
(let ((@x1122 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1119 $x1103)) (|unit-resolution| @x647 @x1117 $x643) $x1103)))
(let ((@x1138 ((_ |th-lemma| arith farkas 1 -1 1 -1 -1 1 -1 -1 1 -1 1 -1 -2 2 1) @x833 @x1137 @x1136 @x1087 @x696 @x1133 @x713 @x709 @x718 (|unit-resolution| @x691 @x1072 $x676) @x685 @x1131 (|unit-resolution| @x1127 @x1112 $x661) @x1125 @x1122 false)))
(let ((@x1172 (|unit-resolution| (lemma @x1138 (or $x386 $x1139 $x656 $x411 (not $x659))) @x842 @x709 @x1150 @x1145 $x386)))
(let ((@x1152 ((_ |th-lemma| arith farkas -1/2 1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 -1/2 1/2 -1/2 1/2 -1/2 1) @x701 @x681 @x697 @x696 (hypothesis $x1103) @x1150 @x1136 @x713 @x709 @x718 @x866 @x685 @x867 @x1076 false)))
(let ((@x1155 (lemma @x1152 (or (not $x1103) (not $x668) $x704 $x656 $x782 (not $x679) $x287))))
(let ((@x1175 (|unit-resolution| @x1155 (|unit-resolution| @x806 (|unit-resolution| @x613 @x1172 $x610) $x671) (|unit-resolution| @x1159 (|unit-resolution| @x647 @x1169 $x643) $x1103) @x709 @x1131 @x1086 @x1076 $x782)))
(let ((@x1177 (|unit-resolution| @x1092 @x1087 @x833 @x842 (|unit-resolution| @x948 (|unit-resolution| @x613 @x1172 $x610) $x934) @x851 $x336)))
(let ((@x1102 (lemma ((_ |th-lemma| arith farkas 1 1 1 1 1 1 1 1 1) @x856 @x701 @x1086 @x855 @x761 @x998 @x842 @x797 @x1076 false) (or $x436 $x858 $x411 $x287))))
(let ((@x1180 (|unit-resolution| @x1102 (|unit-resolution| @x1115 (|unit-resolution| @x629 @x1177 $x626) $x665) @x842 @x1076 $x436)))
(let ((@x1184 (lemma (|unit-resolution| @x691 (|unit-resolution| @x597 @x1180 $x594) @x1175 false) (or $x411 $x287 $x656))))
(let ((@x1220 (|unit-resolution| @x789 (|unit-resolution| @x605 (|unit-resolution| @x1184 @x709 @x1076 $x411) $x602) $x774)))
(let ((@x1193 (|unit-resolution| @x629 (|unit-resolution| @x1191 (hypothesis $x312) @x1136 @x1076 @x1150 $x336) $x626)))
(let ((@x1188 (hypothesis $x312)))
(let ((@x1200 (|unit-resolution| @x1199 (|unit-resolution| @x1127 @x1193 $x661) @x1136 @x1188 @x1150 @x1125 $x361)))
(let ((@x1203 ((_ |th-lemma| arith farkas -1 1 -1 -1 -1 1 1 -1 1) @x1185 @x701 (|unit-resolution| @x924 (|unit-resolution| @x621 @x1200 $x618) $x668) @x1076 (|unit-resolution| @x1115 @x1193 $x665) @x855 @x761 @x797 @x1187 false)))
(let ((@x1205 (lemma @x1203 (or $x436 $x412 $x287 $x311))))
(let ((@x1221 (|unit-resolution| @x1205 (|unit-resolution| @x1184 @x709 @x1076 $x411) @x1076 @x1169 $x436)))
(let (($x816 (not $x608)))
(let (($x1197 (not $x633)))
(let (($x1189 (not $x641)))
(let (($x741 (not $x616)))
(let ((@x1224 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1 -1 1 1 -1 1 1 -1) (or $x704 $x741 $x311 $x1139 $x1189 $x815 $x1196 $x1197 $x437 $x816)) @x1169 @x696 @x1125 @x1136 @x810 @x1150 @x1221 @x1220 @x1217 $x704)))
(let ((@x1225 (|unit-resolution| @x792 (|unit-resolution| @x605 (|unit-resolution| @x1184 @x709 @x1076 $x411) $x602) $x773)))
(let ((@x1229 (|unit-resolution| @x621 (|unit-resolution| @x1199 @x1217 @x1136 @x1169 @x1150 @x1125 $x361) $x618)))
(let ((@x1209 (|unit-resolution| @x589 (|unit-resolution| @x801 @x843 @x797 @x1207 @x866 @x685 $x461) $x586)))
(let ((@x1212 ((_ |th-lemma| arith farkas -1 -2 2 -1 1 1 -1 -1 1 -1 1 -1 -1 1 1) @x696 @x1211 @x1125 @x1137 @x1136 (hypothesis $x1103) @x713 @x709 @x718 (|unit-resolution| @x723 @x1209 $x679) @x833 @x1206 @x866 @x685 @x1133 false)))
(let ((@x1231 (|unit-resolution| (lemma @x1212 (or $x386 $x1196 $x1139 (not $x1103) $x656 $x1090 $x782 $x798)) @x1217 @x1150 (|unit-resolution| @x1159 (|unit-resolution| @x647 @x1169 $x643) $x1103) @x709 (|unit-resolution| @x863 @x1229 $x838) (|unit-resolution| @x691 (|unit-resolution| @x597 @x1221 $x594) $x676) @x1225 $x386)))
(let ((@x1235 (lemma (|unit-resolution| @x806 (|unit-resolution| @x613 @x1231 $x610) @x1224 false) (or $x656 $x287))))
(let ((@x1502 (|unit-resolution| @x1235 (|unit-resolution| (lemma @x1495 (or $x708 $x412 $x386)) @x843 @x1185 $x708) $x287)))
(let ((@x1504 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1 1 1 1 1) (or $x286 $x361 $x1197 $x900 (not $x625) $x386 $x1196)) @x1502 @x833 @x1125 @x843 @x1366 @x1476 $x361)))
(let ((@x1506 (|unit-resolution| @x863 (|unit-resolution| @x621 @x1504 $x618) (|unit-resolution| @x1429 @x1502 @x1476 @x843 $x1090) false)))
(let ((@x1508 (lemma @x1506 (or $x386 $x412))))
(let ((@x1815 (|unit-resolution| @x1508 @x1185 $x386)))
(let (($x1513 (not $x627)))
(let ((@x1519 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1 -1 1 1) (or $x1510 $x1197 $x387 $x1374 (not $x624) $x286)) @x1385 @x1125 @x1426 @x1024 @x701 $x1510)))
(let ((@x1522 (|unit-resolution| @x629 (|unit-resolution| @x631 (|unit-resolution| @x1517 @x1519 $x1513) $x336) $x626)))
(let ((@x1524 ((_ |th-lemma| arith farkas 1 1 1 1 1) @x1426 @x1125 (|unit-resolution| @x1127 @x1522 $x661) @x1025 (|unit-resolution| @x631 (|unit-resolution| @x1517 @x1519 $x1513) $x336) false)))
(let ((@x1526 (lemma @x1524 (or $x361 $x286 $x387))))
(let ((@x1826 (|unit-resolution| @x924 (|unit-resolution| @x621 (|unit-resolution| @x1526 @x1815 @x1426 $x361) $x618) $x668)))
(let (($x705 (not $x668)))
(let ((@x1734 (|unit-resolution| @x806 (|unit-resolution| @x613 @x1024 $x610) $x671)))
(let ((@x1670 (|unit-resolution| @x924 (|unit-resolution| @x621 @x839 $x618) $x668)))
(let (($x1500 (>= ?x664 0)))
(let ((@x1546 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1513 $x1500)) @x1528 $x1500)))
(let ((@x1547 (|unit-resolution| @x1517 @x1528 $x873)))
(let ((@x1550 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1 1 1) (or $x437 $x815 $x816 $x704 $x741 $x1510 $x1197 $x286 $x336)) @x1426 @x696 @x1527 @x1125 @x810 @x697 @x1477 @x1547 $x437)))
(let ((@x1552 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x595) $x930)) (|unit-resolution| @x599 @x1550 $x595) $x930)))
(let ((@x1558 (|unit-resolution| @x738 (|unit-resolution| @x599 @x1550 $x595) $x673)))
(let (($x740 (not $x624)))
(let (($x742 (not $x601)))
(let ((@x1560 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1 1 1 1 2 2) (or $x461 $x815 $x816 $x742 $x705 $x740 $x1510 $x1197 $x286 $x743 $x704 $x741))))
(let ((@x1561 (|unit-resolution| @x1560 @x1426 @x810 @x696 @x701 @x1125 @x685 @x697 @x681 @x1558 @x1477 @x1547 $x461)))
(let ((@x1566 ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1 1 1) (or $x311 (not $x1499) $x1189 $x286 $x705 $x412 $x704 $x741 $x740))))
(let ((@x1568 (|unit-resolution| @x645 (|unit-resolution| @x1566 @x1557 @x701 @x1185 @x1136 @x1426 @x697 @x681 @x696 $x311) $x642)))
(let ((@x1570 ((_ |th-lemma| arith assign-bounds -1 1 1 -1 -1 -1 -3 3 1 -1 1 1 -2 2 2 -2) (|unit-resolution| @x1396 @x1568 $x1369) @x1256 (|unit-resolution| @x1268 (|unit-resolution| @x589 @x1561 $x586) $x670) @x1252 @x830 @x1206 @x999 @x851 @x833 @x1557 @x1136 @x1552 @x1187 @x797 @x1546 @x855 $x655)))
(let ((@x1574 (|unit-resolution| @x723 (|unit-resolution| @x589 @x1561 $x586) $x679)))
(let ((@x1576 ((_ |th-lemma| arith assign-bounds -1 1 1 -1 -1 -1 -3 3 1 -1 1 1 -2 2 2 -2) (|unit-resolution| @x1166 @x1568 $x662) @x713 @x1574 @x718 @x685 @x681 @x697 @x696 @x701 @x1573 @x728 @x1558 @x1477 @x810 @x1547 @x1125 $x656)))
(let (($x813 (not $x593)))
(let (($x869 (not $x679)))
(let (($x1579 (or $x486 $x286 $x336 $x869 $x813 $x742 $x705 $x704 $x741 $x740 $x743 $x815 $x816 $x1510 $x1197)))
(let ((@x1581 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1 1 1 1 1 3 3 1 1 2 2 2 2) $x1579) @x1426 @x685 @x810 @x696 @x701 @x1527 @x1125 @x718 @x697 @x681 @x1558 @x1477 @x1574 @x1547 $x486)))
(let (($x812 (not $x640)))
(let (($x1586 (not $x1543)))
(let (($x1585 (not $x585)))
(let (($x1584 (not $x1236)))
(let (($x1587 (or $x652 $x1584 $x1585 $x815 $x816 $x1510 $x1197 $x704 $x741 $x869 $x813 $x1586 $x812)))
(let ((@x1589 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 1 -1 -1 1 1 -1 -1 1) $x1587) @x1574 @x810 @x696 @x1125 @x728 @x1284 @x697 @x1477 @x718 @x1547 @x1573 (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1581 $x578) $x1236) $x652)))
(let (($x1564 (not $x1499)))
(let (($x1401 (not $x592)))
(let (($x956 (not $x617)))
(let (($x955 (not $x934)))
(let (($x1593 (not $x632)))
(let (($x1592 (not $x1500)))
(let (($x799 (not $x609)))
(let (($x1591 (not $x584)))
(let (($x1321 (not $x1237)))
(let (($x1594 (or $x651 $x1321 $x1591 $x798 $x799 $x1592 $x1593 $x955 $x956 $x1260 $x1401 $x1564 $x1189)))
(let ((@x1596 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 1 -1 -1 1 1 -1 -1 1) $x1594) (|unit-resolution| @x1268 (|unit-resolution| @x589 @x1561 $x586) $x670) @x797 @x851 @x855 @x1136 @x1296 @x1187 @x1252 @x999 (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1581 $x578) $x1237) @x1557 @x1546 $x651)))
(let ((@x1597 (|unit-resolution| @x1304 @x1596 @x1589 (|unit-resolution| @x577 (|unit-resolution| @x1277 @x1576 @x1570 $x71) $x564) false)))
(let ((@x1671 (|unit-resolution| (lemma @x1597 (or $x286 $x955 $x704 $x336 $x705 $x1090 $x412)) @x1670 @x697 @x1527 @x999 @x864 @x1185 $x286)))
(let ((@x1673 (|unit-resolution| @x1149 (|unit-resolution| @x637 @x1671 $x634) $x658)))
(let ((@x1676 (|unit-resolution| (|unit-resolution| @x1191 @x1136 (or $x336 $x311 $x1139 $x287)) @x1673 @x1671 @x1527 $x311)))
(let ((@x1677 (|unit-resolution| @x1235 @x1671 $x656)))
(let (($x1654 (or $x655 $x705 $x704 $x1139 $x1104 $x815 $x1564 $x798 $x955 $x1592 $x1090 $x708 $x312)))
(let ((@x1602 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x841 $x642) $x1369)))
(let ((@x1600 (hypothesis $x1500)))
(let ((@x1623 (hypothesis $x1499)))
(let ((@x1604 ((_ |th-lemma| arith farkas 2 2 2 2 1 1 1 1 1 1 1 1 1 1) (hypothesis $x487) @x1602 @x1256 @x1263 @x1136 @x761 @x1207 @x797 @x999 @x851 @x1600 @x855 @x841 @x1137 false)))
(let ((@x1620 (|unit-resolution| (lemma @x1604 (or $x486 $x708 $x436 $x798 $x955 $x1592 $x312 $x1139)) @x761 @x1263 @x1207 @x999 @x1600 @x841 @x1137 $x486)))
(let (($x1626 (not $x930)))
(let (($x1089 (not $x625)))
(let (($x1402 (not $x600)))
(let (($x1625 (not $x649)))
(let (($x1627 (or $x1301 $x1584 $x1585 $x798 $x799 $x1592 $x1593 $x955 $x956 $x1373 $x1625 $x655 $x1402 $x1090 $x1089 $x1626)))
(let ((@x1629 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 1 -1 -1 1 2 -2 1 -1 -1 1 1 -1 -1) $x1627) @x964 @x797 @x851 @x833 @x855 @x1256 @x1284 @x1253 @x1207 @x999 @x830 @x1206 @x1602 @x1600 (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1620 $x578) $x1236) $x1301)))
(let ((@x1630 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 1 -1 -1 1 1 -1 -1 1) $x1594) @x1629 @x797 @x851 @x855 @x1136 @x1623 @x1207 (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1620 $x578) $x1237) @x999 @x1252 @x1296 @x1600 $x1260)))
(let (($x757 (not $x587)))
(let (($x1607 (>= ?x674 0)))
(let (($x1611 (not $x1607)))
(let ((@x1609 (hypothesis $x673)))
(let ((@x1610 ((_ |th-lemma| arith farkas 1 1 -1 1 -1 -1 -1 -1 1 1 -1 1 1) @x685 @x697 @x696 @x681 @x701 @x1609 @x1252 @x1371 @x1256 @x1253 @x1137 @x1136 (hypothesis $x1607) false)))
(let ((@x1613 (lemma @x1610 (or $x1611 $x704 $x705 $x743 $x1373 $x655 $x1139))))
(let ((@x1618 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x757 $x1607)) (hypothesis $x587) (hypothesis $x1611) false)))
(let ((@x1619 (lemma @x1618 (or $x757 $x1607))))
(let ((@x1632 (|unit-resolution| @x1619 (|unit-resolution| @x1613 @x939 @x681 @x697 @x1602 @x1253 @x1137 $x1611) $x757)))
(let ((@x1635 (|unit-resolution| @x1268 (|unit-resolution| @x589 (|unit-resolution| @x591 @x1632 $x461) $x586) @x1630 false)))
(let ((@x1637 (lemma @x1635 (or $x436 $x705 $x704 $x655 $x1139 $x1564 $x798 $x955 $x1592 $x1090 $x708 $x312))))
(let ((@x1638 (|unit-resolution| @x1637 @x1253 @x697 @x681 @x1137 @x1623 @x1207 @x999 @x1600 @x1206 @x1263 @x841 $x436)))
(let ((@x1641 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -2 -2 2 -2 2) (or $x1354 $x705 $x437 $x815 $x816 $x704 $x741)) @x1638 @x696 @x697 @x681 @x897 @x810 $x1354)))
(let ((@x1644 (|unit-resolution| @x1376 (|unit-resolution| @x826 (|unit-resolution| @x597 @x1638 $x594) $x667) @x1248 @x1137 @x1253 @x1641 @x1602 $x1260)))
(let ((@x1648 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x673 $x437 $x782)) (|unit-resolution| @x691 (|unit-resolution| @x597 @x1638 $x594) $x676) @x1638 $x673)))
(let ((@x1650 (|unit-resolution| @x1619 (|unit-resolution| @x1613 @x1648 @x681 @x697 @x1602 @x1253 @x1137 $x1611) $x757)))
(let ((@x1653 (|unit-resolution| @x1268 (|unit-resolution| @x589 (|unit-resolution| @x591 @x1650 $x461) $x586) @x1644 false)))
(let ((@x1681 (|unit-resolution| (lemma @x1653 $x1654) @x1670 @x697 @x1673 @x1248 @x1477 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -2) (or $x1499 $x1139 $x287)) @x1673 @x1671 $x1499) @x1187 @x999 @x1546 @x864 @x1677 @x1676 $x655)))
(let (($x1665 (or $x436 $x815 $x1510 $x704 $x764 $x705 $x708 $x798 $x955 $x1090 $x1592 $x312 $x1139)))
(let (($x1658 (or $x652 $x1584 $x1585 $x798 $x799 $x1592 $x1593 $x955 $x956 $x1373 $x1625 $x708 $x1402 $x1090 $x1089 $x1626)))
(let ((@x1660 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1 2 2 1 1 1 1 1 -1 -1) $x1658) (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1620 $x578) $x1236) @x797 @x851 @x833 @x855 @x1256 @x964 @x1263 @x1207 @x999 @x830 @x1206 @x1602 @x1600 @x1284 $x652)))
(let ((@x1661 (|unit-resolution| @x1304 @x1660 (|unit-resolution| @x577 (|unit-resolution| @x1277 @x762 @x1263 $x71) $x564) $x1301)))
(let ((@x1664 ((_ |th-lemma| arith farkas 1 -1 1 -1 -1 1 2 -2 1 -1 -1 1 1 -1 -1 1) (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1620 $x578) $x1237) @x1296 @x897 @x810 (hypothesis $x873) @x1125 @x697 @x696 (|unit-resolution| @x1166 (|unit-resolution| @x645 @x841 $x642) $x662) @x713 @x762 @x685 @x681 @x701 @x939 @x1661 false)))
(let ((@x1682 (|unit-resolution| (lemma @x1664 $x1665) @x1681 @x1547 @x697 @x1477 @x1670 @x1677 @x1187 @x999 @x864 @x1546 @x1676 @x1673 $x436)))
(let ((@x1694 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -2 2 -2 -2 2 -1) (or $x930 $x815 $x816 $x704 $x362 $x741 $x901)) @x696 @x810 (or $x930 $x815 $x704 $x362 $x901))))
(let ((@x1695 (|unit-resolution| @x1694 (|unit-resolution| @x826 (|unit-resolution| @x597 @x1682 $x594) $x667) @x697 @x839 @x1477 $x930)))
(let ((@x1667 ((_ |th-lemma| arith farkas 1 -1 1 -1 -1 -1 1 1 -1 1 1) @x681 @x701 @x697 @x696 (hypothesis $x487) @x1371 @x1256 @x1263 @x1137 @x1136 @x1185 false)))
(let ((@x1669 (lemma @x1667 (or $x486 $x705 $x704 $x1373 $x708 $x1139 $x412))))
(let ((@x1696 (|unit-resolution| @x1669 @x1670 @x697 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x1676 $x642) $x1369) @x1677 @x1673 @x1185 $x486)))
(let ((@x1699 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1 2 2 1 1 1 1 1 -1 -1) $x1658) (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1696 $x578) $x1236) @x797 @x851 @x833 @x855 @x1256 @x1695 @x1677 @x1187 @x999 @x830 @x864 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x1676 $x642) $x1369) @x1546 @x1284 $x652)))
(let ((@x1700 (|unit-resolution| @x1304 @x1699 (|unit-resolution| @x577 (|unit-resolution| @x1277 @x1681 @x1677 $x71) $x564) $x1301)))
(let ((@x1702 ((_ |th-lemma| arith farkas -2 -1 1 -1 -1 1 1 -1 -2 2 -1 1 1 -1 -1 1 1) @x1682 (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1696 $x578) $x1237) @x1296 @x1700 @x1477 @x810 @x1547 @x1125 @x697 @x696 (|unit-resolution| @x1166 (|unit-resolution| @x645 @x1676 $x642) $x662) @x713 @x1681 @x685 @x1670 @x701 (|unit-resolution| @x691 (|unit-resolution| @x597 @x1682 $x594) $x676) false)))
(let ((@x1736 (|unit-resolution| (lemma @x1702 (or $x362 $x704 $x955 $x412 $x1104 $x336)) @x1527 @x1027 @x1185 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x778 $x387 $x955)) @x1027 @x1024 $x778) @x1734 $x362)))
(let ((@x1737 (|unit-resolution| (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1) (or $x705 $x361 $x900)) @x1366 (or $x705 $x361)) @x1736 $x705)))
(let ((@x1741 (|unit-resolution| @x1149 (|unit-resolution| @x637 (|unit-resolution| @x1526 @x1736 @x1024 $x286) $x634) $x658)))
(let ((@x1743 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x821 $x1354)) (|unit-resolution| @x623 @x1736 $x619) $x1354)))
(let ((@x1744 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 2 1 2 2 2) (or $x1374 $x1139 $x1189 $x1090 $x1197 $x1196 $x311)) @x1743 @x1542 @x1741 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x838 $x668)) @x1737 $x838) @x1136 @x1125 $x311)))
(let ((@x1747 (|unit-resolution| @x1235 (|unit-resolution| @x1526 @x1736 @x1024 $x286) $x656)))
(let ((@x1750 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1) (or $x486 $x336 $x1373 $x1625 $x708 $x1139 $x1189)) @x1527 @x1136 @x1256 @x1747 @x1741 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x1744 $x642) $x1369) $x486)))
(let ((@x1719 (|unit-resolution| @x958 @x851 @x797 (or $x361 $x955 $x436 $x798))))
(let ((@x1755 (|unit-resolution| @x826 (|unit-resolution| @x597 (|unit-resolution| @x1719 @x1736 @x1027 @x1187 $x436) $x594) $x667)))
(let (($x1756 (or $x652 $x901 $x1584 $x1585 $x815 $x816 $x1592 $x1593 $x1373 $x1625 $x708 $x1402 $x1089 $x900)))
(let ((@x1758 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 1 -1 -1 1 -1 1 1 -1 -1 1 -1 1) $x1756) @x1747 @x810 @x833 @x855 @x1256 @x1284 @x830 @x1477 @x1755 @x1366 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x1744 $x642) $x1369) @x1546 (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1750 $x578) $x1236) $x652)))
(let ((@x1709 (|unit-resolution| (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1) (or $x705 $x361 $x900)) @x1366 (or $x705 $x361)) @x1025 $x705)))
(let ((@x1715 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 2 1 2 2 2) (or $x1374 $x1139 $x1189 $x1090 $x1197 $x1196 $x311)) @x1385 @x1542 @x1137 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x838 $x668)) @x1709 $x838) @x1136 @x1125 $x311)))
(let ((@x1722 (|unit-resolution| @x691 (|unit-resolution| @x597 (|unit-resolution| @x1719 @x1025 @x999 @x1207 $x436) $x594) $x676)))
(let (($x1723 (or $x1611 $x955 $x956 $x1401 $x1373 $x1625 $x655 $x1139 $x1189 $x798 $x799 $x782 $x742 $x740 $x1374)))
(let ((@x1725 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 1 -1 -1 1 1 -1 1 -2 2 -1 1 -1 1) $x1723) @x1253 @x797 @x851 @x701 @x1136 @x1256 @x685 @x1137 @x1722 @x1207 @x999 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x1715 $x642) $x1369) @x1385 @x1252 $x1611)))
(let ((@x1726 (|unit-resolution| @x826 (|unit-resolution| @x597 (|unit-resolution| @x1719 @x1025 @x999 @x1207 $x436) $x594) $x667)))
(let ((@x1729 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1 1 1 1) (or $x462 $x361 $x901 $x815 $x816 $x1402 $x1089 $x900 $x336)) @x1025 @x810 @x830 @x833 @x1527 @x897 @x1726 @x1366 $x462)))
(let ((@x1733 (lemma (|unit-resolution| @x1619 (|unit-resolution| @x591 @x1729 $x587) @x1725 false) (or $x655 $x1139 $x798 $x955 $x361 $x336 $x815))))
(let ((@x1760 (|unit-resolution| @x1277 (|unit-resolution| @x1733 @x1741 @x1187 @x1027 @x1736 @x1527 @x1477 $x655) @x1747 $x71)))
(let ((@x1765 (|unit-resolution| @x691 (|unit-resolution| @x597 (|unit-resolution| @x1719 @x1736 @x1027 @x1187 $x436) $x594) $x676)))
(let ((@x1766 ((_ |th-lemma| arith farkas -1 1 -1 -1 1 -1 1 1 -1 -1 1 -1 1 1) @x1765 (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1750 $x578) $x1237) @x1296 @x1187 @x797 @x1547 @x1125 (|unit-resolution| @x1166 (|unit-resolution| @x645 @x1744 $x642) $x662) @x713 (|unit-resolution| @x1733 @x1741 @x1187 @x1027 @x1736 @x1527 @x1477 $x655) @x685 @x701 @x1743 (|unit-resolution| @x1304 (|unit-resolution| @x577 @x1760 $x564) @x1758 $x1301) false)))
(let ((@x1768 (lemma @x1766 (or $x336 $x387 $x412))))
(let ((@x1829 (|unit-resolution| (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -2) (or $x873 $x1196 $x337)) @x1542 (or $x873 $x337)) (|unit-resolution| @x1768 @x1185 @x1815 $x336) $x873)))
(let ((@x1820 (|unit-resolution| @x806 (|unit-resolution| @x613 @x1815 $x610) $x671)))
(let ((@x1805 (hypothesis $x1139)))
(let ((@x1807 (|unit-resolution| @x1556 @x1553 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1) (or $x658 $x286 $x1564)) @x1426 @x1805 $x1564) false)))
(let ((@x1811 (|unit-resolution| @x637 (|unit-resolution| (lemma @x1807 (or $x286 $x658)) @x1805 $x286) $x634)))
(let ((@x1813 (lemma (|unit-resolution| @x1149 @x1811 @x1805 false) $x658)))
(let (($x1791 (or $x1586 $x815 $x816 $x704 $x741 $x1510 $x1197 $x1139 $x461 $x742 $x705 $x740 $x743)))
(let ((@x1831 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 2 4 4 2 2 1 2 2 2 2 2) $x1791) @x810 @x696 @x701 @x1125 @x1813 @x685 (or $x1586 $x815 $x704 $x1510 $x461 $x705 $x743))))
(let ((@x1833 (|unit-resolution| @x589 (|unit-resolution| @x1831 @x1820 @x1573 @x1826 @x1609 @x1477 @x1829 $x461) $x586)))
(let ((@x1836 (|unit-resolution| @x1566 @x701 @x1136 @x696 (or $x311 $x1564 $x286 $x705 $x412 $x704))))
(let ((@x1838 (|unit-resolution| @x645 (|unit-resolution| @x1836 @x1820 @x1557 @x1426 @x1185 @x1826 $x311) $x642)))
(let ((@x1842 (|unit-resolution| (|unit-resolution| @x1669 @x1813 (or $x486 $x705 $x704 $x1373 $x708 $x412)) (|unit-resolution| @x1396 @x1838 $x1369) @x1263 @x1826 @x1820 @x1185 $x486)))
(let ((@x1846 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 -1 1 1 -1 -1 1 1 -1 -1 1) $x1587) @x810 @x696 @x1125 @x728 @x718 @x1284 (or $x652 $x1584 $x815 $x1510 $x704 $x869 $x1586))))
(let ((@x1847 (|unit-resolution| @x1846 (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1842 $x578) $x1236) @x1573 @x1820 @x1477 (|unit-resolution| @x723 @x1833 $x679) @x1829 $x652)))
(let ((@x1818 (|unit-resolution| @x1115 (|unit-resolution| @x629 (|unit-resolution| @x1768 @x1185 @x1815 $x336) $x626) $x665)))
(let ((@x1821 ((_ |th-lemma| arith farkas -1 1/3 -1/3 4/3 1/3 -1/3 -1/3 1/3 1/3 -1/3 1/3 -2/3 2/3 2/3 -2/3 1/3 -1/3 1) @x701 @x1820 @x696 @x1185 @x1249 @x1252 @x1371 @x1256 @x1253 @x1623 @x1136 @x1187 @x797 @x1818 @x855 (hypothesis $x930) @x830 @x681 false)))
(let ((@x1849 (|unit-resolution| (lemma @x1821 (or $x655 $x412 $x1260 $x1373 $x1564 $x1626 $x705)) @x1185 (|unit-resolution| @x1268 @x1833 $x670) (|unit-resolution| @x1396 @x1838 $x1369) @x1557 (hypothesis $x930) @x1826 $x655)))
(let ((@x1852 (|unit-resolution| @x1304 (|unit-resolution| @x577 (|unit-resolution| @x1277 @x1849 @x1263 $x71) $x564) @x1847 $x1301)))
(let ((@x1855 ((_ |th-lemma| arith farkas 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 1) @x701 @x1820 @x696 (|unit-resolution| @x1268 @x1833 $x670) @x1252 (|unit-resolution| @x1166 @x1838 $x662) @x713 @x1849 @x1557 @x1136 @x1609 @x685 (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1842 $x578) $x1237) @x1296 @x1852 @x1826 false)))
(let ((@x1858 (|unit-resolution| (lemma @x1855 (or $x412 $x743 $x708 $x1626 $x286)) @x939 @x1263 @x964 @x1426 $x412)))
(let ((@x1860 (|unit-resolution| @x997 (|unit-resolution| @x607 @x1858 $x603) $x931)))
(let ((@x1861 (|unit-resolution| @x1037 (|unit-resolution| @x607 @x1858 $x603) $x1022)))
(let ((@x1865 (|unit-resolution| @x863 (|unit-resolution| @x621 (|unit-resolution| @x1064 @x1858 $x361) $x618) $x838)))
(let ((@x1868 (|unit-resolution| (|unit-resolution| @x1070 @x797 (or $x436 (not $x931) $x411 $x386)) @x1860 @x761 @x1858 $x386)))
(let ((@x1874 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2 2 2 2 2) (or (not $x1022) $x798 $x336 $x1090 $x955 $x956 $x1089)) @x833 @x851 (or (not $x1022) $x798 $x336 $x1090 $x955))))
(let ((@x1875 (|unit-resolution| @x1874 (|unit-resolution| @x948 (|unit-resolution| @x613 @x1868 $x610) $x934) @x1865 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x773 (not $x931) $x411)) @x1860 @x1858 $x773) @x1861 $x336)))
(let ((@x1877 (|unit-resolution| @x1115 (|unit-resolution| @x629 @x1875 $x626) $x665)))
(let ((@x1878 (|unit-resolution| @x924 (|unit-resolution| @x621 (|unit-resolution| @x1064 @x1858 $x361) $x618) $x668)))
(let ((@x1879 (|unit-resolution| @x806 (|unit-resolution| @x613 @x1868 $x610) $x671)))
(let (($x1000 (not $x931)))
(let ((@x1881 ((_ |th-lemma| arith assign-bounds 2 2 1 1 1 1 1 1 1 1 1) (or $x311 $x705 $x740 $x704 $x741 $x1564 $x1189 $x436 $x799 $x858 $x1593 $x1000))))
(let ((@x1882 (|unit-resolution| @x1881 @x761 @x696 @x701 @x855 @x1136 @x797 @x1879 @x1878 @x1877 @x1860 @x1557 $x311)))
(let ((@x1887 (|unit-resolution| @x1268 (|unit-resolution| @x589 (|unit-resolution| @x1098 @x1858 $x461) $x586) $x670)))
(let ((@x1888 (|unit-resolution| @x723 (|unit-resolution| @x589 (|unit-resolution| @x1098 @x1858 $x461) $x586) $x679)))
(let ((@x1892 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2 2 2 2 2) (or (not $x1022) $x798 $x486 $x782 $x869 $x742 $x813)) @x685 @x718 (or (not $x1022) $x798 $x486 $x782 $x869))))
(let ((@x1893 (|unit-resolution| @x1892 @x1861 @x942 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x773 $x1000 $x411)) @x1860 @x1858 $x773) @x1888 $x486)))
(let (($x1078 (not $x1022)))
(let (($x1896 (or $x652 $x1090 $x1089 $x955 $x956 $x869 $x813 $x1586 $x812 $x1584 $x1585 $x816 $x1196 $x1197 $x1078)))
(let ((@x1898 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -2 1 -1 1 -1 -1 1 1 -1 1 1 -1 -1) $x1896) @x1888 @x810 @x851 @x833 @x1125 @x728 @x1284 @x718 (|unit-resolution| @x948 (|unit-resolution| @x613 @x1868 $x610) $x934) @x1865 @x1861 @x1542 @x1573 (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1893 $x578) $x1236) $x652)))
(let (($x1900 (or $x651 $x705 $x740 $x704 $x741 $x1260 $x1401 $x1564 $x1189 $x1321 $x1591 $x799 $x858 $x1593 $x1000)))
(let ((@x1902 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -2 1 -1 1 -1 -1 1 1 -1 1 1 -1 -1) $x1900) @x1879 @x797 @x696 @x701 @x855 @x1136 @x1296 @x1252 @x1878 @x1877 @x1887 @x1860 (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1893 $x578) $x1237) @x1557 $x651)))
(let ((@x1905 (|unit-resolution| @x1277 (|unit-resolution| @x577 (|unit-resolution| @x1304 @x1902 @x1898 $x70) $x565) @x1263 $x764)))
(let ((@x1906 ((_ |th-lemma| arith farkas -1 -1 -1 1 -3 3 -1 1 -1 1 1 -1 -2 -2 2 2 1) @x1256 @x1905 @x964 @x830 @x1878 @x701 @x1879 @x696 @x1887 @x1252 @x1557 @x1136 @x797 @x1877 @x855 @x1860 (|unit-resolution| @x1396 (|unit-resolution| @x645 @x1882 $x642) $x1369) false)))
(let ((@x1919 (|unit-resolution| @x597 (|unit-resolution| (lemma @x1906 (or $x436 $x708 $x286)) @x1426 @x1263 $x436) $x594)))
(let ((@x1922 (|unit-resolution| @x1892 @x1038 (|unit-resolution| @x691 @x1919 $x676) @x1067 @x1131 $x486)))
(let ((@x1925 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -2 1 -1 1 -1 -1 1 1 -1 1 1 -1 -1) $x1896) @x1917 @x810 @x851 @x833 @x1125 @x728 @x1284 @x718 @x1131 @x1087 @x1038 @x1542 @x1573 (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1922 $x578) $x1236) $x652)))
(let ((@x1929 (|unit-resolution| @x629 (|unit-resolution| @x1874 @x1917 @x1087 @x1067 @x1038 $x336) $x626)))
(let ((@x1931 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -2 1 -1 1 -1 -1 1 1 -1 1 1 -1 -1) $x1900) (|unit-resolution| @x1115 @x1929 $x665) @x797 @x696 @x701 @x855 @x1136 @x1296 @x1252 @x1086 (|unit-resolution| @x806 (|unit-resolution| @x613 @x1915 $x610) $x671) @x1269 @x998 (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1922 $x578) $x1237) @x1557 $x651)))
(let ((@x1934 (|unit-resolution| @x1277 (|unit-resolution| @x577 (|unit-resolution| @x1304 @x1931 @x1925 $x70) $x565) @x1263 $x764)))
(let ((@x1910 ((_ |th-lemma| arith farkas -1 -1 -1 1 -1 1 1 -1 1 -1 -1 1 1) @x1256 @x1253 @x898 @x830 @x1249 @x1252 @x1206 @x833 @x999 @x851 (hypothesis $x1543) @x728 (hypothesis $x1247) false)))
(let ((@x1935 (|unit-resolution| (lemma @x1910 (or $x1259 $x655 $x901 $x1260 $x1090 $x955 $x1586)) @x1934 (|unit-resolution| @x826 @x1919 $x667) @x1269 @x1087 @x1917 @x1573 $x1259)))
(let ((@x1938 (|unit-resolution| @x645 (|unit-resolution| @x647 (|unit-resolution| @x1310 @x1935 $x1119) $x311) $x642)))
(let ((@x1940 ((_ |th-lemma| arith farkas -1 -1 -2 -1 1 -1 1 1 -1 1 -1 -1 1 1) @x1256 @x1934 (|unit-resolution| @x647 (|unit-resolution| @x1310 @x1935 $x1119) $x311) (|unit-resolution| @x826 @x1919 $x667) @x830 @x1269 @x1252 @x1087 @x833 @x1917 @x851 @x1573 @x728 (|unit-resolution| @x1396 @x1938 $x1369) false)))
(let ((@x1943 (|unit-resolution| (lemma @x1940 (or $x411 $x708 $x286)) @x1426 @x1263 $x411)))
(let ((@x1944 (|unit-resolution| @x1508 @x1943 $x386)))
(let ((@x1948 (|unit-resolution| (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -2) (or $x873 $x1196 $x337)) @x1542 (or $x873 $x337)) (|unit-resolution| @x1768 @x1943 @x1944 $x336) $x873)))
(let ((@x1950 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1 -1 1 1) (or $x1510 $x1197 $x387 $x1374 $x740 $x286)) @x1125 @x701 (or $x1510 $x387 $x1374 $x286))))
(let ((@x1956 (|unit-resolution| @x924 (|unit-resolution| @x621 (|unit-resolution| @x1526 @x1944 @x1426 $x361) $x618) $x668)))
(let ((@x1958 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -2 -2 2 -2 2) (or $x1354 $x705 $x437 $x815 $x816 $x704 $x741)) @x696 @x810 (or $x1354 $x705 $x437 $x815 $x704))))
(let ((@x1959 (|unit-resolution| @x1958 @x1956 (|unit-resolution| @x789 (|unit-resolution| @x605 @x1943 $x602) $x774) (|unit-resolution| (lemma @x1906 (or $x436 $x708 $x286)) @x1426 @x1263 $x436) (|unit-resolution| @x1950 @x1948 @x1426 @x1944 $x1374) (|unit-resolution| @x806 (|unit-resolution| @x613 @x1944 $x610) $x671) false)))
(let ((@x1992 (|unit-resolution| (lemma @x1959 (or $x286 $x708)) @x1263 $x286)))
(let ((@x1240 (|unit-resolution| @x613 (|unit-resolution| @x1070 @x761 @x797 @x998 @x842 $x386) $x610)))
(let ((@x1242 (|unit-resolution| @x1092 (|unit-resolution| @x948 @x1240 $x934) @x833 @x842 @x1087 @x851 $x336)))
(let ((@x1244 (|unit-resolution| @x1115 (|unit-resolution| @x629 @x1242 $x626) (|unit-resolution| @x1102 @x761 @x842 @x1076 $x858) false)))
(let ((@x1325 (|unit-resolution| @x597 (|unit-resolution| (lemma @x1244 (or $x436 $x411 $x287)) @x842 @x1076 $x436) $x594)))
(let ((@x1265 (|unit-resolution| @x629 (|unit-resolution| @x1092 @x1110 @x833 @x842 @x1087 @x851 $x336) $x626)))
(let ((@x1270 (|unit-resolution| @x860 (|unit-resolution| @x1115 @x1265 $x665) @x842 @x729 @x843 $x312)))
(let ((@x1274 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x1119 $x1247)) (|unit-resolution| @x647 @x1270 $x643) $x1247)))
(let ((@x1275 (|unit-resolution| @x1262 @x1274 @x1086 @x1269 @x729 @x898 @x848 (|unit-resolution| @x1115 @x1265 $x665) $x655)))
(let ((@x1287 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x486 $x813 $x411 $x782 $x742 $x869)) @x866 @x685 @x842 @x1131 @x718 $x486)))
(let ((@x1293 ((_ |th-lemma| arith assign-bounds 1 -3/2 3/2 -1 1/2 -1/2 1/2 -1/2 -1 1 1/2 -1/2 -1/2 1/2 1/2 -1/2 1/2) (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1287 $x578) $x1236) @x718 @x1131 @x1284 @x1087 @x729 @x728 @x833 @x1038 @x810 @x848 @x851 (|unit-resolution| @x1159 (|unit-resolution| @x647 @x1270 $x643) $x1103) @x713 @x1275 @x685 @x866 $x652)))
(let ((@x1300 ((_ |th-lemma| arith assign-bounds 1 -3/2 3/2 -1 1/2 -1/2 1/2 -1/2 -1 1 1/2 -1/2 -1/2 1/2 1/2 -1/2 1/2) (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1287 $x578) $x1237) @x1252 @x1269 @x1296 @x1086 @x1137 @x1136 @x701 @x998 @x797 @x1133 @x696 @x1274 @x1256 @x1263 @x830 @x898 $x651)))
(let ((@x1305 (|unit-resolution| @x1304 @x1300 @x1293 (|unit-resolution| @x577 (|unit-resolution| @x1277 @x1275 @x1263 $x71) $x564) false)))
(let ((@x1329 (|unit-resolution| (lemma @x1305 (or $x386 $x1139 $x708 $x901 (not $x659) $x782 $x411)) (|unit-resolution| @x826 @x1325 $x667) (|unit-resolution| @x1235 @x1076 $x656) @x1150 @x1145 (|unit-resolution| @x691 @x1325 $x676) @x842 $x386)))
(let ((@x1331 (|unit-resolution| @x948 (|unit-resolution| @x613 @x1329 $x610) $x934)))
(let ((@x1333 ((_ |th-lemma| arith assign-bounds 2 -1) (or $x778 $x387 $x955))))
(let ((@x1336 (|unit-resolution| @x629 (|unit-resolution| @x1092 @x1331 @x833 @x842 @x1087 @x851 $x336) $x626)))
(let ((@x1337 (|unit-resolution| @x1115 @x1336 $x665)))
(let ((@x1313 (|unit-resolution| @x629 (|unit-resolution| @x1092 @x1027 @x833 @x842 @x1087 @x851 $x336) $x626)))
(let ((@x1315 ((_ |th-lemma| arith farkas -1 -1 -1 1 -1 1 -1 1 1) @x1024 @x841 @x729 @x728 @x851 @x842 (|unit-resolution| @x1115 @x1313 $x665) @x855 @x1027 false)))
(let ((@x1338 (|unit-resolution| (lemma @x1315 (or $x312 $x387 (not $x659) $x411)) @x1329 @x1145 @x842 $x312)))
(let ((@x1341 (|unit-resolution| @x1262 (|unit-resolution| @x1310 (|unit-resolution| @x647 @x1338 $x643) $x1247) @x1337 @x1269 @x1145 (|unit-resolution| @x826 @x1325 $x667) (|unit-resolution| @x1333 @x1331 @x1329 $x778) @x1086 $x655)))
(let ((@x1343 (|unit-resolution| @x577 (|unit-resolution| @x1277 @x1341 (|unit-resolution| @x1235 @x1076 $x656) $x71) $x564)))
(let ((@x1344 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1 1 1 1) (or $x486 $x813 $x411 $x782 $x742 $x869)) (|unit-resolution| @x691 @x1325 $x676) @x685 @x842 @x1131 @x718 $x486)))
(let ((@x1320 ((_ |th-lemma| arith farkas 1 -1 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 1) @x681 @x701 @x856 @x855 @x697 @x1150 @x1136 @x696 (hypothesis $x1237) @x1252 @x1249 @x1296 @x1318 (hypothesis $x931) @x797 @x1076 false)))
(let ((@x1323 (lemma @x1320 (or $x651 $x705 $x858 $x704 $x1321 $x1260 $x1000 $x287))))
(let ((@x1348 (|unit-resolution| @x1323 @x1086 @x1337 (|unit-resolution| @x806 (|unit-resolution| @x613 @x1329 $x610) $x671) (|unit-resolution| @x1298 (|unit-resolution| @x581 @x1344 $x578) $x1237) @x1269 @x998 @x1076 $x651)))
(let ((@x1351 ((_ |th-lemma| arith farkas -1/2 1/2 -1/2 1/2 1/2 -1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1) @x1331 @x1145 @x728 @x851 @x1337 @x855 (|unit-resolution| @x1291 (|unit-resolution| @x581 @x1344 $x578) $x1236) @x718 @x1131 @x1284 (|unit-resolution| @x1304 @x1348 @x1343 $x1302) @x1038 @x810 @x1329 false)))
(let ((@x1353 (lemma @x1351 (or $x411 $x287))))
(let ((@x1993 (|unit-resolution| @x1353 @x1992 $x411)))
(let ((@x1994 (|unit-resolution| @x1508 @x1993 $x386)))
(let ((@x1996 (|unit-resolution| @x948 (|unit-resolution| @x613 @x1994 $x610) $x934)))
(let ((@x1998 (|unit-resolution| @x792 (|unit-resolution| @x605 @x1993 $x602) $x773)))
(let ((@x1964 (|unit-resolution| @x613 (|unit-resolution| @x1508 (|unit-resolution| @x1353 @x1076 $x411) $x386) $x610)))
(let ((@x1967 (|unit-resolution| @x789 (|unit-resolution| @x605 (|unit-resolution| @x1353 @x1076 $x411) $x602) $x774)))
(let ((@x1970 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1 -1 1 1 -1 1 1 -1) (or $x704 $x741 $x311 $x1139 $x1189 $x815 $x1196 $x1197 $x437 $x816)) @x696 @x1125 @x1136 @x810 (or $x704 $x311 $x1139 $x815 $x1196 $x437))))
(let ((@x1973 (|unit-resolution| (|unit-resolution| @x1970 @x1542 @x1813 (or $x704 $x311 $x815 $x437)) (|unit-resolution| @x1205 @x1188 @x1076 (|unit-resolution| @x1353 @x1076 $x411) $x436) @x1188 @x1967 (|unit-resolution| @x806 @x1964 $x671) false)))
(let ((@x2008 (|unit-resolution| @x1115 (|unit-resolution| @x629 (|unit-resolution| @x1768 @x1993 @x1994 $x336) $x626) $x665)))
(let ((@x2012 (|unit-resolution| @x1144 (|unit-resolution| @x637 @x1992 $x634) $x659)))
(let ((@x2049 (lemma ((_ |th-lemma| arith farkas 1 -1 1 -1 -1 -1 1 -1 1 1) @x729 @x728 @x856 @x855 @x1207 @x761 @x797 @x999 @x851 @x841 false) (or $x436 (not $x659) $x858 $x798 $x955 $x312))))
(let ((@x2050 (|unit-resolution| @x2049 @x2012 @x2008 @x1998 @x1996 (|unit-resolution| (lemma @x1973 (or $x311 $x287)) @x1992 $x311) $x436)))
(let ((@x2000 (|unit-resolution| @x645 (|unit-resolution| (lemma @x1973 (or $x311 $x287)) @x1992 $x311) $x642)))
(let ((@x2001 (|unit-resolution| @x1396 @x2000 $x1369)))
(let ((@x2002 (|unit-resolution| @x1333 @x1996 @x1994 $x778)))
(let ((@x2053 (|unit-resolution| @x806 (|unit-resolution| @x613 @x1994 $x610) $x671)))
(let ((@x2006 (|unit-resolution| @x1768 @x1993 @x1994 $x336)))
(let ((@x2027 (|unit-resolution| @x691 (|unit-resolution| @x597 (|unit-resolution| @x1719 @x1025 @x1996 @x1998 $x436) $x594) $x676)))
(let ((@x2028 (|unit-resolution| @x826 (|unit-resolution| @x597 (|unit-resolution| @x1719 @x1025 @x1996 @x1998 $x436) $x594) $x667)))
(let ((@x1982 (|unit-resolution| (|unit-resolution| @x1376 @x1813 (or $x655 $x1373 $x1104 $x901 $x1260 $x1374)) @x1253 @x1370 @x898 @x1248 @x1371 $x1260)))
(let ((@x1984 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 1 -1 -1 1 1 -1 1 -2 2 -1 1 -1 1) $x1723) @x797 @x851 @x701 @x1136 @x1256 @x1813 @x685 @x1252 (or $x1611 $x955 $x1373 $x655 $x798 $x782 $x1374))))
(let ((@x1986 (|unit-resolution| @x1619 (|unit-resolution| @x1984 @x1253 @x1370 @x866 @x1207 @x999 @x1371 $x1611) $x757)))
(let ((@x1989 (|unit-resolution| @x1268 (|unit-resolution| @x589 (|unit-resolution| @x591 @x1986 $x461) $x586) @x1982 false)))
(let ((@x1991 (lemma @x1989 (or $x655 $x1374 $x901 $x1104 $x1373 $x782 $x798 $x955))))
(let ((@x2029 (|unit-resolution| @x1991 @x1385 @x2028 @x2002 @x2001 @x2027 @x1998 @x1996 $x655)))
(let ((@x2009 (|unit-resolution| @x789 (|unit-resolution| @x605 @x1993 $x602) $x774)))
(let ((@x2004 (|unit-resolution| @x1277 (|unit-resolution| @x1991 @x1370 @x898 @x2002 @x2001 @x866 @x1998 @x1996 $x655) @x1263 $x71)))
(let ((@x2010 (|unit-resolution| @x1166 @x2000 $x662)))
(let (($x731 (not $x659)))
(let (($x814 (not $x648)))
(let (($x2015 (or $x652 $x1585 $x732 $x814 $x764 $x901 $x1402 $x858 $x1593 $x815 $x816 $x900 $x1089 $x731 $x812 (not $x1367))))
(let ((@x2017 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1 1 1 -1 1 -1 1 -1 1 1 -1 -2 2 1) $x2015) (|unit-resolution| @x1411 @x1441 $x1367) @x810 @x833 @x855 @x728 @x713 @x1284 (|unit-resolution| @x1991 @x1370 @x898 @x2002 @x2001 @x866 @x1998 @x1996 $x655) @x2012 @x2010 @x2009 @x2008 @x898 @x1366 @x830 $x652)))
(let (($x2019 (or $x651 $x1591 $x1373 $x1625 $x708 $x782 $x742 $x1196 $x1197 $x798 $x799 $x1374 $x740 $x1139 $x1189 $x1437)))
(let ((@x2021 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -1 1 1 -1 1 -1 1 -1 1 1 -1 -2 2 1) $x2019) (|unit-resolution| @x1443 @x1441 $x1368) @x797 @x701 @x1125 @x1136 @x1256 @x1296 @x1263 @x1813 @x866 @x1998 @x1542 @x2001 @x1370 @x685 $x651)))
(let ((@x2022 (|unit-resolution| @x1304 @x2021 @x2017 (|unit-resolution| @x577 @x2004 $x564) false)))
(let ((@x2032 (|unit-resolution| (lemma @x2022 (or $x1409 $x708 $x782 $x1374 $x901)) @x2027 @x1263 @x1385 @x2028 $x1409)))
(let ((@x2035 (|unit-resolution| @x1291 (|unit-resolution| @x581 (|unit-resolution| @x583 @x2032 $x486) $x578) $x1236)))
(let ((@x2038 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 -2 -2 2 2 -2 2) (or $x1500 $x858 $x487 $x732 $x814 $x764 $x731 $x812)) @x2029 @x713 @x728 @x2012 @x2010 @x2008 (|unit-resolution| @x583 @x2032 $x486) $x1500)))
(let ((@x2040 (|unit-resolution| ((_ |th-lemma| arith assign-bounds -1 1 -1 -1 1 -1 1 1 -1 -1 1 -1 1) $x1756) @x810 @x833 @x855 @x1256 @x1366 @x830 @x1284 (or $x652 $x901 $x1584 $x815 $x1592 $x1373 $x708))))
(let ((@x2042 (|unit-resolution| @x1304 (|unit-resolution| @x2040 @x2038 @x2035 @x1263 @x2009 @x2028 @x2001 $x652) (|unit-resolution| @x577 (|unit-resolution| @x1277 @x2029 @x1263 $x71) $x564) $x1301)))
(let ((@x2043 (|unit-resolution| @x1298 (|unit-resolution| @x581 (|unit-resolution| @x583 @x2032 $x486) $x578) $x1237)))
(let ((@x2044 ((_ |th-lemma| arith farkas 1/2 -1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 -1/2 1/2 1/2 -1/2 1) @x2010 @x713 @x2029 @x2043 @x1296 @x2042 @x2027 @x685 @x1542 @x1125 @x1998 @x797 @x1385 @x701 @x2006 false)))
(let ((@x2055 (|unit-resolution| @x621 (|unit-resolution| (lemma @x2044 (or $x361 $x708)) @x1263 $x361) $x618)))
(let ((@x1979 (lemma (|unit-resolution| @x924 (hypothesis $x618) (hypothesis $x705) false) (or (not $x618) $x668))))
(let ((@x2056 (|unit-resolution| @x1979 @x2055 $x668)))
(let ((@x2059 (|unit-resolution| @x1991 (|unit-resolution| @x826 (|unit-resolution| @x597 @x2050 $x594) $x667) (|unit-resolution| @x1958 @x2050 @x2009 @x2056 @x2053 $x1354) @x2002 @x2001 (|unit-resolution| @x691 (|unit-resolution| @x597 @x2050 $x594) $x676) @x1998 @x1996 $x655)))
(let ((@x2061 (|unit-resolution| (|unit-resolution| @x1669 @x1813 (or $x486 $x705 $x704 $x1373 $x708 $x412)) @x2056 @x1263 @x2001 @x2053 @x1993 $x486)))
(let ((@x2063 (|unit-resolution| @x589 (|unit-resolution| @x707 @x2050 @x2053 @x2006 @x2056 $x461) $x586)))
(let ((@x2065 (|unit-resolution| @x1465 (|unit-resolution| @x1268 @x2063 $x670) @x2009 @x2012 @x2002 @x2061 @x2008 (|unit-resolution| @x826 (|unit-resolution| @x597 @x2050 $x594) $x667) $x652)))
(let ((@x2071 (|unit-resolution| @x1323 (|unit-resolution| @x1268 @x2063 $x670) @x1992 @x2008 @x2053 (|unit-resolution| @x1298 (|unit-resolution| @x581 @x2061 $x578) $x1237) (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x931 $x412 $x798)) @x1998 @x1993 $x931) @x2056 $x651)))
(let ((@x2073 (|unit-resolution| @x577 (|unit-resolution| @x1304 @x2071 @x2065 $x70) (|unit-resolution| @x1277 @x2059 @x1263 $x71) false)))
(let ((@x2074 (lemma @x2073 $x708)))
(let ((@x1771 (|unit-resolution| @x621 (|unit-resolution| @x1526 (|unit-resolution| @x1235 @x709 $x287) @x1024 $x361) $x618)))
(let ((@x1772 (|unit-resolution| @x924 @x1771 $x668)))
(let ((@x1773 (|unit-resolution| @x1768 @x1185 @x1024 $x336)))
(let ((@x1769 (|unit-resolution| @x1235 @x709 $x287)))
(let ((@x1776 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -1 1 -1 -1 1 -1 1) (or $x437 $x815 $x816 $x704 $x741 $x1196 $x337 $x286 $x1197)) @x1769 @x696 @x1773 @x1125 @x810 @x1734 @x1477 @x1542 $x437)))
(let ((@x1782 (|unit-resolution| @x1566 (|unit-resolution| @x1556 (|unit-resolution| @x639 @x1769 $x635) $x1499) @x701 @x1185 @x1136 @x1769 @x1734 @x1772 @x696 $x311)))
(let ((@x1790 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 1) (or $x658 $x286 $x1564)) (|unit-resolution| @x1556 (|unit-resolution| @x639 @x1769 $x635) $x1499) @x1769 $x658)))
(let ((@x1793 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 2 4 4 2 2 1 2 2 2 2 2) $x1791) (|unit-resolution| @x738 (|unit-resolution| @x599 @x1776 $x595) $x673) @x810 @x696 @x701 @x1125 @x1790 @x1734 @x1772 (|unit-resolution| @x1572 (|unit-resolution| @x639 @x1769 $x635) $x1543) @x1477 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 -2) (or $x873 $x1196 $x337)) @x1773 @x1542 $x873) @x685 $x461)))
(let ((@x1796 ((_ |th-lemma| arith farkas 4 -1 3 -3 -1 1 1 -1 -1 1 -1 2 -2 -2 2 -1 1 1) @x1773 @x701 @x1734 @x696 (|unit-resolution| @x723 (|unit-resolution| @x589 @x1793 $x586) $x679) @x718 (|unit-resolution| @x1166 (|unit-resolution| @x645 @x1782 $x642) $x662) @x713 @x709 (|unit-resolution| @x1572 (|unit-resolution| @x639 @x1769 $x635) $x1543) @x728 @x1477 @x810 @x1542 @x1125 (|unit-resolution| @x738 (|unit-resolution| @x599 @x1776 $x595) $x673) @x685 @x1772 false)))
(let ((@x2081 (|unit-resolution| (lemma @x1796 (or $x656 $x412 $x387)) @x1815 @x1185 @x2074 false)))
(let ((@x2082 (lemma @x2081 $x412)))
(let ((@x2100 (|unit-resolution| @x863 (|unit-resolution| @x621 (|unit-resolution| @x1064 @x2082 $x361) $x618) $x838)))
(let ((@x2117 (|unit-resolution| @x1572 (|unit-resolution| @x639 (|unit-resolution| @x1235 @x2074 $x287) $x635) $x1543)))
(let ((@x2101 (|unit-resolution| (|unit-resolution| @x1429 @x1542 (or $x286 $x386 $x1090)) @x2100 (|unit-resolution| @x1235 @x2074 $x287) $x386)))
(let ((@x2090 (|unit-resolution| @x1556 (|unit-resolution| @x639 (|unit-resolution| @x1235 @x2074 $x287) $x635) $x1499)))
(let ((@x2078 (|unit-resolution| @x997 @x994 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 2) (or $x815 $x1000 $x411)) @x842 @x897 $x1000) false)))
(let ((@x2097 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x774 $x773)) (|unit-resolution| (lemma @x2078 (or $x411 $x815)) @x2082 $x815) $x773)))
(let ((@x2104 (|unit-resolution| @x1874 (|unit-resolution| @x948 (|unit-resolution| @x613 @x2101 $x610) $x934) @x2100 @x2097 (|unit-resolution| @x1037 (|unit-resolution| @x607 @x2082 $x603) $x1022) $x336)))
(let ((@x2107 (|unit-resolution| @x1979 (|unit-resolution| @x621 (|unit-resolution| @x1064 @x2082 $x361) $x618) $x668)))
(let ((@x2109 (|unit-resolution| @x1881 @x1188 @x696 @x701 @x855 @x1136 @x797 (|unit-resolution| @x806 (|unit-resolution| @x613 @x2101 $x610) $x671) @x2107 (|unit-resolution| @x1115 (|unit-resolution| @x629 @x2104 $x626) $x665) (|unit-resolution| @x997 (|unit-resolution| @x607 @x2082 $x603) $x931) @x2090 $x436)))
(let ((@x2114 (|unit-resolution| @x723 (|unit-resolution| @x589 (|unit-resolution| @x1098 @x2082 $x461) $x586) $x679)))
(let ((@x2115 ((_ |th-lemma| arith farkas 1 1 -1 -1 1 -1 -1 1 -1 -1 1 -1 1) @x1136 (|unit-resolution| @x806 (|unit-resolution| @x613 @x2101 $x610) $x671) @x696 @x2090 @x2107 @x701 @x2114 @x718 @x713 @x2074 @x685 (|unit-resolution| @x691 (|unit-resolution| @x597 @x2109 $x594) $x676) (|unit-resolution| @x1159 (|unit-resolution| @x647 @x1188 $x643) $x1103) false)))
(let ((@x2119 (|unit-resolution| @x1166 (|unit-resolution| @x645 (lemma @x2115 $x311) $x642) $x662)))
(let ((@x2120 ((_ |th-lemma| arith farkas 1 -1 1 -1 1 1 -1 -1 3 -3 2 -2 2 -2 1 -1 1) @x2114 @x718 @x728 @x2119 @x713 (|unit-resolution| @x948 (|unit-resolution| @x613 @x2101 $x610) $x934) @x851 @x2117 @x2100 @x833 @x1542 @x1125 @x810 (|unit-resolution| @x1037 (|unit-resolution| @x607 @x2082 $x603) $x1022) @x1609 @x685 @x2074 false)))
(let ((@x2121 (lemma @x2120 $x743)))
(let (($x736 (not $x595)))
(let ((@x2125 (|unit-resolution| @x599 (lemma (|unit-resolution| @x738 (hypothesis $x595) @x2121 false) $x736) $x436)))
(|unit-resolution| @x691 (|unit-resolution| @x597 @x2125 $x594) (|unit-resolution| ((_ |th-lemma| arith assign-bounds 2 -1) (or $x673 $x437 $x782)) @x2125 @x2121 $x782) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

8778062e40723924421e3a1f0c912b62e43b9b81 20 0
unsat
((set-logic AUFLIRA)
(proof
(let ((?x8 (* 2.0 |x$|)))
(let ((?x10 (+ ?x8 1.0)))
(let ((?x6 (+ |x$| |x$|)))
(let (($x11 (< ?x6 ?x10)))
(let (($x12 (or false $x11)))
(let (($x13 (or $x11 $x12)))
(let (($x14 (not $x13)))
(let ((@x65 (monotonicity (rewrite (= (< ?x8 (+ 1.0 ?x8)) true)) (= (not (< ?x8 (+ 1.0 ?x8))) (not true)))))
(let ((@x69 (trans @x65 (rewrite (= (not true) false)) (= (not (< ?x8 (+ 1.0 ?x8))) false))))
(let ((?x38 (+ 1.0 ?x8)))
(let (($x41 (< ?x8 ?x38)))
(let ((@x43 (monotonicity (rewrite (= ?x6 ?x8)) (rewrite (= ?x10 ?x38)) (= $x11 $x41))))
(let ((@x50 (trans (monotonicity @x43 (= $x12 (or false $x41))) (rewrite (= (or false $x41) $x41)) (= $x12 $x41))))
(let ((@x57 (trans (monotonicity @x43 @x50 (= $x13 (or $x41 $x41))) (rewrite (= (or $x41 $x41) $x41)) (= $x13 $x41))))
(let ((@x60 (monotonicity @x57 (= $x14 (not $x41)))))
(mp (asserted $x14) (trans @x60 @x69 (= $x14 false)) false))))))))))))))))))

bbf5431bd7e9448dc98de52e9b465f05ca123636 113 0
unsat
((set-logic <null>)
(proof
(let ((?x215 (mod |x$| 2)))
(let ((?x249 (* (~ 1) ?x215)))
(let ((?x9 (|mod$| |x$| 2)))
(let ((?x250 (+ ?x9 ?x249)))
(let (($x267 (>= ?x250 0)))
(let (($x251 (= ?x250 0)))
(let (($x203 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x30 (mod ?v0 ?v1)))
(let ((?x99 (* (~ 1) ?v1)))
(let ((?x96 (* (~ 1) ?v0)))
(let ((?x142 (mod ?x96 ?x99)))
(let ((?x148 (* (~ 1) ?x142)))
(let (($x117 (<= ?v1 0)))
(let ((?x168 (ite $x117 ?x148 ?x30)))
(let (($x19 (= ?v1 0)))
(let ((?x173 (ite $x19 ?v0 ?x168)))
(let ((?x29 (|mod$| ?v0 ?v1)))
(= ?x29 ?x173))))))))))) :pattern ( (|mod$| ?v0 ?v1) )))
))
(let (($x179 (forall ((?v0 Int) (?v1 Int) )(let ((?x30 (mod ?v0 ?v1)))
(let ((?x99 (* (~ 1) ?v1)))
(let ((?x96 (* (~ 1) ?v0)))
(let ((?x142 (mod ?x96 ?x99)))
(let ((?x148 (* (~ 1) ?x142)))
(let (($x117 (<= ?v1 0)))
(let ((?x168 (ite $x117 ?x148 ?x30)))
(let (($x19 (= ?v1 0)))
(let ((?x173 (ite $x19 ?v0 ?x168)))
(let ((?x29 (|mod$| ?v0 ?v1)))
(= ?x29 ?x173))))))))))))
))
(let ((?x30 (mod ?1 ?0)))
(let ((?x99 (* (~ 1) ?0)))
(let ((?x96 (* (~ 1) ?1)))
(let ((?x142 (mod ?x96 ?x99)))
(let ((?x148 (* (~ 1) ?x142)))
(let (($x117 (<= ?0 0)))
(let ((?x168 (ite $x117 ?x148 ?x30)))
(let (($x19 (= ?0 0)))
(let ((?x173 (ite $x19 ?1 ?x168)))
(let ((?x29 (|mod$| ?1 ?0)))
(let (($x176 (= ?x29 ?x173)))
(let (($x36 (forall ((?v0 Int) (?v1 Int) )(let (($x19 (= ?v1 0)))
(let ((?x34 (ite $x19 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
(let ((?x29 (|mod$| ?v0 ?v1)))
(= ?x29 ?x34)))))
))
(let (($x162 (forall ((?v0 Int) (?v1 Int) )(let ((?x99 (* (~ 1) ?v1)))
(let ((?x96 (* (~ 1) ?v0)))
(let ((?x142 (mod ?x96 ?x99)))
(let ((?x148 (* (~ 1) ?x142)))
(let ((?x30 (mod ?v0 ?v1)))
(let (($x20 (< 0 ?v1)))
(let ((?x153 (ite $x20 ?x30 ?x148)))
(let (($x19 (= ?v1 0)))
(let ((?x156 (ite $x19 ?v0 ?x153)))
(let ((?x29 (|mod$| ?v0 ?v1)))
(= ?x29 ?x156))))))))))))
))
(let ((@x167 (monotonicity (rewrite (= (< 0 ?0) (not $x117))) (= (ite (< 0 ?0) ?x30 ?x148) (ite (not $x117) ?x30 ?x148)))))
(let ((@x172 (trans @x167 (rewrite (= (ite (not $x117) ?x30 ?x148) ?x168)) (= (ite (< 0 ?0) ?x30 ?x148) ?x168))))
(let ((@x175 (monotonicity @x172 (= (ite $x19 ?1 (ite (< 0 ?0) ?x30 ?x148)) ?x173))))
(let ((@x178 (monotonicity @x175 (= (= ?x29 (ite $x19 ?1 (ite (< 0 ?0) ?x30 ?x148))) $x176))))
(let (($x20 (< 0 ?0)))
(let ((?x153 (ite $x20 ?x30 ?x148)))
(let ((?x156 (ite $x19 ?1 ?x153)))
(let (($x159 (= ?x29 ?x156)))
(let (($x160 (= (= ?x29 (ite $x19 ?1 (ite $x20 ?x30 (- (mod (- ?1) (- ?0)))))) $x159)))
(let ((@x144 (monotonicity (rewrite (= (- ?1) ?x96)) (rewrite (= (- ?0) ?x99)) (= (mod (- ?1) (- ?0)) ?x142))))
(let ((@x152 (trans (monotonicity @x144 (= (- (mod (- ?1) (- ?0))) (- ?x142))) (rewrite (= (- ?x142) ?x148)) (= (- (mod (- ?1) (- ?0))) ?x148))))
(let ((@x155 (monotonicity @x152 (= (ite $x20 ?x30 (- (mod (- ?1) (- ?0)))) ?x153))))
(let ((@x158 (monotonicity @x155 (= (ite $x19 ?1 (ite $x20 ?x30 (- (mod (- ?1) (- ?0))))) ?x156))))
(let ((@x183 (trans (|quant-intro| (monotonicity @x158 $x160) (= $x36 $x162)) (|quant-intro| @x178 (= $x162 $x179)) (= $x36 $x179))))
(let ((@x194 (|mp~| (mp (asserted $x36) @x183 $x179) (|nnf-pos| (refl (|~| $x176 $x176)) (|~| $x179 $x179)) $x179)))
(let ((@x208 (mp @x194 (|quant-intro| (refl (= $x176 $x176)) (= $x179 $x203)) $x203)))
(let (($x257 (or (not $x203) $x251)))
(let ((?x212 (* (~ 1) 2)))
(let ((?x211 (* (~ 1) |x$|)))
(let ((?x213 (mod ?x211 ?x212)))
(let ((?x214 (* (~ 1) ?x213)))
(let (($x210 (<= 2 0)))
(let ((?x216 (ite $x210 ?x214 ?x215)))
(let (($x209 (= 2 0)))
(let ((?x217 (ite $x209 |x$| ?x216)))
(let (($x218 (= ?x9 ?x217)))
(let ((@x231 (monotonicity (monotonicity (rewrite (= ?x212 (~ 2))) (= ?x213 (mod ?x211 (~ 2)))) (= ?x214 (* (~ 1) (mod ?x211 (~ 2)))))))
(let ((@x234 (monotonicity (rewrite (= $x210 false)) @x231 (= ?x216 (ite false (* (~ 1) (mod ?x211 (~ 2))) ?x215)))))
(let ((@x238 (trans @x234 (rewrite (= (ite false (* (~ 1) (mod ?x211 (~ 2))) ?x215) ?x215)) (= ?x216 ?x215))))
(let ((@x241 (monotonicity (rewrite (= $x209 false)) @x238 (= ?x217 (ite false |x$| ?x215)))))
(let ((@x248 (monotonicity (trans @x241 (rewrite (= (ite false |x$| ?x215) ?x215)) (= ?x217 ?x215)) (= $x218 (= ?x9 ?x215)))))
(let ((@x261 (monotonicity (trans @x248 (rewrite (= (= ?x9 ?x215) $x251)) (= $x218 $x251)) (= (or (not $x203) $x218) $x257))))
(let ((@x264 (trans @x261 (rewrite (= $x257 $x257)) (= (or (not $x203) $x218) $x257))))
(let ((@x265 (mp ((_ |quant-inst| |x$| 2) (or (not $x203) $x218)) @x264 $x257)))
(let ((@x324 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x251) $x267)) (|unit-resolution| @x265 @x208 $x251) $x267)))
(let (($x292 (>= ?x215 0)))
(let (($x83 (>= ?x9 0)))
(let (($x86 (not $x83)))
(let (($x14 (not (<= (+ |x$| 1) (+ |x$| (+ (* 2 ?x9) 1))))))
(let ((@x88 (monotonicity (rewrite (= (>= (* 2 ?x9) 0) $x83)) (= (not (>= (* 2 ?x9) 0)) $x86))))
(let ((?x10 (* 2 ?x9)))
(let ((?x66 (+ 1 |x$| ?x10)))
(let (($x71 (<= (+ 1 |x$|) ?x66)))
(let (($x74 (not $x71)))
(let ((@x82 (monotonicity (rewrite (= $x71 (>= ?x10 0))) (= $x74 (not (>= ?x10 0))))))
(let ((@x65 (monotonicity (rewrite (= (+ ?x10 1) (+ 1 ?x10))) (= (+ |x$| (+ ?x10 1)) (+ |x$| (+ 1 ?x10))))))
(let ((@x70 (trans @x65 (rewrite (= (+ |x$| (+ 1 ?x10)) ?x66)) (= (+ |x$| (+ ?x10 1)) ?x66))))
(let ((@x73 (monotonicity (rewrite (= (+ |x$| 1) (+ 1 |x$|))) @x70 (= (<= (+ |x$| 1) (+ |x$| (+ ?x10 1))) $x71))))
(let ((@x92 (trans (monotonicity @x73 (= $x14 $x74)) (trans @x82 @x88 (= $x74 $x86)) (= $x14 $x86))))
(let ((@x93 (mp (asserted $x14) @x92 $x86)))
((_ |th-lemma| arith farkas -1 1 1) @x93 (|unit-resolution| ((_ |th-lemma| arith) (or false $x292)) (|true-axiom| true) $x292) @x324 false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

b5183bee77d63a5b887fd6f1c6035b47d90e65cb 112 0
unsat
((set-logic <null>)
(proof
(let ((?x211 (mod |x$| 2)))
(let (($x305 (>= ?x211 2)))
(let (($x306 (not $x305)))
(let ((?x245 (* (~ 1) ?x211)))
(let ((?x7 (|mod$| |x$| 2)))
(let ((?x246 (+ ?x7 ?x245)))
(let (($x262 (<= ?x246 0)))
(let (($x247 (= ?x246 0)))
(let (($x199 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x29 (mod ?v0 ?v1)))
(let ((?x95 (* (~ 1) ?v1)))
(let ((?x92 (* (~ 1) ?v0)))
(let ((?x138 (mod ?x92 ?x95)))
(let ((?x144 (* (~ 1) ?x138)))
(let (($x113 (<= ?v1 0)))
(let ((?x164 (ite $x113 ?x144 ?x29)))
(let (($x18 (= ?v1 0)))
(let ((?x169 (ite $x18 ?v0 ?x164)))
(let ((?x28 (|mod$| ?v0 ?v1)))
(= ?x28 ?x169))))))))))) :pattern ( (|mod$| ?v0 ?v1) )))
))
(let (($x175 (forall ((?v0 Int) (?v1 Int) )(let ((?x29 (mod ?v0 ?v1)))
(let ((?x95 (* (~ 1) ?v1)))
(let ((?x92 (* (~ 1) ?v0)))
(let ((?x138 (mod ?x92 ?x95)))
(let ((?x144 (* (~ 1) ?x138)))
(let (($x113 (<= ?v1 0)))
(let ((?x164 (ite $x113 ?x144 ?x29)))
(let (($x18 (= ?v1 0)))
(let ((?x169 (ite $x18 ?v0 ?x164)))
(let ((?x28 (|mod$| ?v0 ?v1)))
(= ?x28 ?x169))))))))))))
))
(let ((?x29 (mod ?1 ?0)))
(let ((?x95 (* (~ 1) ?0)))
(let ((?x92 (* (~ 1) ?1)))
(let ((?x138 (mod ?x92 ?x95)))
(let ((?x144 (* (~ 1) ?x138)))
(let (($x113 (<= ?0 0)))
(let ((?x164 (ite $x113 ?x144 ?x29)))
(let (($x18 (= ?0 0)))
(let ((?x169 (ite $x18 ?1 ?x164)))
(let ((?x28 (|mod$| ?1 ?0)))
(let (($x172 (= ?x28 ?x169)))
(let (($x35 (forall ((?v0 Int) (?v1 Int) )(let (($x18 (= ?v1 0)))
(let ((?x33 (ite $x18 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
(let ((?x28 (|mod$| ?v0 ?v1)))
(= ?x28 ?x33)))))
))
(let (($x158 (forall ((?v0 Int) (?v1 Int) )(let ((?x95 (* (~ 1) ?v1)))
(let ((?x92 (* (~ 1) ?v0)))
(let ((?x138 (mod ?x92 ?x95)))
(let ((?x144 (* (~ 1) ?x138)))
(let ((?x29 (mod ?v0 ?v1)))
(let (($x19 (< 0 ?v1)))
(let ((?x149 (ite $x19 ?x29 ?x144)))
(let (($x18 (= ?v1 0)))
(let ((?x152 (ite $x18 ?v0 ?x149)))
(let ((?x28 (|mod$| ?v0 ?v1)))
(= ?x28 ?x152))))))))))))
))
(let ((@x163 (monotonicity (rewrite (= (< 0 ?0) (not $x113))) (= (ite (< 0 ?0) ?x29 ?x144) (ite (not $x113) ?x29 ?x144)))))
(let ((@x168 (trans @x163 (rewrite (= (ite (not $x113) ?x29 ?x144) ?x164)) (= (ite (< 0 ?0) ?x29 ?x144) ?x164))))
(let ((@x171 (monotonicity @x168 (= (ite $x18 ?1 (ite (< 0 ?0) ?x29 ?x144)) ?x169))))
(let ((@x174 (monotonicity @x171 (= (= ?x28 (ite $x18 ?1 (ite (< 0 ?0) ?x29 ?x144))) $x172))))
(let (($x19 (< 0 ?0)))
(let ((?x149 (ite $x19 ?x29 ?x144)))
(let ((?x152 (ite $x18 ?1 ?x149)))
(let (($x155 (= ?x28 ?x152)))
(let (($x156 (= (= ?x28 (ite $x18 ?1 (ite $x19 ?x29 (- (mod (- ?1) (- ?0)))))) $x155)))
(let ((@x140 (monotonicity (rewrite (= (- ?1) ?x92)) (rewrite (= (- ?0) ?x95)) (= (mod (- ?1) (- ?0)) ?x138))))
(let ((@x148 (trans (monotonicity @x140 (= (- (mod (- ?1) (- ?0))) (- ?x138))) (rewrite (= (- ?x138) ?x144)) (= (- (mod (- ?1) (- ?0))) ?x144))))
(let ((@x151 (monotonicity @x148 (= (ite $x19 ?x29 (- (mod (- ?1) (- ?0)))) ?x149))))
(let ((@x154 (monotonicity @x151 (= (ite $x18 ?1 (ite $x19 ?x29 (- (mod (- ?1) (- ?0))))) ?x152))))
(let ((@x179 (trans (|quant-intro| (monotonicity @x154 $x156) (= $x35 $x158)) (|quant-intro| @x174 (= $x158 $x175)) (= $x35 $x175))))
(let ((@x190 (|mp~| (mp (asserted $x35) @x179 $x175) (|nnf-pos| (refl (|~| $x172 $x172)) (|~| $x175 $x175)) $x175)))
(let ((@x204 (mp @x190 (|quant-intro| (refl (= $x172 $x172)) (= $x175 $x199)) $x199)))
(let (($x253 (or (not $x199) $x247)))
(let ((?x208 (* (~ 1) 2)))
(let ((?x207 (* (~ 1) |x$|)))
(let ((?x209 (mod ?x207 ?x208)))
(let ((?x210 (* (~ 1) ?x209)))
(let (($x206 (<= 2 0)))
(let ((?x212 (ite $x206 ?x210 ?x211)))
(let (($x205 (= 2 0)))
(let ((?x213 (ite $x205 |x$| ?x212)))
(let (($x214 (= ?x7 ?x213)))
(let ((@x227 (monotonicity (monotonicity (rewrite (= ?x208 (~ 2))) (= ?x209 (mod ?x207 (~ 2)))) (= ?x210 (* (~ 1) (mod ?x207 (~ 2)))))))
(let ((@x230 (monotonicity (rewrite (= $x206 false)) @x227 (= ?x212 (ite false (* (~ 1) (mod ?x207 (~ 2))) ?x211)))))
(let ((@x234 (trans @x230 (rewrite (= (ite false (* (~ 1) (mod ?x207 (~ 2))) ?x211) ?x211)) (= ?x212 ?x211))))
(let ((@x237 (monotonicity (rewrite (= $x205 false)) @x234 (= ?x213 (ite false |x$| ?x211)))))
(let ((@x244 (monotonicity (trans @x237 (rewrite (= (ite false |x$| ?x211) ?x211)) (= ?x213 ?x211)) (= $x214 (= ?x7 ?x211)))))
(let ((@x257 (monotonicity (trans @x244 (rewrite (= (= ?x7 ?x211) $x247)) (= $x214 $x247)) (= (or (not $x199) $x214) $x253))))
(let ((@x260 (trans @x257 (rewrite (= $x253 $x253)) (= (or (not $x199) $x214) $x253))))
(let ((@x261 (mp ((_ |quant-inst| |x$| 2) (or (not $x199) $x214)) @x260 $x253)))
(let ((@x323 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x247) $x262)) (|unit-resolution| @x261 @x204 $x247) $x262)))
(let (($x82 (>= ?x7 2)))
(let ((?x56 (* 2 ?x7)))
(let (($x75 (>= ?x56 3)))
(let (($x65 (< (+ |x$| ?x56) (+ 3 |x$|))))
(let (($x68 (not $x65)))
(let ((@x77 (monotonicity (rewrite (= $x65 (not $x75))) (= $x68 (not (not $x75))))))
(let ((@x86 (trans (trans @x77 (rewrite (= (not (not $x75)) $x75)) (= $x68 $x75)) (rewrite (= $x75 $x82)) (= $x68 $x82))))
(let ((@x61 (monotonicity (rewrite (= (+ ?x7 ?x7) ?x56)) (= (+ |x$| (+ ?x7 ?x7)) (+ |x$| ?x56)))))
(let ((@x67 (monotonicity @x61 (rewrite (= (+ |x$| 3) (+ 3 |x$|))) (= (< (+ |x$| (+ ?x7 ?x7)) (+ |x$| 3)) $x65))))
(let ((@x70 (monotonicity @x67 (= (not (< (+ |x$| (+ ?x7 ?x7)) (+ |x$| 3))) $x68))))
(let ((@x88 (trans @x70 @x86 (= (not (< (+ |x$| (+ ?x7 ?x7)) (+ |x$| 3))) $x82))))
(let ((@x89 (mp (asserted (not (< (+ |x$| (+ ?x7 ?x7)) (+ |x$| 3)))) @x88 $x82)))
((_ |th-lemma| arith farkas -1 1 1) @x89 @x323 (|unit-resolution| ((_ |th-lemma| arith) (or false $x306)) (|true-axiom| true) $x306) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

fb75370f1b646783db5a9a683587f9b2b11bd686 32 0
unsat
((set-logic <null>)
(proof
(let (($x7 (= |x$| 0.0)))
(let (($x8 (not $x7)))
(let ((@x43 (asserted $x8)))
(let (($x99 (<= |x$| 0.0)))
(let ((?x45 (* 2.0 |x$|)))
(let (($x97 (<= ?x45 0.0)))
(let (($x93 (= ?x45 0.0)))
(let (($x14 (< 1.0 (ite (< |x$| 0.0) (- |x$|) |x$|))))
(let (($x16 (or $x14 (not $x14))))
(let ((?x19 (ite $x16 4.0 2.0)))
(let (($x23 (not (not (= (+ |x$| |x$|) (* ?x19 |x$|))))))
(let ((@x88 (rewrite (= (not (not (= ?x45 (* 4.0 |x$|)))) (= ?x45 (* 4.0 |x$|))))))
(let (($x82 (= (not (= (+ |x$| |x$|) (* ?x19 |x$|))) (not (= ?x45 (* 4.0 |x$|))))))
(let (($x55 (< 1.0 (ite (< |x$| 0.0) (* (~ 1.0) |x$|) |x$|))))
(let (($x53 (= (ite (< |x$| 0.0) (- |x$|) |x$|) (ite (< |x$| 0.0) (* (~ 1.0) |x$|) |x$|))))
(let ((@x57 (monotonicity (monotonicity (rewrite (= (- |x$|) (* (~ 1.0) |x$|))) $x53) (= $x14 $x55))))
(let ((@x63 (monotonicity @x57 (monotonicity @x57 (= (not $x14) (not $x55))) (= $x16 (or $x55 (not $x55))))))
(let ((@x67 (trans @x63 (rewrite (= (or $x55 (not $x55)) true)) (= $x16 true))))
(let ((@x74 (trans (monotonicity @x67 (= ?x19 (ite true 4.0 2.0))) (rewrite (= (ite true 4.0 2.0) 4.0)) (= ?x19 4.0))))
(let ((@x80 (monotonicity (rewrite (= (+ |x$| |x$|) ?x45)) (monotonicity @x74 (= (* ?x19 |x$|) (* 4.0 |x$|))) (= (= (+ |x$| |x$|) (* ?x19 |x$|)) (= ?x45 (* 4.0 |x$|))))))
(let ((@x86 (monotonicity (monotonicity @x80 $x82) (= $x23 (not (not (= ?x45 (* 4.0 |x$|))))))))
(let ((@x95 (trans (trans @x86 @x88 (= $x23 (= ?x45 (* 4.0 |x$|)))) (rewrite (= (= ?x45 (* 4.0 |x$|)) $x93)) (= $x23 $x93))))
(let ((@x96 (mp (asserted $x23) @x95 $x93)))
(let ((@x108 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1) (or $x99 (not $x97))) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x93) $x97)) @x96 $x97) $x99)))
(let (($x100 (>= |x$| 0.0)))
(let (($x98 (>= ?x45 0.0)))
(let ((@x115 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1) (or $x100 (not $x98))) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x93) $x98)) @x96 $x98) $x100)))
(|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x7 (not $x99) (not $x100))) @x115 @x108 @x43 false))))))))))))))))))))))))))))))

bba1efa8562001b979c24cfd840c5185f0dad8b2 242 0
unsat
((set-logic <null>)
(proof
(let ((?x471 (div |m$| 2)))
(let ((?x531 (* (~ 1) ?x471)))
(let ((?x426 (mod |m$| 2)))
(let ((?x453 (* (~ 1) ?x426)))
(let ((?x368 (div |n$| 4)))
(let ((?x541 (* (~ 2) ?x368)))
(let ((?x316 (mod |n$| 4)))
(let ((?x350 (* (~ 1) ?x316)))
(let ((?x7 (+ |n$| |m$|)))
(let ((?x259 (div ?x7 2)))
(let ((?x540 (* (~ 1) ?x259)))
(let ((?x201 (mod ?x7 2)))
(let ((?x240 (* (~ 1) ?x201)))
(let ((?x13 (|mod$| |n$| 4)))
(let ((?x9 (|mod$| ?x7 2)))
(let ((?x534 (+ |n$| |m$| ?x9 ?x13 ?x240 ?x540 ?x350 ?x541 ?x453 ?x531)))
(let (($x535 (>= ?x534 2)))
(let (($x492 (>= ?x426 0)))
(let ((@x62 (|true-axiom| true)))
(let ((?x484 (* (~ 2) ?x471)))
(let ((?x485 (+ |m$| ?x453 ?x484)))
(let (($x490 (<= ?x485 0)))
(let (($x483 (= ?x485 0)))
(let ((@x379 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x483) $x490)) (|unit-resolution| ((_ |th-lemma| arith) (or false $x483)) @x62 $x483) $x490)))
(let ((?x351 (+ ?x13 ?x350)))
(let (($x366 (<= ?x351 0)))
(let (($x352 (= ?x351 0)))
(let (($x189 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x37 (mod ?v0 ?v1)))
(let ((?x71 (* (~ 1) ?v1)))
(let ((?x68 (* (~ 1) ?v0)))
(let ((?x114 (mod ?x68 ?x71)))
(let ((?x120 (* (~ 1) ?x114)))
(let (($x89 (<= ?v1 0)))
(let ((?x140 (ite $x89 ?x120 ?x37)))
(let (($x26 (= ?v1 0)))
(let ((?x145 (ite $x26 ?v0 ?x140)))
(let ((?x36 (|mod$| ?v0 ?v1)))
(= ?x36 ?x145))))))))))) :pattern ( (|mod$| ?v0 ?v1) )))
))
(let (($x151 (forall ((?v0 Int) (?v1 Int) )(let ((?x37 (mod ?v0 ?v1)))
(let ((?x71 (* (~ 1) ?v1)))
(let ((?x68 (* (~ 1) ?v0)))
(let ((?x114 (mod ?x68 ?x71)))
(let ((?x120 (* (~ 1) ?x114)))
(let (($x89 (<= ?v1 0)))
(let ((?x140 (ite $x89 ?x120 ?x37)))
(let (($x26 (= ?v1 0)))
(let ((?x145 (ite $x26 ?v0 ?x140)))
(let ((?x36 (|mod$| ?v0 ?v1)))
(= ?x36 ?x145))))))))))))
))
(let ((?x37 (mod ?1 ?0)))
(let ((?x71 (* (~ 1) ?0)))
(let ((?x68 (* (~ 1) ?1)))
(let ((?x114 (mod ?x68 ?x71)))
(let ((?x120 (* (~ 1) ?x114)))
(let (($x89 (<= ?0 0)))
(let ((?x140 (ite $x89 ?x120 ?x37)))
(let (($x26 (= ?0 0)))
(let ((?x145 (ite $x26 ?1 ?x140)))
(let ((?x36 (|mod$| ?1 ?0)))
(let (($x148 (= ?x36 ?x145)))
(let (($x43 (forall ((?v0 Int) (?v1 Int) )(let (($x26 (= ?v1 0)))
(let ((?x41 (ite $x26 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
(let ((?x36 (|mod$| ?v0 ?v1)))
(= ?x36 ?x41)))))
))
(let (($x134 (forall ((?v0 Int) (?v1 Int) )(let ((?x71 (* (~ 1) ?v1)))
(let ((?x68 (* (~ 1) ?v0)))
(let ((?x114 (mod ?x68 ?x71)))
(let ((?x120 (* (~ 1) ?x114)))
(let ((?x37 (mod ?v0 ?v1)))
(let (($x27 (< 0 ?v1)))
(let ((?x125 (ite $x27 ?x37 ?x120)))
(let (($x26 (= ?v1 0)))
(let ((?x128 (ite $x26 ?v0 ?x125)))
(let ((?x36 (|mod$| ?v0 ?v1)))
(= ?x36 ?x128))))))))))))
))
(let ((@x139 (monotonicity (rewrite (= (< 0 ?0) (not $x89))) (= (ite (< 0 ?0) ?x37 ?x120) (ite (not $x89) ?x37 ?x120)))))
(let ((@x144 (trans @x139 (rewrite (= (ite (not $x89) ?x37 ?x120) ?x140)) (= (ite (< 0 ?0) ?x37 ?x120) ?x140))))
(let ((@x147 (monotonicity @x144 (= (ite $x26 ?1 (ite (< 0 ?0) ?x37 ?x120)) ?x145))))
(let ((@x150 (monotonicity @x147 (= (= ?x36 (ite $x26 ?1 (ite (< 0 ?0) ?x37 ?x120))) $x148))))
(let (($x27 (< 0 ?0)))
(let ((?x125 (ite $x27 ?x37 ?x120)))
(let ((?x128 (ite $x26 ?1 ?x125)))
(let (($x131 (= ?x36 ?x128)))
(let (($x132 (= (= ?x36 (ite $x26 ?1 (ite $x27 ?x37 (- (mod (- ?1) (- ?0)))))) $x131)))
(let ((@x116 (monotonicity (rewrite (= (- ?1) ?x68)) (rewrite (= (- ?0) ?x71)) (= (mod (- ?1) (- ?0)) ?x114))))
(let ((@x124 (trans (monotonicity @x116 (= (- (mod (- ?1) (- ?0))) (- ?x114))) (rewrite (= (- ?x114) ?x120)) (= (- (mod (- ?1) (- ?0))) ?x120))))
(let ((@x127 (monotonicity @x124 (= (ite $x27 ?x37 (- (mod (- ?1) (- ?0)))) ?x125))))
(let ((@x130 (monotonicity @x127 (= (ite $x26 ?1 (ite $x27 ?x37 (- (mod (- ?1) (- ?0))))) ?x128))))
(let ((@x155 (trans (|quant-intro| (monotonicity @x130 $x132) (= $x43 $x134)) (|quant-intro| @x150 (= $x134 $x151)) (= $x43 $x151))))
(let ((@x166 (|mp~| (mp (asserted $x43) @x155 $x151) (|nnf-pos| (refl (|~| $x148 $x148)) (|~| $x151 $x151)) $x151)))
(let ((@x194 (mp @x166 (|quant-intro| (refl (= $x148 $x148)) (= $x151 $x189)) $x189)))
(let (($x247 (not $x189)))
(let (($x357 (or $x247 $x352)))
(let ((?x317 (ite (<= 4 0) (* (~ 1) (mod (* (~ 1) |n$|) (* (~ 1) 4))) ?x316)))
(let ((?x318 (ite (= 4 0) |n$| ?x317)))
(let (($x319 (= ?x13 ?x318)))
(let ((@x337 (rewrite (= (ite false (* (~ 1) (mod (* (~ 1) |n$|) (~ 4))) ?x316) ?x316))))
(let (($x331 (= (* (~ 1) (mod (* (~ 1) |n$|) (* (~ 1) 4))) (* (~ 1) (mod (* (~ 1) |n$|) (~ 4))))))
(let ((@x329 (monotonicity (rewrite (= (* (~ 1) 4) (~ 4))) (= (mod (* (~ 1) |n$|) (* (~ 1) 4)) (mod (* (~ 1) |n$|) (~ 4))))))
(let ((@x335 (monotonicity (rewrite (= (<= 4 0) false)) (monotonicity @x329 $x331) (= ?x317 (ite false (* (~ 1) (mod (* (~ 1) |n$|) (~ 4))) ?x316)))))
(let ((@x342 (monotonicity (rewrite (= (= 4 0) false)) (trans @x335 @x337 (= ?x317 ?x316)) (= ?x318 (ite false |n$| ?x316)))))
(let ((@x349 (monotonicity (trans @x342 (rewrite (= (ite false |n$| ?x316) ?x316)) (= ?x318 ?x316)) (= $x319 (= ?x13 ?x316)))))
(let ((@x361 (monotonicity (trans @x349 (rewrite (= (= ?x13 ?x316) $x352)) (= $x319 $x352)) (= (or $x247 $x319) $x357))))
(let ((@x365 (mp ((_ |quant-inst| |n$| 4) (or $x247 $x319)) (trans @x361 (rewrite (= $x357 $x357)) (= (or $x247 $x319) $x357)) $x357)))
(let ((@x570 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x352) $x366)) (|unit-resolution| @x365 @x194 $x352) $x366)))
(let ((?x275 (* (~ 2) ?x259)))
(let ((?x276 (+ |n$| |m$| ?x240 ?x275)))
(let (($x281 (<= ?x276 0)))
(let (($x274 (= ?x276 0)))
(let ((@x560 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x274) $x281)) (|unit-resolution| ((_ |th-lemma| arith) (or false $x274)) @x62 $x274) $x281)))
(let ((?x241 (+ ?x9 ?x240)))
(let (($x257 (<= ?x241 0)))
(let (($x242 (= ?x241 0)))
(let (($x248 (or $x247 $x242)))
(let (($x196 (<= 2 0)))
(let ((?x202 (ite $x196 (* (~ 1) (mod (* (~ 1) ?x7) (* (~ 1) 2))) ?x201)))
(let (($x195 (= 2 0)))
(let ((?x203 (ite $x195 ?x7 ?x202)))
(let (($x204 (= ?x9 ?x203)))
(let ((?x223 (ite false (* (~ 1) (mod (+ (* (~ 1) |n$|) (* (~ 1) |m$|)) (~ 2))) ?x201)))
(let (($x221 (= (* (~ 1) (mod (* (~ 1) ?x7) (* (~ 1) 2))) (* (~ 1) (mod (+ (* (~ 1) |n$|) (* (~ 1) |m$|)) (~ 2))))))
(let (($x218 (= (mod (* (~ 1) ?x7) (* (~ 1) 2)) (mod (+ (* (~ 1) |n$|) (* (~ 1) |m$|)) (~ 2)))))
(let ((@x216 (rewrite (= (* (~ 1) 2) (~ 2)))))
(let ((@x219 (monotonicity (rewrite (= (* (~ 1) ?x7) (+ (* (~ 1) |n$|) (* (~ 1) |m$|)))) @x216 $x218)))
(let ((@x208 (rewrite (= $x196 false))))
(let ((@x229 (trans (monotonicity @x208 (monotonicity @x219 $x221) (= ?x202 ?x223)) (rewrite (= ?x223 ?x201)) (= ?x202 ?x201))))
(let ((@x206 (rewrite (= $x195 false))))
(let ((@x236 (trans (monotonicity @x206 @x229 (= ?x203 (ite false ?x7 ?x201))) (rewrite (= (ite false ?x7 ?x201) ?x201)) (= ?x203 ?x201))))
(let ((@x246 (trans (monotonicity @x236 (= $x204 (= ?x9 ?x201))) (rewrite (= (= ?x9 ?x201) $x242)) (= $x204 $x242))))
(let ((@x255 (trans (monotonicity @x246 (= (or $x247 $x204) $x248)) (rewrite (= $x248 $x248)) (= (or $x247 $x204) $x248))))
(let ((@x256 (mp ((_ |quant-inst| (+ |n$| |m$|) 2) (or $x247 $x204)) @x255 $x248)))
(let ((@x565 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x242) $x257)) (|unit-resolution| @x256 @x194 $x242) $x257)))
(let ((?x384 (* (~ 4) ?x368)))
(let ((?x385 (+ |n$| ?x350 ?x384)))
(let (($x390 (<= ?x385 0)))
(let (($x383 (= ?x385 0)))
(let ((@x577 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x383) $x390)) (|unit-resolution| ((_ |th-lemma| arith) (or false $x383)) @x62 $x383) $x390)))
(let (($x422 (<= ?x13 3)))
(let (($x15 (= ?x13 3)))
(let ((@x64 (asserted $x15)))
(let ((@x581 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x15) $x422)) @x64 $x422)))
(let (($x420 (<= ?x9 0)))
(let (($x11 (= ?x9 0)))
(let ((@x63 (asserted $x11)))
(let ((@x553 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x11) $x420)) @x63 $x420)))
(let ((@x494 ((_ |th-lemma| arith farkas -1 -1 2 -1 -1 -1 -1 -1 1) @x553 @x581 (hypothesis $x535) @x577 @x565 @x560 @x570 @x379 (|unit-resolution| ((_ |th-lemma| arith) (or false $x492)) @x62 $x492) false)))
(let (($x304 (>= ?x485 0)))
(let ((@x648 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x483) $x304)) (|unit-resolution| ((_ |th-lemma| arith) (or false $x483)) @x62 $x483) $x304)))
(let (($x367 (>= ?x351 0)))
(let ((@x473 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x352) $x367)) (|unit-resolution| @x365 @x194 $x352) $x367)))
(let (($x421 (>= ?x9 0)))
(let (($x282 (>= ?x276 0)))
(let ((@x371 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x274) $x282)) (|unit-resolution| ((_ |th-lemma| arith) (or false $x274)) @x62 $x274) $x282)))
(let (($x258 (>= ?x241 0)))
(let ((@x377 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x242) $x258)) (|unit-resolution| @x256 @x194 $x242) $x258)))
(let (($x391 (>= ?x385 0)))
(let ((@x474 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x383) $x391)) (|unit-resolution| ((_ |th-lemma| arith) (or false $x383)) @x62 $x383) $x391)))
(let (($x423 (>= ?x13 3)))
(let ((@x261 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x15) $x423)) @x64 $x423)))
(let ((?x19 (|mod$| |m$| 2)))
(let ((?x454 (+ ?x19 ?x453)))
(let (($x263 (>= ?x454 0)))
(let (($x386 (= ?x454 0)))
(let (($x486 (or $x247 $x386)))
(let ((?x198 (* (~ 1) 2)))
(let ((?x210 (* (~ 1) |m$|)))
(let ((?x424 (mod ?x210 ?x198)))
(let ((?x425 (* (~ 1) ?x424)))
(let ((?x427 (ite $x196 ?x425 ?x426)))
(let ((?x428 (ite $x195 |m$| ?x427)))
(let (($x429 (= ?x19 ?x428)))
(let ((@x594 (monotonicity (monotonicity @x216 (= ?x424 (mod ?x210 (~ 2)))) (= ?x425 (* (~ 1) (mod ?x210 (~ 2)))))))
(let ((@x596 (monotonicity @x208 @x594 (= ?x427 (ite false (* (~ 1) (mod ?x210 (~ 2))) ?x426)))))
(let ((@x603 (trans @x596 (rewrite (= (ite false (* (~ 1) (mod ?x210 (~ 2))) ?x426) ?x426)) (= ?x427 ?x426))))
(let ((@x414 (trans (monotonicity @x206 @x603 (= ?x428 (ite false |m$| ?x426))) (rewrite (= (ite false |m$| ?x426) ?x426)) (= ?x428 ?x426))))
(let ((@x482 (trans (monotonicity @x414 (= $x429 (= ?x19 ?x426))) (rewrite (= (= ?x19 ?x426) $x386)) (= $x429 $x386))))
(let ((@x511 (trans (monotonicity @x482 (= (or $x247 $x429) $x486)) (rewrite (= $x486 $x486)) (= (or $x247 $x429) $x486))))
(let ((@x512 (mp ((_ |quant-inst| |m$| 2) (or $x247 $x429)) @x511 $x486)))
(let ((@x653 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x386) $x263)) (|unit-resolution| @x512 @x194 $x386) $x263)))
(let (($x271 (>= ?x19 1)))
(let (($x666 (not $x271)))
(let (($x509 (<= ?x19 1)))
(let (($x498 (>= ?x426 2)))
(let (($x635 (not $x498)))
(let (($x469 (<= ?x454 0)))
(let ((@x659 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x386) $x469)) (|unit-resolution| @x512 @x194 $x386) $x469)))
(let ((@x663 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1) (or $x509 $x498 (not $x469))) @x659 (|unit-resolution| ((_ |th-lemma| arith) (or false $x635)) @x62 $x635) $x509)))
(let (($x20 (= ?x19 1)))
(let (($x168 (not $x20)))
(let ((?x16 (|mod$| |n$| 2)))
(let (($x18 (= ?x16 1)))
(let (($x280 (>= ?x16 1)))
(let (($x606 (not $x280)))
(let (($x279 (<= ?x16 1)))
(let ((?x430 (mod |n$| 2)))
(let ((?x437 (* (~ 1) ?x430)))
(let ((?x438 (+ ?x16 ?x437)))
(let (($x455 (<= ?x438 0)))
(let (($x439 (= ?x438 0)))
(let (($x444 (or $x247 $x439)))
(let ((?x209 (* (~ 1) |n$|)))
(let ((?x461 (mod ?x209 ?x198)))
(let ((?x462 (* (~ 1) ?x461)))
(let ((?x431 (ite $x196 ?x462 ?x430)))
(let ((?x432 (ite $x195 |n$| ?x431)))
(let (($x433 (= ?x16 ?x432)))
(let ((@x522 (monotonicity (monotonicity @x216 (= ?x461 (mod ?x209 (~ 2)))) (= ?x462 (* (~ 1) (mod ?x209 (~ 2)))))))
(let ((@x521 (monotonicity @x208 @x522 (= ?x431 (ite false (* (~ 1) (mod ?x209 (~ 2))) ?x430)))))
(let ((@x288 (trans @x521 (rewrite (= (ite false (* (~ 1) (mod ?x209 (~ 2))) ?x430) ?x430)) (= ?x431 ?x430))))
(let ((@x538 (trans (monotonicity @x206 @x288 (= ?x432 (ite false |n$| ?x430))) (rewrite (= (ite false |n$| ?x430) ?x430)) (= ?x432 ?x430))))
(let ((@x443 (trans (monotonicity @x538 (= $x433 (= ?x16 ?x430))) (rewrite (= (= ?x16 ?x430) $x439)) (= $x433 $x439))))
(let ((@x451 (trans (monotonicity @x443 (= (or $x247 $x433) $x444)) (rewrite (= $x444 $x444)) (= (or $x247 $x433) $x444))))
(let ((@x460 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x439) $x455)) (|unit-resolution| (mp ((_ |quant-inst| |n$| 2) (or $x247 $x433)) @x451 $x444) @x194 $x439) $x455)))
(let ((@x463 (|unit-resolution| ((_ |th-lemma| arith) (or false (not (>= ?x430 2)))) @x62 (not (>= ?x430 2)))))
(let ((@x295 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1) (or $x279 (>= ?x430 2) (not $x455))) @x463 @x460 $x279)))
(let ((@x292 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x18 (not $x279) $x606)) (hypothesis (not $x18)) (or (not $x279) $x606))))
(let (($x623 (or (not (>= (+ |n$| ?x13 ?x350 ?x541 (* (~ 1) (div |n$| 2))) 2)) $x280)))
(let ((?x491 (+ |n$| ?x437 (* (~ 2) (div |n$| 2)))))
(let (($x397 (<= ?x491 0)))
(let (($x508 (= ?x491 0)))
(let ((@x614 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x508) $x397)) (|unit-resolution| ((_ |th-lemma| arith) (or false $x508)) @x62 $x508) $x397)))
(let (($x601 (>= (+ |n$| ?x13 ?x350 ?x541 (* (~ 1) (div |n$| 2))) 2)))
(let ((@x620 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x439) (>= ?x438 0))) (|unit-resolution| (mp ((_ |quant-inst| |n$| 2) (or $x247 $x433)) @x451 $x444) @x194 $x439) (>= ?x438 0))))
(let ((@x621 ((_ |th-lemma| arith farkas -1 -2 1 1 1 1 1) @x620 (hypothesis $x601) @x614 @x570 @x577 @x581 (hypothesis $x606) false)))
(let ((@x403 (|unit-resolution| (lemma @x621 $x623) (|unit-resolution| @x292 @x295 $x606) (not $x601))))
(let ((@x406 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x508) (>= ?x491 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x508)) @x62 $x508) (>= ?x491 0))))
(let ((@x411 (|unit-resolution| ((_ |th-lemma| arith) (or false (>= ?x430 0))) @x62 (>= ?x430 0))))
(let (($x169 (or (not $x18) $x168)))
(let ((@x175 (monotonicity (rewrite (= (and $x18 $x20) (not $x169))) (= (not (and $x18 $x20)) (not (not $x169))))))
(let ((@x179 (trans @x175 (rewrite (= (not (not $x169)) $x169)) (= (not (and $x18 $x20)) $x169))))
(let ((@x180 (mp (asserted (not (and $x18 $x20))) @x179 $x169)))
(let ((@x664 (|unit-resolution| @x180 (lemma ((_ |th-lemma| arith farkas -1/2 -1/2 -1/2 -1/2 -1/2 1) @x411 @x406 @x473 @x474 @x261 @x403 false) $x18) $x168)))
(let ((@x670 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x20 (not $x509) $x666)) @x664 (or (not $x509) $x666))))
((_ |th-lemma| arith farkas 1/2 -1/2 -1/2 -1/2 -1/2 -1/2 -1/2 -1/2 -1/2 1) (|unit-resolution| @x670 @x663 $x666) @x653 @x261 @x474 @x377 @x371 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x11) $x421)) @x63 $x421) @x473 @x648 (lemma @x494 (not $x535)) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

5e6ffeb79676694a9ab7732936a1e448ef9134cd 12 0
unsat
((set-logic AUFLIA)
(proof
(let (($x6 (exists ((?v0 Int) )false)
))
(let (($x5 (not $x6)))
(let (($x7 (not $x5)))
(let ((@x33 (monotonicity (|elim-unused| (= $x6 false)) (= $x5 (not false)))))
(let ((@x40 (monotonicity (trans @x33 (rewrite (= (not false) true)) (= $x5 true)) (= $x7 (not true)))))
(let ((@x44 (trans @x40 (rewrite (= (not true) false)) (= $x7 false))))
(mp (asserted $x7) @x44 false)))))))))

d02a9dcd83dfb0d3e50a887c4f5274a79c10c85e 12 0
unsat
((set-logic AUFLIRA)
(proof
(let (($x6 (exists ((?v0 Real) )false)
))
(let (($x5 (not $x6)))
(let (($x7 (not $x5)))
(let ((@x33 (monotonicity (|elim-unused| (= $x6 false)) (= $x5 (not false)))))
(let ((@x40 (monotonicity (trans @x33 (rewrite (= (not false) true)) (= $x5 true)) (= $x7 (not true)))))
(let ((@x44 (trans @x40 (rewrite (= (not true) false)) (= $x7 false))))
(mp (asserted $x7) @x44 false)))))))))

1a820d07cf476448545d144873b309b9cfc3a238 2 0
unknown
(error "line 6 column 10: proof is not available")
23ed6364c527ef515dd659de8b496cfd59df4ec7 2 0
unknown
(error "line 6 column 10: proof is not available")
9722ff2e938783a69202c957c858fb219ec0cdb0 2 0
unknown
(error "line 6 column 10: proof is not available")
cb87115705dc568881932b35aa82751f3f97049c 22 0
unsat
((set-logic AUFLIA)
(declare-fun ?v1!0 () Int)
(declare-fun ?v0!1 () Int)
(proof
(let (($x51 (= ?v1!0 1)))
(let (($x57 (not (or (not (and (= ?v0!1 0) $x51)) (not (= ?v0!1 ?v1!0))))))
(let (($x41 (forall ((?v0 Int) (?v1 Int) )(or (not (and (= ?v0 0) (= ?v1 1))) (not (= ?v0 ?v1))))
))
(let (($x44 (not $x41)))
(let (($x15 (forall ((?v0 Int) (?v1 Int) )(=> (and (= ?v0 0) (= ?v1 1)) (not (= ?v0 ?v1))))
))
(let (($x16 (not $x15)))
(let (($x39 (= (=> (and (= ?1 0) (= ?0 1)) (not (= ?1 ?0))) (or (not (and (= ?1 0) (= ?0 1))) (not (= ?1 ?0))))))
(let ((@x46 (monotonicity (|quant-intro| (rewrite $x39) (= $x15 $x41)) (= $x16 $x44))))
(let ((@x63 (|not-or-elim| (|mp~| (mp (asserted $x16) @x46 $x44) (sk (|~| $x44 $x57)) $x57) (and (= ?v0!1 0) $x51))))
(let ((@x65 (|and-elim| @x63 $x51)))
(let (($x54 (= ?v0!1 ?v1!0)))
(let ((@x66 (|not-or-elim| (|mp~| (mp (asserted $x16) @x46 $x44) (sk (|~| $x44 $x57)) $x57) $x54)))
(let ((@x68 (trans (symm (|and-elim| @x63 (= ?v0!1 0)) (= 0 ?v0!1)) @x66 (= 0 ?v1!0))))
(mp (trans @x68 @x65 (= 0 1)) (rewrite (= (= 0 1) false)) false))))))))))))))))

d2d0a7794c4de3708d5541374fd9e0075ad5fa36 55 0
unsat
((set-logic AUFLIA)
(proof
(let (($x14 (exists ((?v0 Int) )(forall ((?v1 Int) )(let (($x10 (<= 0 ?v1)))
(let (($x9 (< ?v1 0)))
(let (($x11 (or $x9 $x10)))
(let (($x7 (< ?v0 ?v1)))
(=> $x7 $x11))))))
)
))
(let (($x15 (not $x14)))
(let (($x43 (exists ((?v0 Int) )(forall ((?v1 Int) )(let (($x10 (<= 0 ?v1)))
(let (($x9 (< ?v1 0)))
(let (($x11 (or $x9 $x10)))
(let (($x7 (< ?v0 ?v1)))
(let (($x36 (not $x7)))
(or $x36 $x11)))))))
)
))
(let (($x46 (not $x43)))
(let (($x86 (exists ((?v0 Int) )true)
))
(let (($x40 (forall ((?v1 Int) )(let (($x10 (<= 0 ?v1)))
(let (($x9 (< ?v1 0)))
(let (($x11 (or $x9 $x10)))
(let (($x7 (< ?0 ?v1)))
(let (($x36 (not $x7)))
(or $x36 $x11)))))))
))
(let (($x79 (forall ((?v1 Int) )true)
))
(let (($x10 (<= 0 ?0)))
(let (($x9 (< ?0 0)))
(let (($x11 (or $x9 $x10)))
(let (($x7 (< ?1 ?0)))
(let (($x36 (not $x7)))
(let (($x37 (or $x36 $x11)))
(let (($x58 (<= (+ ?0 (* (~ 1) ?1)) 0)))
(let ((@x76 (rewrite (= (or $x58 (or (not (>= ?0 0)) (>= ?0 0))) true))))
(let ((@x71 (monotonicity (rewrite (= $x9 (not (>= ?0 0)))) (rewrite (= $x10 (>= ?0 0))) (= $x11 (or (not (>= ?0 0)) (>= ?0 0))))))
(let ((@x64 (monotonicity (rewrite (= $x7 (not $x58))) (= $x36 (not (not $x58))))))
(let ((@x74 (monotonicity (trans @x64 (rewrite (= (not (not $x58)) $x58)) (= $x36 $x58)) @x71 (= $x37 (or $x58 (or (not (>= ?0 0)) (>= ?0 0)))))))
(let ((@x85 (trans (|quant-intro| (trans @x74 @x76 (= $x37 true)) (= $x40 $x79)) (|elim-unused| (= $x79 true)) (= $x40 true))))
(let ((@x92 (trans (|quant-intro| @x85 (= $x43 $x86)) (|elim-unused| (= $x86 true)) (= $x43 true))))
(let ((@x99 (trans (monotonicity @x92 (= $x46 (not true))) (rewrite (= (not true) false)) (= $x46 false))))
(let (($x13 (forall ((?v1 Int) )(let (($x10 (<= 0 ?v1)))
(let (($x9 (< ?v1 0)))
(let (($x11 (or $x9 $x10)))
(let (($x7 (< ?0 ?v1)))
(=> $x7 $x11))))))
))
(let ((@x45 (|quant-intro| (|quant-intro| (rewrite (= (=> $x7 $x11) $x37)) (= $x13 $x40)) (= $x14 $x43))))
(let ((@x48 (monotonicity @x45 (= $x15 $x46))))
(mp (asserted $x15) (trans @x48 @x99 (= $x15 false)) false)))))))))))))))))))))))))))

75e4df9c205f7c15d7e530b5e1e97635aed16d82 42 0
unsat
((set-logic AUFLIA)
(proof
(let (($x15 (forall ((?v0 Int) (?v1 Int) )(let ((?x12 (* 2 ?v1)))
(let ((?x9 (* 2 ?v0)))
(let ((?x11 (+ ?x9 1)))
(let (($x13 (< ?x11 ?x12)))
(let (($x7 (< ?v0 ?v1)))
(=> $x7 $x13)))))))
))
(let (($x16 (not $x15)))
(let (($x53 (forall ((?v0 Int) (?v1 Int) )(let ((?x12 (* 2 ?v1)))
(let ((?x9 (* 2 ?v0)))
(let ((?x38 (+ 1 ?x9)))
(let (($x41 (< ?x38 ?x12)))
(let (($x7 (< ?v0 ?v1)))
(let (($x47 (not $x7)))
(or $x47 $x41))))))))
))
(let (($x56 (not $x53)))
(let (($x82 (forall ((?v0 Int) (?v1 Int) )true)
))
(let ((?x12 (* 2 ?0)))
(let ((?x9 (* 2 ?1)))
(let ((?x38 (+ 1 ?x9)))
(let (($x41 (< ?x38 ?x12)))
(let (($x7 (< ?1 ?0)))
(let (($x47 (not $x7)))
(let (($x48 (or $x47 $x41)))
(let (($x61 (>= (+ ?1 (* (~ 1) ?0)) 0)))
(let (($x60 (not $x61)))
(let ((@x72 (trans (monotonicity (rewrite (= $x7 $x60)) (= $x47 (not $x60))) (rewrite (= (not $x60) $x61)) (= $x47 $x61))))
(let ((@x77 (monotonicity @x72 (rewrite (= $x41 $x60)) (= $x48 (or $x61 $x60)))))
(let ((@x84 (|quant-intro| (trans @x77 (rewrite (= (or $x61 $x60) true)) (= $x48 true)) (= $x53 $x82))))
(let ((@x91 (monotonicity (trans @x84 (|elim-unused| (= $x82 true)) (= $x53 true)) (= $x56 (not true)))))
(let ((@x95 (trans @x91 (rewrite (= (not true) false)) (= $x56 false))))
(let ((@x43 (monotonicity (rewrite (= (+ ?x9 1) ?x38)) (= (< (+ ?x9 1) ?x12) $x41))))
(let ((@x46 (monotonicity @x43 (= (=> $x7 (< (+ ?x9 1) ?x12)) (=> $x7 $x41)))))
(let ((@x52 (trans @x46 (rewrite (= (=> $x7 $x41) $x48)) (= (=> $x7 (< (+ ?x9 1) ?x12)) $x48))))
(let ((@x58 (monotonicity (|quant-intro| @x52 (= $x15 $x53)) (= $x16 $x56))))
(mp (asserted $x16) (trans @x58 @x95 (= $x16 false)) false))))))))))))))))))))))))))

591a3beb5d84c4e2d6724bf947c2fd4fa44c6bbc 32 0
unsat
((set-logic AUFLIA)
(proof
(let (($x14 (forall ((?v0 Int) (?v1 Int) )(let ((?x11 (* 2 ?v1)))
(let ((?x8 (* 2 ?v0)))
(let ((?x10 (+ ?x8 1)))
(let (($x12 (= ?x10 ?x11)))
(not $x12))))))
))
(let (($x15 (not $x14)))
(let (($x46 (forall ((?v0 Int) (?v1 Int) )(let ((?x11 (* 2 ?v1)))
(let ((?x8 (* 2 ?v0)))
(let ((?x37 (+ 1 ?x8)))
(let (($x40 (= ?x37 ?x11)))
(not $x40))))))
))
(let (($x49 (not $x46)))
(let (($x61 (forall ((?v0 Int) (?v1 Int) )true)
))
(let ((?x11 (* 2 ?0)))
(let ((?x8 (* 2 ?1)))
(let ((?x37 (+ 1 ?x8)))
(let (($x40 (= ?x37 ?x11)))
(let (($x43 (not $x40)))
(let ((@x60 (trans (monotonicity (rewrite (= $x40 false)) (= $x43 (not false))) (rewrite (= (not false) true)) (= $x43 true))))
(let ((@x67 (trans (|quant-intro| @x60 (= $x46 $x61)) (|elim-unused| (= $x61 true)) (= $x46 true))))
(let ((@x74 (trans (monotonicity @x67 (= $x49 (not true))) (rewrite (= (not true) false)) (= $x49 false))))
(let ((@x42 (monotonicity (rewrite (= (+ ?x8 1) ?x37)) (= (= (+ ?x8 1) ?x11) $x40))))
(let ((@x48 (|quant-intro| (monotonicity @x42 (= (not (= (+ ?x8 1) ?x11)) $x43)) (= $x14 $x46))))
(let ((@x51 (monotonicity @x48 (= $x15 $x49))))
(mp (asserted $x15) (trans @x51 @x74 (= $x15 false)) false)))))))))))))))))))

ed6b5d78e5a12fb3a6471e02bc6e89ebc78c1a34 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 (($x71 (or (not (<= (+ ?v0!1 ?v1!0) 2)) (= (+ ?v0!1 ?v1!0) 2) (not (>= (+ ?v0!1 ?v1!0) 2)))))
(let (($x72 (not $x71)))
(let ((@x80 (rewrite (= (+ ?v0!1 ?v1!0) ?x78))))
(let ((@x95 (monotonicity (monotonicity @x80 (= (>= (+ ?v0!1 ?v1!0) 2) $x90)) (= (not (>= (+ ?v0!1 ?v1!0) 2)) $x93))))
(let ((@x86 (monotonicity (monotonicity @x80 (= (<= (+ ?v0!1 ?v1!0) 2) $x81)) (= (not (<= (+ ?v0!1 ?v1!0) 2)) $x84))))
(let ((@x98 (monotonicity @x86 (monotonicity @x80 (= (= (+ ?v0!1 ?v1!0) 2) $x87)) @x95 (= $x71 (or $x84 $x87 $x93)))))
(let (($x58 (forall ((?v0 Int) (?v1 Int) )(let (($x39 (not (>= (+ ?v0 ?v1) 2))))
(let ((?x8 (+ ?v0 ?v1)))
(let (($x10 (= ?x8 2)))
(let (($x44 (not (<= ?x8 2))))
(or $x44 $x10 $x39))))))
))
(let (($x61 (not $x58)))
(let (($x14 (forall ((?v0 Int) (?v1 Int) )(or (< 2 (+ ?v0 ?v1)) (or (= (+ ?v0 ?v1) 2) (< (+ ?v0 ?v1) 2))))
))
(let (($x15 (not $x14)))
(let (($x39 (not (>= (+ ?1 ?0) 2))))
(let ((?x8 (+ ?1 ?0)))
(let (($x10 (= ?x8 2)))
(let (($x44 (not (<= ?x8 2))))
(let (($x53 (or $x44 $x10 $x39)))
(let (($x13 (or (< 2 ?x8) (or $x10 (< ?x8 2)))))
(let ((@x49 (monotonicity (rewrite (= (< ?x8 2) $x39)) (= (or $x10 (< ?x8 2)) (or $x10 $x39)))))
(let ((@x52 (monotonicity (rewrite (= (< 2 ?x8) $x44)) @x49 (= $x13 (or $x44 (or $x10 $x39))))))
(let ((@x57 (trans @x52 (rewrite (= (or $x44 (or $x10 $x39)) $x53)) (= $x13 $x53))))
(let ((@x64 (mp (asserted $x15) (monotonicity (|quant-intro| @x57 (= $x14 $x58)) (= $x15 $x61)) $x61)))
(let ((@x76 (mp (|mp~| @x64 (sk (|~| $x61 $x72)) $x72) (monotonicity @x98 (= $x72 (not (or $x84 $x87 $x93)))) (not (or $x84 $x87 $x93)))))
(let ((@x103 (|not-or-elim| @x76 (not $x87))))
(let ((@x104 (|not-or-elim| @x76 $x90)))
(let ((@x77 (|not-or-elim| @x76 $x81)))
(|unit-resolution| (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x87 $x84 $x93)) @x77 (or $x87 $x93)) @x104 @x103 false)))))))))))))))))))))))))))))))))

092a8c0984dc61be1fab786d699cb79093b7c5f2 46 0
unsat
((set-logic AUFLIA)
(declare-fun ?v0!0 () Int)
(proof
(let (($x81 (<= ?v0!0 0)))
(let (($x84 (<= ?v0!0 (~ 1))))
(let (($x85 (not $x84)))
(let ((@x103 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x85 $x81)) (hypothesis (not $x81)) $x85)))
(let (($x82 (>= ?v0!0 1)))
(let (($x83 (not $x82)))
(let (($x86 (ite $x81 $x83 $x85)))
(let (($x87 (not $x86)))
(let (($x71 (forall ((?v0 Int) )(let (($x56 (not (<= ?v0 (~ 1)))))
(let (($x59 (not (>= ?v0 1))))
(ite (<= ?v0 0) $x59 $x56))))
))
(let (($x74 (not $x71)))
(let (($x13 (forall ((?v0 Int) )(let (($x11 (< ?v0 1)))
(let (($x7 (< 0 ?v0)))
(ite $x7 (< 0 (+ ?v0 1)) $x11))))
))
(let (($x14 (not $x13)))
(let (($x44 (forall ((?v0 Int) )(let (($x11 (< ?v0 1)))
(let (($x38 (< 0 (+ 1 ?v0))))
(let (($x7 (< 0 ?v0)))
(ite $x7 $x38 $x11)))))
))
(let (($x56 (not (<= ?0 (~ 1)))))
(let (($x59 (not (>= ?0 1))))
(let (($x66 (ite (<= ?0 0) $x59 $x56)))
(let (($x11 (< ?0 1)))
(let (($x38 (< 0 (+ 1 ?0))))
(let (($x7 (< 0 ?0)))
(let (($x41 (ite $x7 $x38 $x11)))
(let ((@x65 (monotonicity (rewrite (= $x7 (not (<= ?0 0)))) (rewrite (= $x38 $x56)) (rewrite (= $x11 $x59)) (= $x41 (ite (not (<= ?0 0)) $x56 $x59)))))
(let ((@x70 (trans @x65 (rewrite (= (ite (not (<= ?0 0)) $x56 $x59) $x66)) (= $x41 $x66))))
(let ((@x76 (monotonicity (|quant-intro| @x70 (= $x44 $x71)) (= (not $x44) $x74))))
(let ((@x40 (monotonicity (rewrite (= (+ ?0 1) (+ 1 ?0))) (= (< 0 (+ ?0 1)) $x38))))
(let ((@x43 (monotonicity @x40 (= (ite $x7 (< 0 (+ ?0 1)) $x11) $x41))))
(let ((@x49 (monotonicity (|quant-intro| @x43 (= $x13 $x44)) (= $x14 (not $x44)))))
(let ((@x90 (|mp~| (mp (asserted $x14) (trans @x49 @x76 (= $x14 $x74)) $x74) (sk (|~| $x74 $x87)) $x87)))
(let ((@x106 (|unit-resolution| (|unit-resolution| (|def-axiom| (or $x86 $x81 $x84)) @x90 (or $x81 $x84)) @x103 (hypothesis (not $x81)) false)))
(let ((@x107 (lemma @x106 $x81)))
(let ((@x112 (|unit-resolution| (|def-axiom| (or $x86 (not $x81) $x82)) @x90 (or (not $x81) $x82))))
(|unit-resolution| @x112 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x83 (not $x81))) @x107 $x83) @x107 false)))))))))))))))))))))))))))))))))

a5ac1b17c244dd3aef6c7c1289500bca02b482d0 2 0
unknown
(error "line 6 column 10: proof is not available")
f697308f77e23a8625c050b2aa7a7f131faf390d 2 0
unknown
(error "line 6 column 10: proof is not available")
ad02a5379962c0c41aaf5c95191947c03228f5e6 39 0
unsat
((set-logic AUFLIA)
(proof
(let (($x16 (exists ((?v0 Int) (?v1 Int) (?v2 Int) )(let ((?x11 (- 6)))
(let ((?x12 (* ?x11 ?v1)))
(let ((?x9 (* 4 ?v0)))
(let ((?x13 (+ ?x9 ?x12)))
(= ?x13 1))))))
))
(let (($x7 (not $x16)))
(let (($x17 (not $x7)))
(let (($x59 (exists ((?v0 Int) (?v1 Int) )(let ((?x56 (* (~ 6) ?v1)))
(let ((?x55 (* 4 ?v0)))
(let ((?x57 (+ ?x55 ?x56)))
(= ?x57 1)))))
))
(let (($x75 (exists ((?v0 Int) (?v1 Int) )false)
))
(let ((@x79 (|quant-intro| (rewrite (= (= (+ (* 4 ?1) (* (~ 6) ?0)) 1) false)) (= $x59 $x75))))
(let ((@x83 (trans @x79 (|elim-unused| (= $x75 false)) (= $x59 false))))
(let (($x51 (exists ((?v0 Int) (?v1 Int) (?v2 Int) )(let ((?x42 (* (~ 6) ?v1)))
(let ((?x9 (* 4 ?v0)))
(let ((?x45 (+ ?x9 ?x42)))
(= ?x45 1)))))
))
(let ((?x42 (* (~ 6) ?1)))
(let ((?x9 (* 4 ?2)))
(let ((?x45 (+ ?x9 ?x42)))
(let (($x48 (= ?x45 1)))
(let ((?x11 (- 6)))
(let ((?x12 (* ?x11 ?1)))
(let ((?x13 (+ ?x9 ?x12)))
(let (($x15 (= ?x13 1)))
(let ((@x47 (monotonicity (monotonicity (rewrite (= ?x11 (~ 6))) (= ?x12 ?x42)) (= ?x13 ?x45))))
(let ((@x63 (trans (|quant-intro| (monotonicity @x47 (= $x15 $x48)) (= $x16 $x51)) (|elim-unused| (= $x51 $x59)) (= $x16 $x59))))
(let ((@x69 (monotonicity (monotonicity @x63 (= $x7 (not $x59))) (= $x17 (not (not $x59))))))
(let ((@x73 (trans @x69 (rewrite (= (not (not $x59)) $x59)) (= $x17 $x59))))
(mp (asserted $x17) (trans @x73 @x83 (= $x17 false)) false)))))))))))))))))))))))

8a423de6b668d07fe5d90dcad74d7fbb1fcb9c11 52 0
unsat
((set-logic AUFLIA)
(declare-fun ?v1!1 () Int)
(declare-fun ?v2!0 () Int)
(proof
(let ((?x103 (+ ?v2!0 ?v1!1)))
(let (($x104 (<= ?x103 0)))
(let (($x106 (or (not (and (not (<= ?v1!1 0)) (not (<= ?v2!0 0)))) (not $x104))))
(let (($x86 (forall ((?v1 Int) (?v2 Int) )(or (not (and (not (<= ?v1 0)) (not (<= ?v2 0)))) (not (<= (+ ?v2 ?v1) 0))))
))
(let (($x89 (not $x86)))
(let (($x15 (exists ((?v0 Int) )(forall ((?v1 Int) (?v2 Int) )(let (($x10 (and (< 0 ?v1) (< 0 ?v2))))
(=> $x10 (< 0 (+ ?v1 ?v2)))))
)
))
(let (($x16 (not $x15)))
(let (($x52 (forall ((?v1 Int) (?v2 Int) )(let ((?x37 (+ ?v2 ?v1)))
(let (($x40 (< 0 ?x37)))
(or (not (and (< 0 ?v1) (< 0 ?v2))) $x40))))
))
(let (($x83 (or (not (and (not (<= ?1 0)) (not (<= ?0 0)))) (not (<= (+ ?0 ?1) 0)))))
(let ((?x37 (+ ?0 ?1)))
(let (($x40 (< 0 ?x37)))
(let (($x47 (or (not (and (< 0 ?1) (< 0 ?0))) $x40)))
(let (($x77 (= (not (and (< 0 ?1) (< 0 ?0))) (not (and (not (<= ?1 0)) (not (<= ?0 0)))))))
(let (($x10 (and (< 0 ?1) (< 0 ?0))))
(let ((@x75 (monotonicity (rewrite (= (< 0 ?1) (not (<= ?1 0)))) (rewrite (= (< 0 ?0) (not (<= ?0 0)))) (= $x10 (and (not (<= ?1 0)) (not (<= ?0 0)))))))
(let ((@x85 (monotonicity (monotonicity @x75 $x77) (rewrite (= $x40 (not (<= ?x37 0)))) (= $x47 $x83))))
(let ((@x91 (monotonicity (|quant-intro| @x85 (= $x52 $x86)) (= (not $x52) $x89))))
(let (($x55 (exists ((?v0 Int) )(forall ((?v1 Int) (?v2 Int) )(let ((?x37 (+ ?v2 ?v1)))
(let (($x40 (< 0 ?x37)))
(or (not (and (< 0 ?v1) (< 0 ?v2))) $x40))))
)
))
(let (($x14 (forall ((?v1 Int) (?v2 Int) )(let (($x10 (and (< 0 ?v1) (< 0 ?v2))))
(=> $x10 (< 0 (+ ?v1 ?v2)))))
))
(let ((@x42 (monotonicity (rewrite (= (+ ?1 ?0) ?x37)) (= (< 0 (+ ?1 ?0)) $x40))))
(let ((@x45 (monotonicity @x42 (= (=> $x10 (< 0 (+ ?1 ?0))) (=> $x10 $x40)))))
(let ((@x51 (trans @x45 (rewrite (= (=> $x10 $x40) $x47)) (= (=> $x10 (< 0 (+ ?1 ?0))) $x47))))
(let ((@x61 (trans (|quant-intro| (|quant-intro| @x51 (= $x14 $x52)) (= $x15 $x55)) (|elim-unused| (= $x55 $x52)) (= $x15 $x52))))
(let ((@x93 (trans (monotonicity @x61 (= $x16 (not $x52))) @x91 (= $x16 $x89))))
(let ((@x110 (|mp~| (mp (asserted $x16) @x93 $x89) (sk (|~| $x89 (not $x106))) (not $x106))))
(let ((@x116 (|not-or-elim| @x110 $x104)))
(let (($x97 (<= ?v1!1 0)))
(let (($x98 (not $x97)))
(let ((@x114 (|and-elim| (|not-or-elim| @x110 (and $x98 (not (<= ?v2!0 0)))) $x98)))
(let (($x99 (<= ?v2!0 0)))
(let (($x100 (not $x99)))
(let ((@x115 (|and-elim| (|not-or-elim| @x110 (and $x98 $x100)) $x100)))
((_ |th-lemma| arith farkas 1 1 1) @x115 @x114 @x116 false)))))))))))))))))))))))))))))))))))

7c93c190dc21779c8214786ce8c1fd4de433814f 46 0
unsat
((set-logic AUFLIRA)
(declare-fun ?v1!1 () Int)
(declare-fun ?v2!0 () Real)
(proof
(let (($x103 (<= ?v1!1 (~ 1))))
(let (($x104 (not $x103)))
(let (($x105 (or (not (and (not (<= ?v1!1 0)) (not (<= ?v2!0 0.0)))) $x104)))
(let (($x86 (forall ((?v1 Int) (?v2 Real) )(or (not (and (not (<= ?v1 0)) (not (<= ?v2 0.0)))) (not (<= ?v1 (~ 1)))))
))
(let (($x89 (not $x86)))
(let (($x18 (exists ((?v0 Int) )(forall ((?v1 Int) (?v2 Real) )(let (($x12 (and (< 0 ?v1) (< 0.0 ?v2))))
(=> $x12 (< (- 1) ?v1))))
)
))
(let (($x5 (not $x18)))
(let (($x52 (forall ((?v1 Int) (?v2 Real) )(let (($x40 (< (~ 1) ?v1)))
(or (not (and (< 0 ?v1) (< 0.0 ?v2))) $x40)))
))
(let (($x83 (or (not (and (not (<= ?1 0)) (not (<= ?0 0.0)))) (not (<= ?1 (~ 1))))))
(let (($x40 (< (~ 1) ?1)))
(let (($x47 (or (not (and (< 0 ?1) (< 0.0 ?0))) $x40)))
(let (($x77 (= (not (and (< 0 ?1) (< 0.0 ?0))) (not (and (not (<= ?1 0)) (not (<= ?0 0.0)))))))
(let (($x12 (and (< 0 ?1) (< 0.0 ?0))))
(let ((@x75 (monotonicity (rewrite (= (< 0 ?1) (not (<= ?1 0)))) (rewrite (= (< 0.0 ?0) (not (<= ?0 0.0)))) (= $x12 (and (not (<= ?1 0)) (not (<= ?0 0.0)))))))
(let ((@x85 (monotonicity (monotonicity @x75 $x77) (rewrite (= $x40 (not (<= ?1 (~ 1))))) (= $x47 $x83))))
(let ((@x91 (monotonicity (|quant-intro| @x85 (= $x52 $x86)) (= (not $x52) $x89))))
(let (($x55 (exists ((?v0 Int) )(forall ((?v1 Int) (?v2 Real) )(let (($x40 (< (~ 1) ?v1)))
(or (not (and (< 0 ?v1) (< 0.0 ?v2))) $x40)))
)
))
(let (($x17 (forall ((?v1 Int) (?v2 Real) )(let (($x12 (and (< 0 ?v1) (< 0.0 ?v2))))
(=> $x12 (< (- 1) ?v1))))
))
(let ((@x42 (monotonicity (rewrite (= (- 1) (~ 1))) (= (< (- 1) ?1) $x40))))
(let ((@x45 (monotonicity @x42 (= (=> $x12 (< (- 1) ?1)) (=> $x12 $x40)))))
(let ((@x51 (trans @x45 (rewrite (= (=> $x12 $x40) $x47)) (= (=> $x12 (< (- 1) ?1)) $x47))))
(let ((@x61 (trans (|quant-intro| (|quant-intro| @x51 (= $x17 $x52)) (= $x18 $x55)) (|elim-unused| (= $x55 $x52)) (= $x18 $x52))))
(let ((@x93 (trans (monotonicity @x61 (= $x5 (not $x52))) @x91 (= $x5 $x89))))
(let ((@x109 (|mp~| (mp (asserted $x5) @x93 $x89) (sk (|~| $x89 (not $x105))) (not $x105))))
(let ((@x115 (|not-or-elim| @x109 $x103)))
(let (($x97 (<= ?v1!1 0)))
(let (($x98 (not $x97)))
(let ((@x113 (|and-elim| (|not-or-elim| @x109 (and $x98 (not (<= ?v2!0 0.0)))) $x98)))
(|unit-resolution| (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x104 $x97)) @x113 $x104) @x115 false)))))))))))))))))))))))))))))))

39a3c02f6687608102bd092d376b8901575e5356 2 0
unknown
(error "line 6 column 10: proof is not available")
3bdf1da3a49c7c0ce726c85bf6e844aabdd6afa0 36 0
unsat
((set-logic AUFLIA)
(proof
(let (($x13 (forall ((?v0 Int) )(let ((?x10 (* 2 |a$|)))
(let ((?x9 (* 2 ?v0)))
(let (($x11 (< ?x9 ?x10)))
(let (($x7 (< ?v0 |a$|)))
(=> $x7 $x11))))))
))
(let (($x14 (not $x13)))
(let (($x40 (forall ((?v0 Int) )(let ((?x10 (* 2 |a$|)))
(let ((?x9 (* 2 ?v0)))
(let (($x11 (< ?x9 ?x10)))
(let (($x7 (< ?v0 |a$|)))
(let (($x36 (not $x7)))
(or $x36 $x11)))))))
))
(let (($x43 (not $x40)))
(let (($x69 (forall ((?v0 Int) )true)
))
(let ((?x10 (* 2 |a$|)))
(let ((?x9 (* 2 ?0)))
(let (($x11 (< ?x9 ?x10)))
(let (($x7 (< ?0 |a$|)))
(let (($x36 (not $x7)))
(let (($x37 (or $x36 $x11)))
(let (($x48 (>= (+ ?0 (* (~ 1) |a$|)) 0)))
(let (($x47 (not $x48)))
(let ((@x59 (trans (monotonicity (rewrite (= $x7 $x47)) (= $x36 (not $x47))) (rewrite (= (not $x47) $x48)) (= $x36 $x48))))
(let ((@x64 (monotonicity @x59 (rewrite (= $x11 $x47)) (= $x37 (or $x48 $x47)))))
(let ((@x71 (|quant-intro| (trans @x64 (rewrite (= (or $x48 $x47) true)) (= $x37 true)) (= $x40 $x69))))
(let ((@x78 (monotonicity (trans @x71 (|elim-unused| (= $x69 true)) (= $x40 true)) (= $x43 (not true)))))
(let ((@x82 (trans @x78 (rewrite (= (not true) false)) (= $x43 false))))
(let ((@x45 (monotonicity (|quant-intro| (rewrite (= (=> $x7 $x11) $x37)) (= $x13 $x40)) (= $x14 $x43))))
(mp (asserted $x14) (trans @x45 @x82 (= $x14 false)) false))))))))))))))))))))))

0737ab0e9619ba68da155fd5dcce2691243e7d8d 24 0
unsat
((set-logic AUFLIA)
(declare-fun ?v1!0 () Int)
(proof
(let (($x62 (>= ?v1!0 1)))
(let (($x50 (forall ((?v1 Int) )(or (not (<= ?v1 0)) (not (>= ?v1 1))))
))
(let (($x53 (not $x50)))
(let (($x12 (forall ((?v0 Int) (?v1 Int) )(or (< 0 ?v1) (< ?v1 1)))
))
(let (($x5 (not $x12)))
(let (($x33 (forall ((?v1 Int) )(or (< 0 ?v1) (< ?v1 1)))
))
(let (($x11 (or (< 0 ?0) (< ?0 1))))
(let ((@x49 (monotonicity (rewrite (= (< 0 ?0) (not (<= ?0 0)))) (rewrite (= (< ?0 1) (not (>= ?0 1)))) (= $x11 (or (not (<= ?0 0)) (not (>= ?0 1)))))))
(let ((@x55 (monotonicity (|quant-intro| @x49 (= $x33 $x50)) (= (not $x33) $x53))))
(let ((@x57 (trans (monotonicity (|elim-unused| (= $x12 $x33)) (= $x5 (not $x33))) @x55 (= $x5 $x53))))
(let ((@x68 (|mp~| (mp (asserted $x5) @x57 $x53) (sk (|~| $x53 (not (or (not (<= ?v1!0 0)) (not $x62))))) (not (or (not (<= ?v1!0 0)) (not $x62))))))
(let ((@x72 (|not-or-elim| @x68 $x62)))
(let (($x63 (not $x62)))
(let (($x60 (<= ?v1!0 0)))
(let ((@x71 (|not-or-elim| @x68 $x60)))
(|unit-resolution| (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x63 (not $x60))) @x71 $x63) @x72 false))))))))))))))))))

40bda8c0d6f113a97f5dc1db7c4465fe4cb9ac06 26 0
unsat
((set-logic <null>)
(proof
(let (($x56 (<= |b$| 0)))
(let (($x60 (or (not (and (not (<= |a$| 0)) (not (<= (* |a$| |b$|) 0)))) (not $x56))))
(let (($x63 (not $x60)))
(let (($x14 (not (=> (and (< 0 |a$|) (< 0 (* |a$| |b$|))) (< 0 |b$|)))))
(let (($x12 (< 0 |b$|)))
(let (($x36 (or (not (and (< 0 |a$|) (< 0 (* |a$| |b$|)))) $x12)))
(let (($x54 (= (not (and (< 0 |a$|) (< 0 (* |a$| |b$|)))) (not (and (not (<= |a$| 0)) (not (<= (* |a$| |b$|) 0)))))))
(let ((?x9 (* |a$| |b$|)))
(let (($x46 (<= ?x9 0)))
(let (($x47 (not $x46)))
(let (($x42 (<= |a$| 0)))
(let (($x43 (not $x42)))
(let (($x50 (and $x43 $x47)))
(let (($x11 (and (< 0 |a$|) (< 0 ?x9))))
(let ((@x52 (monotonicity (rewrite (= (< 0 |a$|) $x43)) (rewrite (= (< 0 ?x9) $x47)) (= $x11 $x50))))
(let ((@x62 (monotonicity (monotonicity @x52 $x54) (rewrite (= $x12 (not $x56))) (= $x36 $x60))))
(let ((@x41 (monotonicity (rewrite (= (=> $x11 $x12) $x36)) (= $x14 (not $x36)))))
(let ((@x67 (trans @x41 (monotonicity @x62 (= (not $x36) $x63)) (= $x14 $x63))))
(let ((@x72 (|not-or-elim| (mp (asserted $x14) @x67 $x63) $x56)))
(let ((@x70 (|and-elim| (|not-or-elim| (mp (asserted $x14) @x67 $x63) $x50) $x43)))
(let ((@x71 (|and-elim| (|not-or-elim| (mp (asserted $x14) @x67 $x63) $x50) $x47)))
((_ |th-lemma| arith farkas 1 1 1) @x71 @x70 @x72 false))))))))))))))))))))))))

3f9914c501829bba4f4b416ce311c4f49855326d 26 0
unsat
((set-logic <null>)
(proof
(let ((?x13 (+ |y$| 1)))
(let ((?x14 (* |a$| ?x13)))
(let ((?x12 (* |a$| |x$|)))
(let ((?x15 (+ ?x12 ?x14)))
(let ((?x8 (+ |x$| 1)))
(let ((?x10 (+ ?x8 |y$|)))
(let ((?x11 (* |a$| ?x10)))
(let (($x16 (= ?x11 ?x15)))
(let (($x17 (not $x16)))
(let (($x80 (= (= (+ |a$| ?x12 (* |a$| |y$|)) (+ |a$| ?x12 (* |a$| |y$|))) true)))
(let (($x78 (= $x16 (= (+ |a$| ?x12 (* |a$| |y$|)) (+ |a$| ?x12 (* |a$| |y$|))))))
(let ((@x74 (rewrite (= (+ ?x12 (+ |a$| (* |a$| |y$|))) (+ |a$| ?x12 (* |a$| |y$|))))))
(let ((@x64 (monotonicity (rewrite (= ?x13 (+ 1 |y$|))) (= ?x14 (* |a$| (+ 1 |y$|))))))
(let ((@x69 (trans @x64 (rewrite (= (* |a$| (+ 1 |y$|)) (+ |a$| (* |a$| |y$|)))) (= ?x14 (+ |a$| (* |a$| |y$|))))))
(let ((@x76 (trans (monotonicity @x69 (= ?x15 (+ ?x12 (+ |a$| (* |a$| |y$|))))) @x74 (= ?x15 (+ |a$| ?x12 (* |a$| |y$|))))))
(let ((@x56 (rewrite (= (* |a$| (+ 1 |x$| |y$|)) (+ |a$| ?x12 (* |a$| |y$|))))))
(let ((@x44 (monotonicity (rewrite (= ?x8 (+ 1 |x$|))) (= ?x10 (+ (+ 1 |x$|) |y$|)))))
(let ((@x49 (trans @x44 (rewrite (= (+ (+ 1 |x$|) |y$|) (+ 1 |x$| |y$|))) (= ?x10 (+ 1 |x$| |y$|)))))
(let ((@x58 (trans (monotonicity @x49 (= ?x11 (* |a$| (+ 1 |x$| |y$|)))) @x56 (= ?x11 (+ |a$| ?x12 (* |a$| |y$|))))))
(let ((@x86 (monotonicity (trans (monotonicity @x58 @x76 $x78) (rewrite $x80) (= $x16 true)) (= $x17 (not true)))))
(let ((@x90 (trans @x86 (rewrite (= (not true) false)) (= $x17 false))))
(mp (asserted $x17) @x90 false))))))))))))))))))))))))

f65cca85cf5c1c666974448574788ae3b34595b7 23 0
unsat
((set-logic <null>)
(proof
(let ((?x14 (* 2.0 |x$|)))
(let ((?x15 (* ?x14 |y$|)))
(let ((?x10 (- 1.0 |y$|)))
(let ((?x11 (* |x$| ?x10)))
(let ((?x8 (+ 1.0 |y$|)))
(let ((?x9 (* |x$| ?x8)))
(let ((?x12 (- ?x9 ?x11)))
(let (($x16 (= ?x12 ?x15)))
(let (($x17 (not $x16)))
(let ((@x71 (rewrite (= (= (* 2.0 (* |x$| |y$|)) (* 2.0 (* |x$| |y$|))) true))))
(let ((?x39 (* |x$| |y$|)))
(let ((?x61 (* 2.0 ?x39)))
(let ((@x54 (rewrite (= (* |x$| (+ 1.0 (* (~ 1.0) |y$|))) (+ |x$| (* (~ 1.0) ?x39))))))
(let ((@x50 (monotonicity (rewrite (= ?x10 (+ 1.0 (* (~ 1.0) |y$|)))) (= ?x11 (* |x$| (+ 1.0 (* (~ 1.0) |y$|)))))))
(let ((@x59 (monotonicity (rewrite (= ?x9 (+ |x$| ?x39))) (trans @x50 @x54 (= ?x11 (+ |x$| (* (~ 1.0) ?x39)))) (= ?x12 (- (+ |x$| ?x39) (+ |x$| (* (~ 1.0) ?x39)))))))
(let ((@x64 (trans @x59 (rewrite (= (- (+ |x$| ?x39) (+ |x$| (* (~ 1.0) ?x39))) ?x61)) (= ?x12 ?x61))))
(let ((@x73 (trans (monotonicity @x64 (rewrite (= ?x15 ?x61)) (= $x16 (= ?x61 ?x61))) @x71 (= $x16 true))))
(let ((@x80 (trans (monotonicity @x73 (= $x17 (not true))) (rewrite (= (not true) false)) (= $x17 false))))
(mp (asserted $x17) @x80 false)))))))))))))))))))))

2643ba95811453f95121cf28c15c748e73c8c127 51 0
unsat
((set-logic <null>)
(proof
(let ((?x25 (+ |b$| |d$|)))
(let ((?x26 (+ ?x25 |e$|)))
(let ((?x8 (+ 1 |p$|)))
(let ((?x27 (* ?x8 ?x26)))
(let ((?x22 (* |d$| |p$|)))
(let ((?x20 (* ?x8 |d$|)))
(let ((?x11 (+ |b$| |e$|)))
(let ((?x18 (* 2 ?x8)))
(let ((?x19 (* ?x18 ?x11)))
(let ((?x21 (+ ?x19 ?x20)))
(let ((?x23 (+ ?x21 ?x22)))
(let ((?x24 (+ |u$| ?x23)))
(let ((?x28 (- ?x24 ?x27)))
(let ((?x15 (* |p$| |d$|)))
(let ((?x12 (* ?x8 ?x11)))
(let ((?x13 (+ |u$| ?x12)))
(let ((?x16 (+ ?x13 ?x15)))
(let (($x29 (= ?x16 ?x28)))
(let (($x30 (not $x29)))
(let ((?x53 (* |p$| |e$|)))
(let ((?x52 (* |p$| |b$|)))
(let ((?x68 (+ |u$| |b$| |e$| ?x15 ?x52 ?x53)))
(let ((?x125 (+ |b$| |e$| |d$| ?x15 ?x52 ?x53)))
(let ((?x83 (* 2 ?x53)))
(let ((?x81 (* 2 ?x52)))
(let ((?x82 (* 2 |e$|)))
(let ((?x80 (* 2 |b$|)))
(let ((?x114 (+ |u$| ?x80 ?x82 |d$| (* 2 ?x15) ?x81 ?x83)))
(let ((@x124 (monotonicity (rewrite (= ?x26 (+ |b$| |e$| |d$|))) (= ?x27 (* ?x8 (+ |b$| |e$| |d$|))))))
(let ((@x129 (trans @x124 (rewrite (= (* ?x8 (+ |b$| |e$| |d$|)) ?x125)) (= ?x27 ?x125))))
(let ((@x116 (rewrite (= (+ |u$| (+ ?x80 ?x82 |d$| (* 2 ?x15) ?x81 ?x83)) ?x114))))
(let ((?x106 (+ ?x80 ?x82 |d$| (* 2 ?x15) ?x81 ?x83)))
(let ((?x95 (+ ?x80 ?x82 |d$| ?x15 ?x81 ?x83)))
(let ((@x86 (rewrite (= (* (+ 2 (* 2 |p$|)) ?x11) (+ ?x80 ?x82 ?x81 ?x83)))))
(let ((@x79 (monotonicity (rewrite (= ?x18 (+ 2 (* 2 |p$|)))) (= ?x19 (* (+ 2 (* 2 |p$|)) ?x11)))))
(let ((@x94 (monotonicity (trans @x79 @x86 (= ?x19 (+ ?x80 ?x82 ?x81 ?x83))) (rewrite (= ?x20 (+ |d$| ?x15))) (= ?x21 (+ (+ ?x80 ?x82 ?x81 ?x83) (+ |d$| ?x15))))))
(let ((@x99 (trans @x94 (rewrite (= (+ (+ ?x80 ?x82 ?x81 ?x83) (+ |d$| ?x15)) ?x95)) (= ?x21 ?x95))))
(let ((@x110 (trans (monotonicity @x99 (rewrite (= ?x22 ?x15)) (= ?x23 (+ ?x95 ?x15))) (rewrite (= (+ ?x95 ?x15) ?x106)) (= ?x23 ?x106))))
(let ((@x118 (trans (monotonicity @x110 (= ?x24 (+ |u$| ?x106))) @x116 (= ?x24 ?x114))))
(let ((@x137 (trans (monotonicity @x118 @x129 (= ?x28 (- ?x114 ?x125))) (rewrite (= (- ?x114 ?x125) ?x68)) (= ?x28 ?x68))))
(let ((@x62 (rewrite (= (+ |u$| (+ |b$| |e$| ?x52 ?x53)) (+ |u$| |b$| |e$| ?x52 ?x53)))))
(let ((@x59 (monotonicity (rewrite (= ?x12 (+ |b$| |e$| ?x52 ?x53))) (= ?x13 (+ |u$| (+ |b$| |e$| ?x52 ?x53))))))
(let ((@x67 (monotonicity (trans @x59 @x62 (= ?x13 (+ |u$| |b$| |e$| ?x52 ?x53))) (= ?x16 (+ (+ |u$| |b$| |e$| ?x52 ?x53) ?x15)))))
(let ((@x72 (trans @x67 (rewrite (= (+ (+ |u$| |b$| |e$| ?x52 ?x53) ?x15) ?x68)) (= ?x16 ?x68))))
(let ((@x143 (trans (monotonicity @x72 @x137 (= $x29 (= ?x68 ?x68))) (rewrite (= (= ?x68 ?x68) true)) (= $x29 true))))
(let ((@x150 (trans (monotonicity @x143 (= $x30 (not true))) (rewrite (= (not true) false)) (= $x30 false))))
(mp (asserted $x30) @x150 false)))))))))))))))))))))))))))))))))))))))))))))))))

9377273e8e637d8916ed13b81bd56a602ea76d29 126 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x7 (|of_nat$| |x$|)))
(let ((?x8 (* 2 ?x7)))
(let ((?x9 (|nat$| ?x8)))
(let ((?x147 (|of_nat$| ?x9)))
(let ((?x160 (* (~ 1) ?x147)))
(let ((?x161 (+ ?x8 ?x160)))
(let (($x177 (<= ?x161 0)))
(let (($x158 (= ?x161 0)))
(let (($x150 (>= ?x7 0)))
(let (($x239 (>= ?x147 1)))
(let (($x237 (= ?x147 1)))
(let ((?x11 (|nat$| 1)))
(let ((?x200 (|of_nat$| ?x11)))
(let (($x201 (= ?x200 1)))
(let (($x128 (forall ((?v0 Int) )(!(let ((?x23 (|nat$| ?v0)))
(let ((?x24 (|of_nat$| ?x23)))
(let (($x25 (= ?x24 ?v0)))
(let (($x66 (>= ?v0 0)))
(let (($x67 (not $x66)))
(or $x67 $x25)))))) :pattern ( (|nat$| ?v0) )))
))
(let (($x73 (forall ((?v0 Int) )(let ((?x23 (|nat$| ?v0)))
(let ((?x24 (|of_nat$| ?x23)))
(let (($x25 (= ?x24 ?v0)))
(let (($x66 (>= ?v0 0)))
(let (($x67 (not $x66)))
(or $x67 $x25)))))))
))
(let ((?x23 (|nat$| ?0)))
(let ((?x24 (|of_nat$| ?x23)))
(let (($x25 (= ?x24 ?0)))
(let (($x66 (>= ?0 0)))
(let (($x67 (not $x66)))
(let (($x70 (or $x67 $x25)))
(let (($x27 (forall ((?v0 Int) )(let ((?x23 (|nat$| ?v0)))
(let ((?x24 (|of_nat$| ?x23)))
(let (($x25 (= ?x24 ?v0)))
(let (($x22 (<= 0 ?v0)))
(=> $x22 $x25))))))
))
(let (($x61 (forall ((?v0 Int) )(let ((?x23 (|nat$| ?v0)))
(let ((?x24 (|of_nat$| ?x23)))
(let (($x25 (= ?x24 ?v0)))
(or (not (<= 0 ?v0)) $x25)))))
))
(let ((@x69 (monotonicity (rewrite (= (<= 0 ?0) $x66)) (= (not (<= 0 ?0)) $x67))))
(let ((@x75 (|quant-intro| (monotonicity @x69 (= (or (not (<= 0 ?0)) $x25) $x70)) (= $x61 $x73))))
(let ((@x60 (rewrite (= (=> (<= 0 ?0) $x25) (or (not (<= 0 ?0)) $x25)))))
(let ((@x78 (mp (asserted $x27) (trans (|quant-intro| @x60 (= $x27 $x61)) @x75 (= $x27 $x73)) $x73)))
(let ((@x133 (mp (|mp~| @x78 (|nnf-pos| (refl (|~| $x70 $x70)) (|~| $x73 $x73)) $x73) (|quant-intro| (refl (= $x70 $x70)) (= $x73 $x128)) $x128)))
(let (($x165 (not $x128)))
(let (($x219 (or $x165 $x201)))
(let ((@x204 (rewrite (= (>= 1 0) true))))
(let ((@x211 (trans (monotonicity @x204 (= (not (>= 1 0)) (not true))) (rewrite (= (not true) false)) (= (not (>= 1 0)) false))))
(let ((@x214 (monotonicity @x211 (= (or (not (>= 1 0)) $x201) (or false $x201)))))
(let ((@x218 (trans @x214 (rewrite (= (or false $x201) $x201)) (= (or (not (>= 1 0)) $x201) $x201))))
(let ((@x223 (monotonicity @x218 (= (or $x165 (or (not (>= 1 0)) $x201)) $x219))))
(let ((@x226 (trans @x223 (rewrite (= $x219 $x219)) (= (or $x165 (or (not (>= 1 0)) $x201)) $x219))))
(let ((@x227 (mp ((_ |quant-inst| 1) (or $x165 (or (not (>= 1 0)) $x201))) @x226 $x219)))
(let (($x12 (= ?x9 ?x11)))
(let ((@x56 (mp (asserted (not (not $x12))) (rewrite (= (not (not $x12)) $x12)) $x12)))
(let ((@x252 (trans (monotonicity @x56 (= ?x147 ?x200)) (|unit-resolution| @x227 @x133 $x201) $x237)))
(let ((@x261 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x239) (not (<= ?x147 0)))) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x237) $x239)) @x252 $x239) (not (<= ?x147 0)))))
(let ((@x265 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x147 0)) (<= ?x147 0))) @x261 (not (= ?x147 0)))))
(let (($x179 (= ?x147 0)))
(let (($x181 (or $x150 $x179)))
(let (($x134 (forall ((?v0 Int) )(!(let ((?x23 (|nat$| ?v0)))
(let ((?x24 (|of_nat$| ?x23)))
(let (($x29 (= ?x24 0)))
(let (($x66 (>= ?v0 0)))
(or $x66 $x29))))) :pattern ( (|nat$| ?v0) )))
))
(let (($x99 (forall ((?v0 Int) )(let ((?x23 (|nat$| ?v0)))
(let ((?x24 (|of_nat$| ?x23)))
(let (($x29 (= ?x24 0)))
(let (($x66 (>= ?v0 0)))
(or $x66 $x29))))))
))
(let ((@x138 (|quant-intro| (refl (= (or $x66 (= ?x24 0)) (or $x66 (= ?x24 0)))) (= $x99 $x134))))
(let ((@x118 (|nnf-pos| (refl (|~| (or $x66 (= ?x24 0)) (or $x66 (= ?x24 0)))) (|~| $x99 $x99))))
(let (($x31 (forall ((?v0 Int) )(let ((?x23 (|nat$| ?v0)))
(let ((?x24 (|of_nat$| ?x23)))
(let (($x29 (= ?x24 0)))
(let (($x28 (< ?v0 0)))
(=> $x28 $x29))))))
))
(let (($x84 (forall ((?v0 Int) )(let ((?x23 (|nat$| ?v0)))
(let ((?x24 (|of_nat$| ?x23)))
(let (($x29 (= ?x24 0)))
(let (($x28 (< ?v0 0)))
(let (($x80 (not $x28)))
(or $x80 $x29)))))))
))
(let (($x29 (= ?x24 0)))
(let (($x96 (or $x66 $x29)))
(let (($x28 (< ?0 0)))
(let (($x80 (not $x28)))
(let (($x81 (or $x80 $x29)))
(let ((@x95 (trans (monotonicity (rewrite (= $x28 $x67)) (= $x80 (not $x67))) (rewrite (= (not $x67) $x66)) (= $x80 $x66))))
(let ((@x103 (trans (|quant-intro| (rewrite (= (=> $x28 $x29) $x81)) (= $x31 $x84)) (|quant-intro| (monotonicity @x95 (= $x81 $x96)) (= $x84 $x99)) (= $x31 $x99))))
(let ((@x139 (mp (|mp~| (mp (asserted $x31) @x103 $x99) @x118 $x99) @x138 $x134)))
(let (($x184 (not $x134)))
(let (($x185 (or $x184 $x150 $x179)))
(let ((@x152 (rewrite (= (>= ?x8 0) $x150))))
(let ((@x190 (monotonicity (monotonicity @x152 (= (or (>= ?x8 0) $x179) $x181)) (= (or $x184 (or (>= ?x8 0) $x179)) (or $x184 $x181)))))
(let ((@x194 (trans @x190 (rewrite (= (or $x184 $x181) $x185)) (= (or $x184 (or (>= ?x8 0) $x179)) $x185))))
(let ((@x195 (mp ((_ |quant-inst| (* 2 ?x7)) (or $x184 (or (>= ?x8 0) $x179))) @x194 $x185)))
(let (($x153 (not $x150)))
(let (($x162 (or $x153 $x158)))
(let (($x166 (or $x165 $x153 $x158)))
(let (($x148 (= ?x147 ?x8)))
(let (($x142 (>= ?x8 0)))
(let (($x143 (not $x142)))
(let (($x149 (or $x143 $x148)))
(let (($x167 (or $x165 $x149)))
(let ((@x164 (monotonicity (monotonicity @x152 (= $x143 $x153)) (rewrite (= $x148 $x158)) (= $x149 $x162))))
(let ((@x175 (trans (monotonicity @x164 (= $x167 (or $x165 $x162))) (rewrite (= (or $x165 $x162) $x166)) (= $x167 $x166))))
(let ((@x176 (mp ((_ |quant-inst| (* 2 ?x7)) $x167) @x175 $x166)))
(let ((@x269 (|unit-resolution| (|unit-resolution| @x176 @x133 $x162) (|unit-resolution| (|unit-resolution| @x195 @x139 $x181) @x265 $x150) $x158)))
(let (($x178 (>= ?x161 0)))
(let (($x238 (<= ?x147 1)))
((_ |th-lemma| arith gcd-test -1/2 -1/2 -1/2 -1/2) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x237) $x239)) @x252 $x239) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x237) $x238)) @x252 $x238) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x158) $x178)) @x269 $x178) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x158) $x177)) @x269 $x177) false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

7540f10f61e5a987b0848b309bd25f2a2ae1cd0a 22 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x6 (|of_nat$| |a$|)))
(let (($x71 (>= ?x6 4)))
(let (($x78 (not (or (>= ?x6 3) (not $x71)))))
(let (($x12 (< (* 2 ?x6) 7)))
(let (($x8 (< ?x6 3)))
(let (($x52 (not $x8)))
(let (($x53 (or $x52 $x12)))
(let ((@x65 (monotonicity (rewrite (= $x8 (not (>= ?x6 3)))) (= $x52 (not (not (>= ?x6 3)))))))
(let ((@x69 (trans @x65 (rewrite (= (not (not (>= ?x6 3))) (>= ?x6 3))) (= $x52 (>= ?x6 3)))))
(let ((@x77 (monotonicity @x69 (rewrite (= $x12 (not $x71))) (= $x53 (or (>= ?x6 3) (not $x71))))))
(let ((@x58 (monotonicity (rewrite (= (=> $x8 $x12) $x53)) (= (not (=> $x8 $x12)) (not $x53)))))
(let ((@x82 (trans @x58 (monotonicity @x77 (= (not $x53) $x78)) (= (not (=> $x8 $x12)) $x78))))
(let ((@x85 (|not-or-elim| (mp (asserted (not (=> $x8 $x12))) @x82 $x78) $x71)))
(let (($x72 (not $x71)))
(let (($x61 (>= ?x6 3)))
(let (($x59 (not $x61)))
(let ((@x84 (|not-or-elim| (mp (asserted (not (=> $x8 $x12))) @x82 $x78) $x59)))
(|unit-resolution| (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x72 $x61)) @x84 $x72) @x85 false))))))))))))))))))))

3a9a1f0f87885c249813dfb78d14e1062fc20ce3 147 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x8 (|of_nat$| |y$|)))
(let ((?x9 (+ 1 ?x8)))
(let ((?x10 (|nat$| ?x9)))
(let ((?x11 (|of_nat$| ?x10)))
(let ((?x57 (* (~ 1) ?x8)))
(let ((?x58 (+ ?x57 ?x11)))
(let ((?x61 (|nat$| ?x58)))
(let ((?x64 (|of_nat$| ?x61)))
(let ((?x195 (* (~ 1) ?x11)))
(let ((?x246 (+ ?x8 ?x195 ?x64)))
(let (($x265 (>= ?x246 0)))
(let (($x247 (= ?x246 0)))
(let ((?x196 (+ ?x8 ?x195)))
(let (($x240 (<= ?x196 0)))
(let (($x215 (<= ?x196 (~ 1))))
(let (($x197 (= ?x196 (~ 1))))
(let (($x189 (>= ?x8 (~ 1))))
(let (($x283 (>= ?x8 0)))
(let ((?x172 (|nat$| ?x8)))
(let ((?x284 (|of_nat$| ?x172)))
(let (($x285 (= ?x284 0)))
(let (($x286 (or $x283 $x285)))
(let (($x166 (forall ((?v0 Int) )(!(let ((?x25 (|nat$| ?v0)))
(let ((?x26 (|of_nat$| ?x25)))
(let (($x31 (= ?x26 0)))
(let (($x97 (>= ?v0 0)))
(or $x97 $x31))))) :pattern ( (|nat$| ?v0) )))
))
(let (($x131 (forall ((?v0 Int) )(let ((?x25 (|nat$| ?v0)))
(let ((?x26 (|of_nat$| ?x25)))
(let (($x31 (= ?x26 0)))
(let (($x97 (>= ?v0 0)))
(or $x97 $x31))))))
))
(let ((?x25 (|nat$| ?0)))
(let ((?x26 (|of_nat$| ?x25)))
(let (($x31 (= ?x26 0)))
(let (($x97 (>= ?0 0)))
(let (($x128 (or $x97 $x31)))
(let (($x33 (forall ((?v0 Int) )(let ((?x25 (|nat$| ?v0)))
(let ((?x26 (|of_nat$| ?x25)))
(let (($x31 (= ?x26 0)))
(let (($x30 (< ?v0 0)))
(=> $x30 $x31))))))
))
(let (($x116 (forall ((?v0 Int) )(let ((?x25 (|nat$| ?v0)))
(let ((?x26 (|of_nat$| ?x25)))
(let (($x31 (= ?x26 0)))
(let (($x30 (< ?v0 0)))
(let (($x112 (not $x30)))
(or $x112 $x31)))))))
))
(let ((@x123 (monotonicity (rewrite (= (< ?0 0) (not $x97))) (= (not (< ?0 0)) (not (not $x97))))))
(let ((@x127 (trans @x123 (rewrite (= (not (not $x97)) $x97)) (= (not (< ?0 0)) $x97))))
(let ((@x133 (|quant-intro| (monotonicity @x127 (= (or (not (< ?0 0)) $x31) $x128)) (= $x116 $x131))))
(let ((@x115 (rewrite (= (=> (< ?0 0) $x31) (or (not (< ?0 0)) $x31)))))
(let ((@x136 (mp (asserted $x33) (trans (|quant-intro| @x115 (= $x33 $x116)) @x133 (= $x33 $x131)) $x131)))
(let ((@x171 (mp (|mp~| @x136 (|nnf-pos| (refl (|~| $x128 $x128)) (|~| $x131 $x131)) $x131) (|quant-intro| (refl (= $x128 $x128)) (= $x131 $x166)) $x166)))
(let (($x222 (not $x166)))
(let (($x289 (or $x222 $x283 $x285)))
(let ((@x294 (mp ((_ |quant-inst| (|of_nat$| |y$|)) (or $x222 $x286)) (rewrite (= (or $x222 $x286) $x289)) $x289)))
(let ((@x316 (|unit-resolution| (|unit-resolution| @x294 @x171 $x286) (hypothesis (not $x283)) $x285)))
(let (($x173 (= ?x172 |y$|)))
(let (($x153 (forall ((?v0 |Nat$|) )(!(= (|nat$| (|of_nat$| ?v0)) ?v0) :pattern ( (|of_nat$| ?v0) )))
))
(let (($x22 (forall ((?v0 |Nat$|) )(= (|nat$| (|of_nat$| ?v0)) ?v0))
))
(let ((@x155 (refl (= (= (|nat$| (|of_nat$| ?0)) ?0) (= (|nat$| (|of_nat$| ?0)) ?0)))))
(let ((@x140 (refl (|~| (= (|nat$| (|of_nat$| ?0)) ?0) (= (|nat$| (|of_nat$| ?0)) ?0)))))
(let ((@x158 (mp (|mp~| (asserted $x22) (|nnf-pos| @x140 (|~| $x22 $x22)) $x22) (|quant-intro| @x155 (= $x22 $x153)) $x153)))
(let (($x176 (not $x153)))
(let (($x177 (or $x176 $x173)))
(let ((@x178 ((_ |quant-inst| |y$|) $x177)))
(let ((@x321 (monotonicity (symm (|unit-resolution| @x178 @x158 $x173) (= |y$| ?x172)) (= ?x8 ?x284))))
(let ((@x326 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x8 0)) $x283)) (hypothesis (not $x283)) (trans @x321 @x316 (= ?x8 0)) false)))
(let ((@x329 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x283) $x189)) (lemma @x326 $x283) $x189)))
(let (($x192 (not $x189)))
(let (($x200 (or $x192 $x197)))
(let (($x160 (forall ((?v0 Int) )(!(let ((?x25 (|nat$| ?v0)))
(let ((?x26 (|of_nat$| ?x25)))
(let (($x27 (= ?x26 ?v0)))
(let (($x97 (>= ?v0 0)))
(let (($x99 (not $x97)))
(or $x99 $x27)))))) :pattern ( (|nat$| ?v0) )))
))
(let (($x105 (forall ((?v0 Int) )(let ((?x25 (|nat$| ?v0)))
(let ((?x26 (|of_nat$| ?x25)))
(let (($x27 (= ?x26 ?v0)))
(let (($x97 (>= ?v0 0)))
(let (($x99 (not $x97)))
(or $x99 $x27)))))))
))
(let ((@x162 (refl (= (or (not $x97) (= ?x26 ?0)) (or (not $x97) (= ?x26 ?0))))))
(let ((@x143 (refl (|~| (or (not $x97) (= ?x26 ?0)) (or (not $x97) (= ?x26 ?0))))))
(let (($x29 (forall ((?v0 Int) )(let ((?x25 (|nat$| ?v0)))
(let ((?x26 (|of_nat$| ?x25)))
(let (($x27 (= ?x26 ?v0)))
(let (($x24 (<= 0 ?v0)))
(=> $x24 $x27))))))
))
(let (($x93 (forall ((?v0 Int) )(let ((?x25 (|nat$| ?v0)))
(let ((?x26 (|of_nat$| ?x25)))
(let (($x27 (= ?x26 ?v0)))
(or (not (<= 0 ?v0)) $x27)))))
))
(let (($x27 (= ?x26 ?0)))
(let (($x99 (not $x97)))
(let (($x102 (or $x99 $x27)))
(let (($x90 (or (not (<= 0 ?0)) $x27)))
(let ((@x101 (monotonicity (rewrite (= (<= 0 ?0) $x97)) (= (not (<= 0 ?0)) $x99))))
(let ((@x95 (|quant-intro| (rewrite (= (=> (<= 0 ?0) $x27) $x90)) (= $x29 $x93))))
(let ((@x109 (trans @x95 (|quant-intro| (monotonicity @x101 (= $x90 $x102)) (= $x93 $x105)) (= $x29 $x105))))
(let ((@x146 (|mp~| (mp (asserted $x29) @x109 $x105) (|nnf-pos| @x143 (|~| $x105 $x105)) $x105)))
(let ((@x165 (mp @x146 (|quant-intro| @x162 (= $x105 $x160)) $x160)))
(let (($x203 (not $x160)))
(let (($x204 (or $x203 $x192 $x197)))
(let (($x188 (or (not (>= ?x9 0)) (= ?x11 ?x9))))
(let (($x205 (or $x203 $x188)))
(let ((@x194 (monotonicity (rewrite (= (>= ?x9 0) $x189)) (= (not (>= ?x9 0)) $x192))))
(let ((@x202 (monotonicity @x194 (rewrite (= (= ?x11 ?x9) $x197)) (= $x188 $x200))))
(let ((@x213 (trans (monotonicity @x202 (= $x205 (or $x203 $x200))) (rewrite (= (or $x203 $x200) $x204)) (= $x205 $x204))))
(let ((@x214 (mp ((_ |quant-inst| (+ 1 ?x8)) $x205) @x213 $x204)))
(let ((@x335 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x197) $x215)) (|unit-resolution| (|unit-resolution| @x214 @x165 $x200) @x329 $x197) $x215)))
(let (($x243 (not $x240)))
(let (($x250 (or $x243 $x247)))
(let (($x253 (or $x203 $x243 $x247)))
(let (($x239 (or (not (>= ?x58 0)) (= ?x64 ?x58))))
(let (($x254 (or $x203 $x239)))
(let ((@x245 (monotonicity (rewrite (= (>= ?x58 0) $x240)) (= (not (>= ?x58 0)) $x243))))
(let ((@x252 (monotonicity @x245 (rewrite (= (= ?x64 ?x58) $x247)) (= $x239 $x250))))
(let ((@x262 (trans (monotonicity @x252 (= $x254 (or $x203 $x250))) (rewrite (= (or $x203 $x250) $x253)) (= $x254 $x253))))
(let ((@x263 (mp ((_ |quant-inst| (+ ?x57 ?x11)) $x254) @x262 $x253)))
(let ((@x341 (|unit-resolution| (|unit-resolution| @x263 @x165 $x250) (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x215) $x240)) @x335 $x240) $x247)))
(let (($x73 (<= ?x64 0)))
(let ((@x79 (monotonicity (rewrite (= (< 0 ?x64) (not $x73))) (= (not (< 0 ?x64)) (not (not $x73))))))
(let ((@x83 (trans @x79 (rewrite (= (not (not $x73)) $x73)) (= (not (< 0 ?x64)) $x73))))
(let (($x67 (< 0 ?x64)))
(let (($x70 (not $x67)))
(let (($x17 (not (< (* 0 ?x11) (|of_nat$| (|nat$| (- ?x11 ?x8)))))))
(let ((@x63 (monotonicity (rewrite (= (- ?x11 ?x8) ?x58)) (= (|nat$| (- ?x11 ?x8)) ?x61))))
(let ((@x69 (monotonicity (rewrite (= (* 0 ?x11) 0)) (monotonicity @x63 (= (|of_nat$| (|nat$| (- ?x11 ?x8))) ?x64)) (= (< (* 0 ?x11) (|of_nat$| (|nat$| (- ?x11 ?x8)))) $x67))))
(let ((@x86 (mp (asserted $x17) (trans (monotonicity @x69 (= $x17 $x70)) @x83 (= $x17 $x73)) $x73)))
((_ |th-lemma| arith farkas -1 -1 1) @x86 @x335 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x247) $x265)) @x341 $x265) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

72e646f619a773762ccf2e62425eb512a9cd35f3 144 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x8 (|of_nat$| |y$|)))
(let ((?x9 (+ 1 ?x8)))
(let ((?x10 (|nat$| ?x9)))
(let ((?x11 (|of_nat$| ?x10)))
(let ((?x62 (+ (~ 1) ?x11)))
(let ((?x65 (|nat$| ?x62)))
(let ((?x281 (|of_nat$| ?x65)))
(let ((?x291 (* (~ 1) ?x281)))
(let ((?x330 (+ ?x8 ?x291)))
(let (($x332 (>= ?x330 0)))
(let (($x329 (= ?x8 ?x281)))
(let (($x68 (= ?x65 |y$|)))
(let (($x102 (<= ?x11 0)))
(let (($x112 (not (or (= (not $x102) $x68) (not $x102)))))
(let (($x19 (=> (not (ite (< 0 ?x11) true false)) false)))
(let (($x12 (< 0 ?x11)))
(let (($x13 (ite $x12 true false)))
(let (($x17 (= $x13 (= (|nat$| (- ?x11 1)) |y$|))))
(let (($x21 (or false (or $x17 $x19))))
(let (($x22 (not $x21)))
(let (($x74 (= $x12 $x68)))
(let (($x89 (or $x74 $x12)))
(let ((@x108 (monotonicity (rewrite (= $x12 (not $x102))) (= $x74 (= (not $x102) $x68)))))
(let ((@x111 (monotonicity @x108 (rewrite (= $x12 (not $x102))) (= $x89 (or (= (not $x102) $x68) (not $x102))))))
(let ((@x84 (monotonicity (monotonicity (rewrite (= $x13 $x12)) (= (not $x13) (not $x12))) (= $x19 (=> (not $x12) false)))))
(let ((@x88 (trans @x84 (rewrite (= (=> (not $x12) false) $x12)) (= $x19 $x12))))
(let ((@x67 (monotonicity (rewrite (= (- ?x11 1) ?x62)) (= (|nat$| (- ?x11 1)) ?x65))))
(let ((@x73 (monotonicity (rewrite (= $x13 $x12)) (monotonicity @x67 (= (= (|nat$| (- ?x11 1)) |y$|) $x68)) (= $x17 (= $x12 $x68)))))
(let ((@x91 (monotonicity (trans @x73 (rewrite (= (= $x12 $x68) $x74)) (= $x17 $x74)) @x88 (= (or $x17 $x19) $x89))))
(let ((@x98 (trans (monotonicity @x91 (= $x21 (or false $x89))) (rewrite (= (or false $x89) $x89)) (= $x21 $x89))))
(let ((@x116 (trans (monotonicity @x98 (= $x22 (not $x89))) (monotonicity @x111 (= (not $x89) $x112)) (= $x22 $x112))))
(let ((@x120 (|not-or-elim| (mp (asserted $x22) @x116 $x112) $x102)))
(let (($x171 (= $x102 $x68)))
(let ((@x119 (|not-or-elim| (mp (asserted $x22) @x116 $x112) (not (= (not $x102) $x68)))))
(let ((@x173 (mp @x119 (rewrite (= (not (= (not $x102) $x68)) $x171)) $x171)))
(let ((@x219 (|unit-resolution| (|def-axiom| (or (not $x102) $x68 (not $x171))) @x173 (or (not $x102) $x68))))
(let ((@x345 (monotonicity (symm (|unit-resolution| @x219 @x120 $x68) (= |y$| ?x65)) $x329)))
(let ((?x241 (* (~ 1) ?x11)))
(let ((?x242 (+ ?x8 ?x241)))
(let (($x259 (<= ?x242 (~ 1))))
(let (($x240 (= ?x242 (~ 1))))
(let (($x233 (>= ?x8 (~ 1))))
(let (($x328 (>= ?x281 0)))
(let (($x311 (= ?x281 0)))
(let (($x284 (>= ?x11 1)))
(let (($x287 (not $x284)))
(let (($x204 (forall ((?v0 Int) )(!(let ((?x30 (|nat$| ?v0)))
(let ((?x31 (|of_nat$| ?x30)))
(let (($x36 (= ?x31 0)))
(let (($x131 (>= ?v0 0)))
(or $x131 $x36))))) :pattern ( (|nat$| ?v0) )))
))
(let (($x165 (forall ((?v0 Int) )(let ((?x30 (|nat$| ?v0)))
(let ((?x31 (|of_nat$| ?x30)))
(let (($x36 (= ?x31 0)))
(let (($x131 (>= ?v0 0)))
(or $x131 $x36))))))
))
(let ((?x30 (|nat$| ?0)))
(let ((?x31 (|of_nat$| ?x30)))
(let (($x36 (= ?x31 0)))
(let (($x131 (>= ?0 0)))
(let (($x162 (or $x131 $x36)))
(let (($x38 (forall ((?v0 Int) )(let ((?x30 (|nat$| ?v0)))
(let ((?x31 (|of_nat$| ?x30)))
(let (($x36 (= ?x31 0)))
(let (($x35 (< ?v0 0)))
(=> $x35 $x36))))))
))
(let (($x150 (forall ((?v0 Int) )(let ((?x30 (|nat$| ?v0)))
(let ((?x31 (|of_nat$| ?x30)))
(let (($x36 (= ?x31 0)))
(let (($x35 (< ?v0 0)))
(let (($x146 (not $x35)))
(or $x146 $x36)))))))
))
(let ((@x157 (monotonicity (rewrite (= (< ?0 0) (not $x131))) (= (not (< ?0 0)) (not (not $x131))))))
(let ((@x161 (trans @x157 (rewrite (= (not (not $x131)) $x131)) (= (not (< ?0 0)) $x131))))
(let ((@x167 (|quant-intro| (monotonicity @x161 (= (or (not (< ?0 0)) $x36) $x162)) (= $x150 $x165))))
(let ((@x149 (rewrite (= (=> (< ?0 0) $x36) (or (not (< ?0 0)) $x36)))))
(let ((@x170 (mp (asserted $x38) (trans (|quant-intro| @x149 (= $x38 $x150)) @x167 (= $x38 $x165)) $x165)))
(let ((@x209 (mp (|mp~| @x170 (|nnf-pos| (refl (|~| $x162 $x162)) (|~| $x165 $x165)) $x165) (|quant-intro| (refl (= $x162 $x162)) (= $x165 $x204)) $x204)))
(let (($x266 (not $x204)))
(let (($x316 (or $x266 $x284 $x311)))
(let ((@x286 (rewrite (= (>= ?x62 0) $x284))))
(let ((@x321 (monotonicity (monotonicity @x286 (= (or (>= ?x62 0) $x311) (or $x284 $x311))) (= (or $x266 (or (>= ?x62 0) $x311)) (or $x266 (or $x284 $x311))))))
(let ((@x325 (trans @x321 (rewrite (= (or $x266 (or $x284 $x311)) $x316)) (= (or $x266 (or (>= ?x62 0) $x311)) $x316))))
(let ((@x326 (mp ((_ |quant-inst| (+ (~ 1) ?x11)) (or $x266 (or (>= ?x62 0) $x311))) @x325 $x316)))
(let ((@x353 (|unit-resolution| @x326 @x209 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x287 (not $x102))) @x120 $x287) $x311)))
(let ((@x362 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1) (or $x233 (not $x328) (not $x332))) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x311) $x328)) @x353 $x328) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x329) $x332)) @x345 $x332) $x233)))
(let (($x236 (not $x233)))
(let (($x244 (or $x236 $x240)))
(let (($x198 (forall ((?v0 Int) )(!(let ((?x30 (|nat$| ?v0)))
(let ((?x31 (|of_nat$| ?x30)))
(let (($x32 (= ?x31 ?v0)))
(let (($x131 (>= ?v0 0)))
(let (($x133 (not $x131)))
(or $x133 $x32)))))) :pattern ( (|nat$| ?v0) )))
))
(let (($x139 (forall ((?v0 Int) )(let ((?x30 (|nat$| ?v0)))
(let ((?x31 (|of_nat$| ?x30)))
(let (($x32 (= ?x31 ?v0)))
(let (($x131 (>= ?v0 0)))
(let (($x133 (not $x131)))
(or $x133 $x32)))))))
))
(let ((@x200 (refl (= (or (not $x131) (= ?x31 ?0)) (or (not $x131) (= ?x31 ?0))))))
(let ((@x181 (refl (|~| (or (not $x131) (= ?x31 ?0)) (or (not $x131) (= ?x31 ?0))))))
(let (($x34 (forall ((?v0 Int) )(let ((?x30 (|nat$| ?v0)))
(let ((?x31 (|of_nat$| ?x30)))
(let (($x32 (= ?x31 ?v0)))
(let (($x29 (<= 0 ?v0)))
(=> $x29 $x32))))))
))
(let (($x127 (forall ((?v0 Int) )(let ((?x30 (|nat$| ?v0)))
(let ((?x31 (|of_nat$| ?x30)))
(let (($x32 (= ?x31 ?v0)))
(or (not (<= 0 ?v0)) $x32)))))
))
(let (($x32 (= ?x31 ?0)))
(let (($x133 (not $x131)))
(let (($x136 (or $x133 $x32)))
(let (($x124 (or (not (<= 0 ?0)) $x32)))
(let ((@x135 (monotonicity (rewrite (= (<= 0 ?0) $x131)) (= (not (<= 0 ?0)) $x133))))
(let ((@x129 (|quant-intro| (rewrite (= (=> (<= 0 ?0) $x32) $x124)) (= $x34 $x127))))
(let ((@x143 (trans @x129 (|quant-intro| (monotonicity @x135 (= $x124 $x136)) (= $x127 $x139)) (= $x34 $x139))))
(let ((@x184 (|mp~| (mp (asserted $x34) @x143 $x139) (|nnf-pos| @x181 (|~| $x139 $x139)) $x139)))
(let ((@x203 (mp @x184 (|quant-intro| @x200 (= $x139 $x198)) $x198)))
(let (($x247 (not $x198)))
(let (($x248 (or $x247 $x236 $x240)))
(let (($x231 (= ?x11 ?x9)))
(let (($x227 (>= ?x9 0)))
(let (($x228 (not $x227)))
(let (($x232 (or $x228 $x231)))
(let (($x249 (or $x247 $x232)))
(let ((@x246 (monotonicity (monotonicity (rewrite (= $x227 $x233)) (= $x228 $x236)) (rewrite (= $x231 $x240)) (= $x232 $x244))))
(let ((@x257 (trans (monotonicity @x246 (= $x249 (or $x247 $x244))) (rewrite (= (or $x247 $x244) $x248)) (= $x249 $x248))))
(let ((@x258 (mp ((_ |quant-inst| (+ 1 ?x8)) $x249) @x257 $x248)))
(let ((@x368 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x240) $x259)) (|unit-resolution| (|unit-resolution| @x258 @x203 $x244) @x362 $x240) $x259)))
((_ |th-lemma| arith farkas 1 -1 -1 1) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x311) $x328)) @x353 $x328) @x120 @x368 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x329) $x332)) @x345 $x332) false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

bda6be21dc699a816acc75c786757ad36dd913c8 78 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x51 (* (~ 1) |x$|)))
(let (($x69 (>= |x$| 0)))
(let ((?x76 (ite $x69 |x$| ?x51)))
(let ((?x213 (* (~ 1) ?x76)))
(let ((?x216 (+ ?x51 ?x213)))
(let (($x226 (<= ?x216 0)))
(let (($x182 (= ?x51 ?x76)))
(let (($x70 (not $x69)))
(let (($x181 (= |x$| ?x76)))
(let ((@x222 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x181) (<= (+ |x$| ?x213) 0))) (|unit-resolution| (|def-axiom| (or $x70 $x181)) (hypothesis $x69) $x181) (<= (+ |x$| ?x213) 0))))
(let (($x189 (>= ?x76 0)))
(let (($x190 (not $x189)))
(let (($x169 (forall ((?v0 Int) )(!(let ((?x21 (|nat$| ?v0)))
(let ((?x22 (|of_nat$| ?x21)))
(let (($x23 (= ?x22 ?v0)))
(let (($x106 (>= ?v0 0)))
(let (($x108 (not $x106)))
(or $x108 $x23)))))) :pattern ( (|nat$| ?v0) )))
))
(let (($x114 (forall ((?v0 Int) )(let ((?x21 (|nat$| ?v0)))
(let ((?x22 (|of_nat$| ?x21)))
(let (($x23 (= ?x22 ?v0)))
(let (($x106 (>= ?v0 0)))
(let (($x108 (not $x106)))
(or $x108 $x23)))))))
))
(let ((?x21 (|nat$| ?0)))
(let ((?x22 (|of_nat$| ?x21)))
(let (($x23 (= ?x22 ?0)))
(let (($x106 (>= ?0 0)))
(let (($x108 (not $x106)))
(let (($x111 (or $x108 $x23)))
(let (($x25 (forall ((?v0 Int) )(let ((?x21 (|nat$| ?v0)))
(let ((?x22 (|of_nat$| ?x21)))
(let (($x23 (= ?x22 ?v0)))
(let (($x20 (<= 0 ?v0)))
(=> $x20 $x23))))))
))
(let (($x102 (forall ((?v0 Int) )(let ((?x21 (|nat$| ?v0)))
(let ((?x22 (|of_nat$| ?x21)))
(let (($x23 (= ?x22 ?v0)))
(or (not (<= 0 ?v0)) $x23)))))
))
(let ((@x110 (monotonicity (rewrite (= (<= 0 ?0) $x106)) (= (not (<= 0 ?0)) $x108))))
(let ((@x116 (|quant-intro| (monotonicity @x110 (= (or (not (<= 0 ?0)) $x23) $x111)) (= $x102 $x114))))
(let ((@x101 (rewrite (= (=> (<= 0 ?0) $x23) (or (not (<= 0 ?0)) $x23)))))
(let ((@x119 (mp (asserted $x25) (trans (|quant-intro| @x101 (= $x25 $x102)) @x116 (= $x25 $x114)) $x114)))
(let ((@x174 (mp (|mp~| @x119 (|nnf-pos| (refl (|~| $x111 $x111)) (|~| $x114 $x114)) $x114) (|quant-intro| (refl (= $x111 $x111)) (= $x114 $x169)) $x169)))
(let ((?x81 (|nat$| ?x76)))
(let ((?x84 (|of_nat$| ?x81)))
(let (($x87 (= ?x84 ?x76)))
(let (($x90 (not $x87)))
(let (($x7 (< |x$| 0)))
(let ((?x9 (ite $x7 (- |x$|) |x$|)))
(let (($x13 (not (= (|of_nat$| (|nat$| ?x9)) ?x9))))
(let (($x91 (= (not (= (|of_nat$| (|nat$| (ite $x7 ?x51 |x$|))) (ite $x7 ?x51 |x$|))) $x90)))
(let ((?x54 (ite $x7 ?x51 |x$|)))
(let ((?x57 (|nat$| ?x54)))
(let ((?x60 (|of_nat$| ?x57)))
(let (($x63 (= ?x60 ?x54)))
(let ((@x80 (trans (monotonicity (rewrite (= $x7 $x70)) (= ?x54 (ite $x70 ?x51 |x$|))) (rewrite (= (ite $x70 ?x51 |x$|) ?x76)) (= ?x54 ?x76))))
(let ((@x89 (monotonicity (monotonicity (monotonicity @x80 (= ?x57 ?x81)) (= ?x60 ?x84)) @x80 (= $x63 $x87))))
(let ((@x59 (monotonicity (monotonicity (rewrite (= (- |x$|) ?x51)) (= ?x9 ?x54)) (= (|nat$| ?x9) ?x57))))
(let ((@x65 (monotonicity (monotonicity @x59 (= (|of_nat$| (|nat$| ?x9)) ?x60)) (monotonicity (rewrite (= (- |x$|) ?x51)) (= ?x9 ?x54)) (= (= (|of_nat$| (|nat$| ?x9)) ?x9) $x63))))
(let ((@x94 (trans (monotonicity @x65 (= $x13 (not $x63))) (monotonicity @x89 $x91) (= $x13 $x90))))
(let ((@x95 (mp (asserted $x13) @x94 $x90)))
(let (($x198 (or (not $x169) $x190 $x87)))
(let ((@x203 (mp ((_ |quant-inst| (ite $x69 |x$| ?x51)) (or (not $x169) (or $x190 $x87))) (rewrite (= (or (not $x169) (or $x190 $x87)) $x198)) $x198)))
(let ((@x224 ((_ |th-lemma| arith farkas -1 1 1) (hypothesis $x69) (|unit-resolution| @x203 @x95 @x174 $x190) @x222 false)))
(let ((@x225 (lemma @x224 $x70)))
(let ((@x232 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x182) $x226)) (|unit-resolution| (|def-axiom| (or $x69 $x182)) @x225 $x182) $x226)))
(let (($x205 (<= ?x76 0)))
(let ((@x235 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or $x205 $x189)) (|unit-resolution| @x203 @x95 @x174 $x190) $x205)))
((_ |th-lemma| arith farkas 1 1 1) @x235 @x225 @x232 false)))))))))))))))))))))))))))))))))))))))))))))))))))))))

777f9032b35b7e1c0dce62f13109424c73d5d094 312 0
unsat
((set-logic AUFLIA)
(declare-fun ?v1!0 (|Nat$|) |Nat$|)
(proof
(let ((?x23 (|of_nat$| |m$|)))
(let ((?x24 (* 4 ?x23)))
(let ((?x110 (+ 1 ?x24)))
(let ((?x113 (|nat$| ?x110)))
(let ((?x344 (|of_nat$| ?x113)))
(let ((?x491 (* (~ 1) ?x344)))
(let ((?x492 (+ ?x24 ?x491)))
(let (($x509 (>= ?x492 (~ 1))))
(let (($x489 (= ?x492 (~ 1))))
(let (($x481 (>= ?x23 0)))
(let (($x345 (<= ?x344 1)))
(let (($x373 (not $x345)))
(let (($x351 (forall ((?v1 |Nat$|) )(!(let ((?x23 (|of_nat$| |m$|)))
(let ((?x24 (* 4 ?x23)))
(let ((?x110 (+ 1 ?x24)))
(let ((?x113 (|nat$| ?x110)))
(let (($x348 (= ?v1 ?x113)))
(let ((?x12 (|nat$| 1)))
(let (($x13 (= ?v1 ?x12)))
(let (($x346 (|dvd$| ?v1 ?x113)))
(let (($x347 (not $x346)))
(or $x347 $x13 $x348)))))))))) :pattern ( (|dvd$| ?v1 (|nat$| (+ 1 (* 4 (|of_nat$| |m$|))))) )))
))
(let (($x352 (not $x351)))
(let (($x353 (or $x345 $x352)))
(let (($x354 (not $x353)))
(let (($x116 (|prime_nat$| ?x113)))
(let (($x122 (not $x116)))
(let (($x355 (or $x122 $x354)))
(let ((?x357 (?v1!0 ?x113)))
(let (($x361 (= ?x357 ?x113)))
(let ((?x12 (|nat$| 1)))
(let (($x360 (= ?x357 ?x12)))
(let (($x358 (|dvd$| ?x357 ?x113)))
(let (($x359 (not $x358)))
(let (($x362 (or $x359 $x360 $x361)))
(let (($x363 (not $x362)))
(let (($x364 (or $x116 $x345 $x363)))
(let (($x365 (not $x364)))
(let (($x356 (not $x355)))
(let (($x366 (or $x356 $x365)))
(let (($x367 (not $x366)))
(let (($x321 (forall ((?v0 |Nat$|) )(!(let (($x217 (or (not (|dvd$| (?v1!0 ?v0) ?v0)) (= (?v1!0 ?v0) (|nat$| 1)) (= (?v1!0 ?v0) ?v0))))
(let (($x218 (not $x217)))
(let ((?x8 (|of_nat$| ?v0)))
(let (($x87 (<= ?x8 1)))
(let (($x6 (|prime_nat$| ?v0)))
(let (($x245 (or $x6 $x87 $x218)))
(let (($x293 (forall ((?v1 |Nat$|) )(!(let ((?x12 (|nat$| 1)))
(let (($x13 (= ?v1 ?x12)))
(or (not (|dvd$| ?v1 ?v0)) $x13 (= ?v1 ?v0)))) :pattern ( (|dvd$| ?v1 ?v0) )))
))
(let (($x198 (not $x6)))
(not (or (not (or $x198 (not (or $x87 (not $x293))))) (not $x245))))))))))) :pattern ( (|prime_nat$| ?v0) ) :pattern ( (|of_nat$| ?v0) )))
))
(let (($x288 (forall ((?v0 |Nat$|) )(let (($x217 (or (not (|dvd$| (?v1!0 ?v0) ?v0)) (= (?v1!0 ?v0) (|nat$| 1)) (= (?v1!0 ?v0) ?v0))))
(let (($x218 (not $x217)))
(let ((?x8 (|of_nat$| ?v0)))
(let (($x87 (<= ?x8 1)))
(let (($x6 (|prime_nat$| ?v0)))
(let (($x245 (or $x6 $x87 $x218)))
(let (($x94 (forall ((?v1 |Nat$|) )(let ((?x12 (|nat$| 1)))
(let (($x13 (= ?v1 ?x12)))
(or (not (|dvd$| ?v1 ?v0)) $x13 (= ?v1 ?v0)))))
))
(let (($x219 (not $x94)))
(let (($x271 (not (or $x87 $x219))))
(let (($x198 (not $x6)))
(let (($x274 (or $x198 $x271)))
(not (or (not $x274) (not $x245)))))))))))))))
))
(let (($x217 (or (not (|dvd$| (?v1!0 ?0) ?0)) (= (?v1!0 ?0) ?x12) (= (?v1!0 ?0) ?0))))
(let (($x218 (not $x217)))
(let ((?x8 (|of_nat$| ?0)))
(let (($x87 (<= ?x8 1)))
(let (($x6 (|prime_nat$| ?0)))
(let (($x245 (or $x6 $x87 $x218)))
(let (($x293 (forall ((?v1 |Nat$|) )(!(let ((?x12 (|nat$| 1)))
(let (($x13 (= ?v1 ?x12)))
(or (not (|dvd$| ?v1 ?0)) $x13 (= ?v1 ?0)))) :pattern ( (|dvd$| ?v1 ?0) )))
))
(let (($x198 (not $x6)))
(let (($x94 (forall ((?v1 |Nat$|) )(let ((?x12 (|nat$| 1)))
(let (($x13 (= ?v1 ?x12)))
(or (not (|dvd$| ?v1 ?0)) $x13 (= ?v1 ?0)))))
))
(let (($x219 (not $x94)))
(let (($x271 (not (or $x87 $x219))))
(let (($x274 (or $x198 $x271)))
(let (($x283 (not (or (not $x274) (not $x245)))))
(let (($x317 (= $x283 (not (or (not (or $x198 (not (or $x87 (not $x293))))) (not $x245))))))
(let (($x314 (= (or (not $x274) (not $x245)) (or (not (or $x198 (not (or $x87 (not $x293))))) (not $x245)))))
(let (($x13 (= ?0 ?x12)))
(let (($x91 (or (not (|dvd$| ?0 ?1)) $x13 (= ?0 ?1))))
(let ((@x300 (monotonicity (|quant-intro| (refl (= $x91 $x91)) (= $x94 $x293)) (= $x219 (not $x293)))))
(let ((@x306 (monotonicity (monotonicity @x300 (= (or $x87 $x219) (or $x87 (not $x293)))) (= $x271 (not (or $x87 (not $x293)))))))
(let ((@x312 (monotonicity (monotonicity @x306 (= $x274 (or $x198 (not (or $x87 (not $x293)))))) (= (not $x274) (not (or $x198 (not (or $x87 (not $x293)))))))))
(let ((@x323 (|quant-intro| (monotonicity (monotonicity @x312 $x314) $x317) (= $x288 $x321))))
(let (($x253 (forall ((?v0 |Nat$|) )(let (($x217 (or (not (|dvd$| (?v1!0 ?v0) ?v0)) (= (?v1!0 ?v0) (|nat$| 1)) (= (?v1!0 ?v0) ?v0))))
(let (($x218 (not $x217)))
(let ((?x8 (|of_nat$| ?v0)))
(let (($x87 (<= ?x8 1)))
(let (($x6 (|prime_nat$| ?v0)))
(let (($x245 (or $x6 $x87 $x218)))
(let (($x94 (forall ((?v1 |Nat$|) )(let ((?x12 (|nat$| 1)))
(let (($x13 (= ?v1 ?x12)))
(or (not (|dvd$| ?v1 ?v0)) $x13 (= ?v1 ?v0)))))
))
(let (($x88 (not $x87)))
(let (($x97 (and $x88 $x94)))
(let (($x198 (not $x6)))
(let (($x227 (or $x198 $x97)))
(and $x227 $x245)))))))))))))
))
(let ((@x276 (monotonicity (rewrite (= (and (not $x87) $x94) $x271)) (= (or $x198 (and (not $x87) $x94)) $x274))))
(let ((@x279 (monotonicity @x276 (= (and (or $x198 (and (not $x87) $x94)) $x245) (and $x274 $x245)))))
(let ((@x287 (trans @x279 (rewrite (= (and $x274 $x245) $x283)) (= (and (or $x198 (and (not $x87) $x94)) $x245) $x283))))
(let (($x231 (forall ((?v0 |Nat$|) )(let (($x217 (or (not (|dvd$| (?v1!0 ?v0) ?v0)) (= (?v1!0 ?v0) (|nat$| 1)) (= (?v1!0 ?v0) ?v0))))
(let (($x218 (not $x217)))
(let ((?x8 (|of_nat$| ?v0)))
(let (($x87 (<= ?x8 1)))
(let (($x88 (not $x87)))
(let (($x209 (not $x88)))
(let (($x222 (or $x209 $x218)))
(let (($x6 (|prime_nat$| ?v0)))
(let (($x226 (or $x6 $x222)))
(let (($x94 (forall ((?v1 |Nat$|) )(let ((?x12 (|nat$| 1)))
(let (($x13 (= ?v1 ?x12)))
(or (not (|dvd$| ?v1 ?v0)) $x13 (= ?v1 ?v0)))))
))
(let (($x97 (and $x88 $x94)))
(let (($x198 (not $x6)))
(let (($x227 (or $x198 $x97)))
(and $x227 $x226)))))))))))))))
))
(let (($x88 (not $x87)))
(let (($x97 (and $x88 $x94)))
(let (($x227 (or $x198 $x97)))
(let (($x250 (and $x227 $x245)))
(let (($x209 (not $x88)))
(let (($x222 (or $x209 $x218)))
(let (($x226 (or $x6 $x222)))
(let (($x228 (and $x227 $x226)))
(let ((@x244 (monotonicity (monotonicity (rewrite (= $x209 $x87)) (= $x222 (or $x87 $x218))) (= $x226 (or $x6 (or $x87 $x218))))))
(let ((@x249 (trans @x244 (rewrite (= (or $x6 (or $x87 $x218)) $x245)) (= $x226 $x245))))
(let (($x103 (forall ((?v0 |Nat$|) )(let (($x94 (forall ((?v1 |Nat$|) )(let ((?x12 (|nat$| 1)))
(let (($x13 (= ?v1 ?x12)))
(or (not (|dvd$| ?v1 ?v0)) $x13 (= ?v1 ?v0)))))
))
(let ((?x8 (|of_nat$| ?v0)))
(let (($x87 (<= ?x8 1)))
(let (($x88 (not $x87)))
(let (($x97 (and $x88 $x94)))
(let (($x6 (|prime_nat$| ?v0)))
(= $x6 $x97))))))))
))
(let ((@x225 (|nnf-neg| (refl (|~| $x209 $x209)) (sk (|~| $x219 $x218)) (|~| (not $x97) $x222))))
(let ((@x208 (monotonicity (refl (|~| $x88 $x88)) (|nnf-pos| (refl (|~| $x91 $x91)) (|~| $x94 $x94)) (|~| $x97 $x97))))
(let ((@x230 (|nnf-pos| (refl (|~| $x6 $x6)) (refl (|~| $x198 $x198)) @x208 @x225 (|~| (= $x6 $x97) $x228))))
(let (($x20 (forall ((?v0 |Nat$|) )(let (($x17 (forall ((?v1 |Nat$|) )(let (($x11 (|dvd$| ?v1 ?v0)))
(=> $x11 (or (= ?v1 (|nat$| 1)) (= ?v1 ?v0)))))
))
(let ((?x8 (|of_nat$| ?v0)))
(let (($x9 (< 1 ?x8)))
(let (($x6 (|prime_nat$| ?v0)))
(= $x6 (and $x9 $x17)))))))
))
(let (($x84 (forall ((?v0 |Nat$|) )(let (($x70 (forall ((?v1 |Nat$|) )(or (not (|dvd$| ?v1 ?v0)) (or (= ?v1 (|nat$| 1)) (= ?v1 ?v0))))
))
(let ((?x8 (|of_nat$| ?v0)))
(let (($x9 (< 1 ?x8)))
(let (($x73 (and $x9 $x70)))
(let (($x6 (|prime_nat$| ?v0)))
(= $x6 $x73)))))))
))
(let (($x100 (= $x6 $x97)))
(let (($x70 (forall ((?v1 |Nat$|) )(or (not (|dvd$| ?v1 ?0)) (or (= ?v1 (|nat$| 1)) (= ?v1 ?0))))
))
(let (($x9 (< 1 ?x8)))
(let (($x73 (and $x9 $x70)))
(let (($x79 (= $x6 $x73)))
(let ((@x93 (rewrite (= (or (not (|dvd$| ?0 ?1)) (or $x13 (= ?0 ?1))) $x91))))
(let ((@x99 (monotonicity (rewrite (= $x9 $x88)) (|quant-intro| @x93 (= $x70 $x94)) (= $x73 $x97))))
(let (($x17 (forall ((?v1 |Nat$|) )(let (($x11 (|dvd$| ?v1 ?0)))
(=> $x11 (or (= ?v1 (|nat$| 1)) (= ?v1 ?0)))))
))
(let (($x19 (= $x6 (and $x9 $x17))))
(let (($x67 (or (not (|dvd$| ?0 ?1)) (or $x13 (= ?0 ?1)))))
(let ((@x72 (|quant-intro| (rewrite (= (=> (|dvd$| ?0 ?1) (or $x13 (= ?0 ?1))) $x67)) (= $x17 $x70))))
(let ((@x78 (monotonicity (monotonicity @x72 (= (and $x9 $x17) $x73)) (= $x19 (= $x6 $x73)))))
(let ((@x86 (|quant-intro| (trans @x78 (rewrite (= (= $x6 $x73) $x79)) (= $x19 $x79)) (= $x20 $x84))))
(let ((@x107 (trans @x86 (|quant-intro| (monotonicity @x99 (= $x79 $x100)) (= $x84 $x103)) (= $x20 $x103))))
(let ((@x234 (|mp~| (mp (asserted $x20) @x107 $x103) (|nnf-pos| @x230 (|~| $x103 $x231)) $x231)))
(let ((@x235 (mp @x234 (|quant-intro| (monotonicity @x249 (= $x228 $x250)) (= $x231 $x253)) $x253)))
(let ((@x324 (mp (mp @x235 (|quant-intro| @x287 (= $x253 $x288)) $x288) @x323 $x321)))
(let (($x371 (or (not $x321) $x367)))
(let ((@x372 ((_ |quant-inst| (|nat$| ?x110)) $x371)))
(let ((@x530 (|unit-resolution| (|def-axiom| (or $x366 $x355)) (|unit-resolution| @x372 @x324 $x367) $x355)))
(let (($x137 (not (or $x122 (>= ?x23 1)))))
(let (($x28 (<= 1 ?x23)))
(let (($x29 (=> (|prime_nat$| (|nat$| (+ ?x24 1))) $x28)))
(let (($x30 (not $x29)))
(let ((@x136 (monotonicity (rewrite (= $x28 (>= ?x23 1))) (= (or $x122 $x28) (or $x122 (>= ?x23 1))))))
(let ((@x115 (monotonicity (rewrite (= (+ ?x24 1) ?x110)) (= (|nat$| (+ ?x24 1)) ?x113))))
(let ((@x121 (monotonicity (monotonicity @x115 (= (|prime_nat$| (|nat$| (+ ?x24 1))) $x116)) (= $x29 (=> $x116 $x28)))))
(let ((@x127 (trans @x121 (rewrite (= (=> $x116 $x28) (or $x122 $x28))) (= $x29 (or $x122 $x28)))))
(let ((@x141 (trans (monotonicity @x127 (= $x30 (not (or $x122 $x28)))) (monotonicity @x136 (= (not (or $x122 $x28)) $x137)) (= $x30 $x137))))
(let ((@x143 (|not-or-elim| (mp (asserted $x30) @x141 $x137) $x116)))
(let ((@x533 (|unit-resolution| (|unit-resolution| (|def-axiom| (or $x356 $x122 $x354)) @x143 (or $x356 $x354)) @x530 $x354)))
(let ((@x538 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not (<= ?x344 0)) $x345)) (|unit-resolution| (|def-axiom| (or $x353 $x373)) @x533 $x373) (not (<= ?x344 0)))))
(let ((@x542 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not (= ?x344 0)) (<= ?x344 0))) @x538 (not (= ?x344 0)))))
(let (($x510 (= ?x344 0)))
(let (($x512 (or $x481 $x510)))
(let (($x338 (forall ((?v0 Int) )(!(let ((?x37 (|nat$| ?v0)))
(let ((?x38 (|of_nat$| ?x37)))
(let (($x43 (= ?x38 0)))
(let (($x157 (>= ?v0 0)))
(or $x157 $x43))))) :pattern ( (|nat$| ?v0) )))
))
(let (($x190 (forall ((?v0 Int) )(let ((?x37 (|nat$| ?v0)))
(let ((?x38 (|of_nat$| ?x37)))
(let (($x43 (= ?x38 0)))
(let (($x157 (>= ?v0 0)))
(or $x157 $x43))))))
))
(let ((?x37 (|nat$| ?0)))
(let ((?x38 (|of_nat$| ?x37)))
(let (($x43 (= ?x38 0)))
(let (($x157 (>= ?0 0)))
(let (($x187 (or $x157 $x43)))
(let (($x45 (forall ((?v0 Int) )(let ((?x37 (|nat$| ?v0)))
(let ((?x38 (|of_nat$| ?x37)))
(let (($x43 (= ?x38 0)))
(let (($x42 (< ?v0 0)))
(=> $x42 $x43))))))
))
(let (($x175 (forall ((?v0 Int) )(let ((?x37 (|nat$| ?v0)))
(let ((?x38 (|of_nat$| ?x37)))
(let (($x43 (= ?x38 0)))
(let (($x42 (< ?v0 0)))
(let (($x171 (not $x42)))
(or $x171 $x43)))))))
))
(let ((@x182 (monotonicity (rewrite (= (< ?0 0) (not $x157))) (= (not (< ?0 0)) (not (not $x157))))))
(let ((@x186 (trans @x182 (rewrite (= (not (not $x157)) $x157)) (= (not (< ?0 0)) $x157))))
(let ((@x192 (|quant-intro| (monotonicity @x186 (= (or (not (< ?0 0)) $x43) $x187)) (= $x175 $x190))))
(let ((@x174 (rewrite (= (=> (< ?0 0) $x43) (or (not (< ?0 0)) $x43)))))
(let ((@x195 (mp (asserted $x45) (trans (|quant-intro| @x174 (= $x45 $x175)) @x192 (= $x45 $x190)) $x190)))
(let ((@x343 (mp (|mp~| @x195 (|nnf-pos| (refl (|~| $x187 $x187)) (|~| $x190 $x190)) $x190) (|quant-intro| (refl (= $x187 $x187)) (= $x190 $x338)) $x338)))
(let (($x515 (not $x338)))
(let (($x516 (or $x515 $x481 $x510)))
(let ((@x483 (rewrite (= (>= ?x110 0) $x481))))
(let ((@x514 (monotonicity @x483 (= (or (>= ?x110 0) $x510) $x512))))
(let ((@x521 (monotonicity @x514 (= (or $x515 (or (>= ?x110 0) $x510)) (or $x515 $x512)))))
(let ((@x525 (trans @x521 (rewrite (= (or $x515 $x512) $x516)) (= (or $x515 (or (>= ?x110 0) $x510)) $x516))))
(let ((@x526 (mp ((_ |quant-inst| (+ 1 ?x24)) (or $x515 (or (>= ?x110 0) $x510))) @x525 $x516)))
(let (($x484 (not $x481)))
(let (($x493 (or $x484 $x489)))
(let (($x332 (forall ((?v0 Int) )(!(let ((?x37 (|nat$| ?v0)))
(let ((?x38 (|of_nat$| ?x37)))
(let (($x39 (= ?x38 ?v0)))
(let (($x157 (>= ?v0 0)))
(let (($x158 (not $x157)))
(or $x158 $x39)))))) :pattern ( (|nat$| ?v0) )))
))
(let (($x164 (forall ((?v0 Int) )(let ((?x37 (|nat$| ?v0)))
(let ((?x38 (|of_nat$| ?x37)))
(let (($x39 (= ?x38 ?v0)))
(let (($x157 (>= ?v0 0)))
(let (($x158 (not $x157)))
(or $x158 $x39)))))))
))
(let ((@x334 (refl (= (or (not $x157) (= ?x38 ?0)) (or (not $x157) (= ?x38 ?0))))))
(let ((@x261 (refl (|~| (or (not $x157) (= ?x38 ?0)) (or (not $x157) (= ?x38 ?0))))))
(let (($x41 (forall ((?v0 Int) )(let ((?x37 (|nat$| ?v0)))
(let ((?x38 (|of_nat$| ?x37)))
(let (($x39 (= ?x38 ?v0)))
(let (($x36 (<= 0 ?v0)))
(=> $x36 $x39))))))
))
(let (($x152 (forall ((?v0 Int) )(let ((?x37 (|nat$| ?v0)))
(let ((?x38 (|of_nat$| ?x37)))
(let (($x39 (= ?x38 ?v0)))
(or (not (<= 0 ?v0)) $x39)))))
))
(let (($x39 (= ?x38 ?0)))
(let (($x158 (not $x157)))
(let (($x161 (or $x158 $x39)))
(let (($x149 (or (not (<= 0 ?0)) $x39)))
(let ((@x160 (monotonicity (rewrite (= (<= 0 ?0) $x157)) (= (not (<= 0 ?0)) $x158))))
(let ((@x154 (|quant-intro| (rewrite (= (=> (<= 0 ?0) $x39) $x149)) (= $x41 $x152))))
(let ((@x168 (trans @x154 (|quant-intro| (monotonicity @x160 (= $x149 $x161)) (= $x152 $x164)) (= $x41 $x164))))
(let ((@x264 (|mp~| (mp (asserted $x41) @x168 $x164) (|nnf-pos| @x261 (|~| $x164 $x164)) $x164)))
(let ((@x337 (mp @x264 (|quant-intro| @x334 (= $x164 $x332)) $x332)))
(let (($x496 (not $x332)))
(let (($x497 (or $x496 $x484 $x489)))
(let (($x479 (= ?x344 ?x110)))
(let (($x474 (>= ?x110 0)))
(let (($x475 (not $x474)))
(let (($x480 (or $x475 $x479)))
(let (($x498 (or $x496 $x480)))
(let ((@x495 (monotonicity (monotonicity @x483 (= $x475 $x484)) (rewrite (= $x479 $x489)) (= $x480 $x493))))
(let ((@x506 (trans (monotonicity @x495 (= $x498 (or $x496 $x493))) (rewrite (= (or $x496 $x493) $x497)) (= $x498 $x497))))
(let ((@x507 (mp ((_ |quant-inst| (+ 1 ?x24)) $x498) @x506 $x497)))
(let ((@x546 (|unit-resolution| (|unit-resolution| @x507 @x337 $x493) (|unit-resolution| (|unit-resolution| @x526 @x343 $x512) @x542 $x481) $x489)))
(let ((@x145 (|not-or-elim| (mp (asserted $x30) @x141 $x137) (not (>= ?x23 1)))))
((_ |th-lemma| arith farkas -4 1 1) @x145 (|unit-resolution| (|def-axiom| (or $x353 $x373)) @x533 $x373) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x489) $x509)) @x546 $x509) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

c7efedca31e5e8360d3c81014f43c447bc784df3 23 0
unsat
((set-logic AUFLIA)
(proof
(let (($x17 (= |x$| |a$|)))
(let ((?x13 (|pair$| |x$| |y$|)))
(let ((?x14 (|fst$| ?x13)))
(let (($x16 (= ?x14 |a$|)))
(let ((@x48 (monotonicity (rewrite (= (=> $x16 $x17) (or (not $x16) $x17))) (= (not (=> $x16 $x17)) (not (or (not $x16) $x17))))))
(let ((@x49 (|not-or-elim| (mp (asserted (not (=> $x16 $x17))) @x48 (not (or (not $x16) $x17))) $x16)))
(let (($x65 (= ?x14 |x$|)))
(let (($x59 (forall ((?v0 |A$|) (?v1 |B$|) )(!(= (|fst$| (|pair$| ?v0 ?v1)) ?v0) :pattern ( (|pair$| ?v0 ?v1) )))
))
(let (($x10 (forall ((?v0 |A$|) (?v1 |B$|) )(= (|fst$| (|pair$| ?v0 ?v1)) ?v0))
))
(let (($x9 (= (|fst$| (|pair$| ?1 ?0)) ?1)))
(let ((@x57 (|mp~| (asserted $x10) (|nnf-pos| (refl (|~| $x9 $x9)) (|~| $x10 $x10)) $x10)))
(let ((@x64 (mp @x57 (|quant-intro| (refl (= $x9 $x9)) (= $x10 $x59)) $x59)))
(let (($x69 (or (not $x59) $x65)))
(let ((@x70 ((_ |quant-inst| |x$| |y$|) $x69)))
(let ((@x72 (trans (symm (|unit-resolution| @x70 @x64 $x65) (= |x$| ?x14)) @x49 $x17)))
(let ((@x52 (|not-or-elim| (mp (asserted (not (=> $x16 $x17))) @x48 (not (or (not $x16) $x17))) (not $x17))))
(|unit-resolution| @x52 @x72 false)))))))))))))))))))

aea156a69bb23683148bfccfaa255f874937bce0 42 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x33 (|snd$a| |p2$|)))
(let ((?x32 (|fst$a| |p1$|)))
(let (($x34 (= ?x32 ?x33)))
(let ((?x29 (|pair$| |y$| |x$|)))
(let (($x30 (= |p2$| ?x29)))
(let ((?x26 (|pair$a| |x$| |y$|)))
(let (($x27 (= |p1$| ?x26)))
(let (($x31 (and $x27 $x30)))
(let ((@x68 (monotonicity (rewrite (= (=> $x31 $x34) (or (not $x31) $x34))) (= (not (=> $x31 $x34)) (not (or (not $x31) $x34))))))
(let ((@x69 (|not-or-elim| (mp (asserted (not (=> $x31 $x34))) @x68 (not (or (not $x31) $x34))) $x31)))
(let ((@x72 (|and-elim| @x69 $x30)))
(let ((@x150 (symm (monotonicity @x72 (= ?x33 (|snd$a| ?x29))) (= (|snd$a| ?x29) ?x33))))
(let ((?x123 (|snd$a| ?x29)))
(let (($x124 (= ?x123 |x$|)))
(let (($x115 (forall ((?v0 |B$|) (?v1 |A$|) )(!(= (|snd$a| (|pair$| ?v0 ?v1)) ?v1) :pattern ( (|pair$| ?v0 ?v1) )))
))
(let (($x22 (forall ((?v0 |B$|) (?v1 |A$|) )(= (|snd$a| (|pair$| ?v0 ?v1)) ?v1))
))
(let (($x21 (= (|snd$a| (|pair$| ?1 ?0)) ?0)))
(let ((@x94 (|mp~| (asserted $x22) (|nnf-pos| (refl (|~| $x21 $x21)) (|~| $x22 $x22)) $x22)))
(let ((@x120 (mp @x94 (|quant-intro| (refl (= $x21 $x21)) (= $x22 $x115)) $x115)))
(let (($x131 (or (not $x115) $x124)))
(let ((@x132 ((_ |quant-inst| |y$| |x$|) $x131)))
(let ((?x128 (|fst$a| ?x26)))
(let (($x129 (= ?x128 |x$|)))
(let (($x103 (forall ((?v0 |A$|) (?v1 |B$|) )(!(= (|fst$a| (|pair$a| ?v0 ?v1)) ?v0) :pattern ( (|pair$a| ?v0 ?v1) )))
))
(let (($x16 (forall ((?v0 |A$|) (?v1 |B$|) )(= (|fst$a| (|pair$a| ?v0 ?v1)) ?v0))
))
(let (($x15 (= (|fst$a| (|pair$a| ?1 ?0)) ?1)))
(let ((@x84 (|mp~| (asserted $x16) (|nnf-pos| (refl (|~| $x15 $x15)) (|~| $x16 $x16)) $x16)))
(let ((@x108 (mp @x84 (|quant-intro| (refl (= $x15 $x15)) (= $x16 $x103)) $x103)))
(let (($x136 (or (not $x103) $x129)))
(let ((@x137 ((_ |quant-inst| |x$| |y$|) $x136)))
(let ((@x152 (trans (monotonicity (|and-elim| @x69 $x27) (= ?x32 ?x128)) (|unit-resolution| @x137 @x108 $x129) (= ?x32 |x$|))))
(let ((@x154 (trans @x152 (symm (|unit-resolution| @x132 @x120 $x124) (= |x$| ?x123)) (= ?x32 ?x123))))
(let ((@x74 (|not-or-elim| (mp (asserted (not (=> $x31 $x34))) @x68 (not (or (not $x31) $x34))) (not $x34))))
(|unit-resolution| @x74 (trans @x154 @x150 $x34) false))))))))))))))))))))))))))))))))))))

9e587b4eedc0dc25b019cb54b54b4a4e643bf93e 49 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x45 (|fun_app$| |f$| |i$|)))
(let ((?x36 (|fun_upd$| |f$|)))
(let ((?x37 (|fun_app$b| ?x36 |i1$|)))
(let ((?x39 (|fun_app$a| ?x37 |v1$|)))
(let ((?x40 (|fun_upd$| ?x39)))
(let ((?x41 (|fun_app$b| ?x40 |i2$|)))
(let ((?x43 (|fun_app$a| ?x41 |v2$|)))
(let ((?x44 (|fun_app$| ?x43 |i$|)))
(let (($x46 (= ?x44 ?x45)))
(let (($x29 (= |i$| |i1$|)))
(let ((?x178 (ite $x29 |v1$| ?x45)))
(let (($x185 (= ?x45 ?x178)))
(let (($x30 (not $x29)))
(let (($x32 (= |i$| |i2$|)))
(let (($x33 (not $x32)))
(let (($x34 (and $x30 $x33)))
(let ((@x78 (monotonicity (rewrite (= (=> $x34 $x46) (or (not $x34) $x46))) (= (not (=> $x34 $x46)) (not (or (not $x34) $x46))))))
(let ((@x79 (|not-or-elim| (mp (asserted (not (=> $x34 $x46))) @x78 (not (or (not $x34) $x46))) $x34)))
(let ((@x80 (|and-elim| @x79 $x30)))
(let ((@x197 (symm (|unit-resolution| (|def-axiom| (or $x29 $x185)) @x80 $x185) (= ?x178 ?x45))))
(let ((?x116 (|fun_app$| ?x39 |i$|)))
(let (($x179 (= ?x116 ?x178)))
(let (($x103 (forall ((?v0 |A_b_fun$|) (?v1 |A$|) (?v2 |B$|) (?v3 |A$|) )(!(let ((?x21 (|fun_app$| (|fun_app$a| (|fun_app$b| (|fun_upd$| ?v0) ?v1) ?v2) ?v3)))
(= ?x21 (ite (= ?v3 ?v1) ?v2 (|fun_app$| ?v0 ?v3)))) :pattern ( (|fun_app$| (|fun_app$a| (|fun_app$b| (|fun_upd$| ?v0) ?v1) ?v2) ?v3) )))
))
(let (($x26 (forall ((?v0 |A_b_fun$|) (?v1 |A$|) (?v2 |B$|) (?v3 |A$|) )(let ((?x21 (|fun_app$| (|fun_app$a| (|fun_app$b| (|fun_upd$| ?v0) ?v1) ?v2) ?v3)))
(= ?x21 (ite (= ?v3 ?v1) ?v2 (|fun_app$| ?v0 ?v3)))))
))
(let ((?x21 (|fun_app$| (|fun_app$a| (|fun_app$b| (|fun_upd$| ?3) ?2) ?1) ?0)))
(let (($x25 (= ?x21 (ite (= ?0 ?2) ?1 (|fun_app$| ?3 ?0)))))
(let ((@x94 (|mp~| (asserted $x26) (|nnf-pos| (refl (|~| $x25 $x25)) (|~| $x26 $x26)) $x26)))
(let ((@x108 (mp @x94 (|quant-intro| (refl (= $x25 $x25)) (= $x26 $x103)) $x103)))
(let (($x123 (not $x103)))
(let (($x182 (or $x123 $x179)))
(let ((@x183 ((_ |quant-inst| |f$| |i1$| |v1$| |i$|) $x182)))
(let ((?x117 (ite $x32 |v2$| ?x116)))
(let (($x127 (= ?x116 ?x117)))
(let ((@x82 (|and-elim| @x79 $x33)))
(let ((@x195 (symm (|unit-resolution| (|def-axiom| (or $x32 $x127)) @x82 $x127) (= ?x117 ?x116))))
(let (($x120 (= ?x44 ?x117)))
(let (($x124 (or $x123 $x120)))
(let ((@x125 ((_ |quant-inst| (|fun_app$a| ?x37 |v1$|) |i2$| |v2$| |i$|) $x124)))
(let ((@x201 (trans (trans (|unit-resolution| @x125 @x108 $x120) @x195 (= ?x44 ?x116)) (|unit-resolution| @x183 @x108 $x179) (= ?x44 ?x178))))
(let ((@x84 (|not-or-elim| (mp (asserted (not (=> $x34 $x46))) @x78 (not (or (not $x34) $x46))) (not $x46))))
(|unit-resolution| @x84 (trans @x201 @x197 $x46) false)))))))))))))))))))))))))))))))))))))))))))

b3ae8e1fe1d7b019d0bef97ff09cdb8e0a1cd7dd 25 0
unsat
((set-logic AUFLIA)
(proof
(let (($x7 (|f$| |g$| |x$|)))
(let (($x71 (not $x7)))
(let (($x63 (not (or (= $x7 (|fun_app$| |g$| |x$|)) $x7 (|fun_app$| |g$| |x$|)))))
(let (($x10 (= $x7 (and (|fun_app$| |g$| |x$|) true))))
(let (($x15 (not (or $x10 (or (= $x7 true) (= (|fun_app$| |g$| |x$|) true))))))
(let (($x8 (|fun_app$| |g$| |x$|)))
(let (($x51 (or $x7 $x8)))
(let (($x42 (= $x7 $x8)))
(let (($x54 (or $x42 $x51)))
(let ((@x65 (monotonicity (rewrite (= $x54 (or $x42 $x7 $x8))) (= (not $x54) $x63))))
(let ((@x53 (monotonicity (rewrite (= (= $x7 true) $x7)) (rewrite (= (= $x8 true) $x8)) (= (or (= $x7 true) (= $x8 true)) $x51))))
(let ((@x41 (monotonicity (rewrite (= (and $x8 true) $x8)) (= $x10 (= $x7 $x8)))))
(let ((@x56 (monotonicity (trans @x41 (rewrite (= (= $x7 $x8) $x42)) (= $x10 $x42)) @x53 (= (or $x10 (or (= $x7 true) (= $x8 true))) $x54))))
(let ((@x67 (trans (monotonicity @x56 (= $x15 (not $x54))) @x65 (= $x15 $x63))))
(let ((@x68 (mp (asserted $x15) @x67 $x63)))
(let ((@x72 (|not-or-elim| @x68 $x71)))
(let (($x73 (not $x8)))
(let ((@x74 (|not-or-elim| @x68 $x73)))
(let (($x75 (= $x71 $x8)))
(let ((@x77 (mp (|not-or-elim| @x68 (not $x42)) (rewrite (= (not $x42) $x75)) $x75)))
(|unit-resolution| (|unit-resolution| (|def-axiom| (or $x7 $x8 (not $x75))) @x77 $x51) @x74 @x72 false)))))))))))))))))))))))

d9e693c8b48e2988c493bb1e4e83656e750403bf 14 0
unsat
((set-logic AUFLIA)
(proof
(let (($x7 (exists ((?v0 |A$|) )(|g$| ?v0))
))
(let (($x8 (ite $x7 true false)))
(let (($x9 (|f$| $x8)))
(let (($x10 (=> $x9 true)))
(let (($x11 (not $x10)))
(let ((@x40 (monotonicity (monotonicity (rewrite (= $x8 $x7)) (= $x9 (|f$| $x7))) (= $x10 (=> (|f$| $x7) true)))))
(let ((@x44 (trans @x40 (rewrite (= (=> (|f$| $x7) true) true)) (= $x10 true))))
(let ((@x51 (trans (monotonicity @x44 (= $x11 (not true))) (rewrite (= (not true) false)) (= $x11 false))))
(mp (asserted $x11) @x51 false)))))))))))

389aa7c628b5a2215f1c34b1b3aea4f4becc378c 14 0
unsat
((set-logic AUFLIA)
(proof
(let (($x7 (forall ((?v0 |A$|) )(|g$| ?v0))
))
(let (($x8 (ite $x7 true false)))
(let (($x9 (|f$| $x8)))
(let (($x10 (=> $x9 true)))
(let (($x11 (not $x10)))
(let ((@x40 (monotonicity (monotonicity (rewrite (= $x8 $x7)) (= $x9 (|f$| $x7))) (= $x10 (=> (|f$| $x7) true)))))
(let ((@x44 (trans @x40 (rewrite (= (=> (|f$| $x7) true) true)) (= $x10 true))))
(let ((@x51 (trans (monotonicity @x44 (= $x11 (not true))) (rewrite (= (not true) false)) (= $x11 false))))
(mp (asserted $x11) @x51 false)))))))))))

53b477f55537542d72fa148413e684cc3ff42e5b 46 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x17 (|fun_app$a| |le$| 3)))
(let (($x19 (|fun_app$| ?x17 42)))
(let (($x73 (not $x19)))
(let (($x15 (= |le$| |uu$|)))
(let ((@x71 (monotonicity (rewrite (= (=> $x15 $x19) (or (not $x15) $x19))) (= (not (=> $x15 $x19)) (not (or (not $x15) $x19))))))
(let ((@x72 (|not-or-elim| (mp (asserted (not (=> $x15 $x19))) @x71 (not (or (not $x15) $x19))) $x15)))
(let ((@x126 (monotonicity (symm @x72 (= |uu$| |le$|)) (= (|fun_app$a| |uu$| 3) ?x17))))
(let ((@x130 (symm (monotonicity @x126 (= (|fun_app$| (|fun_app$a| |uu$| 3) 42) $x19)) (= $x19 (|fun_app$| (|fun_app$a| |uu$| 3) 42)))))
(let ((@x133 (monotonicity @x130 (= $x73 (not (|fun_app$| (|fun_app$a| |uu$| 3) 42))))))
(let ((@x75 (|not-or-elim| (mp (asserted (not (=> $x15 $x19))) @x71 (not (or (not $x15) $x19))) $x73)))
(let ((?x81 (|fun_app$a| |uu$| 3)))
(let (($x82 (|fun_app$| ?x81 42)))
(let (($x58 (forall ((?v0 Int) (?v1 Int) )(!(let (($x52 (<= (+ ?v0 (* (~ 1) ?v1)) 0)))
(let (($x9 (|fun_app$| (|fun_app$a| |uu$| ?v0) ?v1)))
(= $x9 $x52))) :pattern ( (|fun_app$| (|fun_app$a| |uu$| ?v0) ?v1) )))
))
(let (($x52 (<= (+ ?1 (* (~ 1) ?0)) 0)))
(let (($x9 (|fun_app$| (|fun_app$a| |uu$| ?1) ?0)))
(let (($x55 (= $x9 $x52)))
(let (($x13 (forall ((?v0 Int) (?v1 Int) )(!(let (($x10 (<= ?v0 ?v1)))
(let (($x9 (|fun_app$| (|fun_app$a| |uu$| ?v0) ?v1)))
(= $x9 $x10))) :pattern ( (|fun_app$| (|fun_app$a| |uu$| ?v0) ?v1) )))
))
(let (($x46 (forall ((?v0 Int) (?v1 Int) )(!(let (($x10 (<= ?v0 ?v1)))
(let (($x9 (|fun_app$| (|fun_app$a| |uu$| ?v0) ?v1)))
(= $x9 $x10))) :pattern ( (|fun_app$| (|fun_app$a| |uu$| ?v0) ?v1) )))
))
(let ((@x57 (monotonicity (rewrite (= (<= ?1 ?0) $x52)) (= (= $x9 (<= ?1 ?0)) $x55))))
(let ((@x48 (|quant-intro| (rewrite (= (= $x9 (<= ?1 ?0)) (= $x9 (<= ?1 ?0)))) (= $x13 $x46))))
(let ((@x63 (mp (asserted $x13) (trans @x48 (|quant-intro| @x57 (= $x46 $x58)) (= $x13 $x58)) $x58)))
(let ((@x80 (|mp~| @x63 (|nnf-pos| (refl (|~| $x55 $x55)) (|~| $x58 $x58)) $x58)))
(let (($x113 (or (not $x58) $x82)))
(let (($x116 (= (or (not $x58) (= $x82 (<= (+ 3 (* (~ 1) 42)) 0))) $x113)))
(let ((?x83 (* (~ 1) 42)))
(let ((?x84 (+ 3 ?x83)))
(let (($x85 (<= ?x84 0)))
(let (($x86 (= $x82 $x85)))
(let ((@x97 (trans (monotonicity (rewrite (= ?x83 (~ 42))) (= ?x84 (+ 3 (~ 42)))) (rewrite (= (+ 3 (~ 42)) (~ 39))) (= ?x84 (~ 39)))))
(let ((@x104 (trans (monotonicity @x97 (= $x85 (<= (~ 39) 0))) (rewrite (= (<= (~ 39) 0) true)) (= $x85 true))))
(let ((@x111 (trans (monotonicity @x104 (= $x86 (= $x82 true))) (rewrite (= (= $x82 true) $x82)) (= $x86 $x82))))
(let ((@x121 (mp ((_ |quant-inst| 3 42) (or (not $x58) $x86)) (trans (monotonicity @x111 $x116) (rewrite (= $x113 $x113)) $x116) $x113)))
(|unit-resolution| (|unit-resolution| @x121 @x80 $x82) (mp @x75 @x133 (not $x82)) false)))))))))))))))))))))))))))))))))))

737e9aeb0ce08125531c37a003d0a11fe8c1aa00 189 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x37 (|nat$| 2)))
(let ((?x38 (|cons$| ?x37 |nil$|)))
(let ((?x32 (|nat$| 1)))
(let ((?x39 (|cons$| ?x32 ?x38)))
(let ((?x33 (|cons$| ?x32 |nil$|)))
(let ((?x31 (|nat$| 0)))
(let ((?x34 (|cons$| ?x31 ?x33)))
(let ((?x35 (|map$| |uu$| ?x34)))
(let (($x40 (= ?x35 ?x39)))
(let ((?x208 (|map$| |uu$| ?x33)))
(let ((?x326 (|map$| |uu$| |nil$|)))
(let ((?x325 (|fun_app$| |uu$| ?x32)))
(let ((?x327 (|cons$| ?x325 ?x326)))
(let (($x328 (= ?x208 ?x327)))
(let (($x181 (forall ((?v0 |Nat_nat_fun$|) (?v1 |Nat$|) (?v2 |Nat_list$|) )(!(let ((?x27 (|cons$| (|fun_app$| ?v0 ?v1) (|map$| ?v0 ?v2))))
(let ((?x24 (|map$| ?v0 (|cons$| ?v1 ?v2))))
(= ?x24 ?x27))) :pattern ( (|map$| ?v0 (|cons$| ?v1 ?v2)) ) :pattern ( (|cons$| (|fun_app$| ?v0 ?v1) (|map$| ?v0 ?v2)) )))
))
(let (($x29 (forall ((?v0 |Nat_nat_fun$|) (?v1 |Nat$|) (?v2 |Nat_list$|) )(let ((?x27 (|cons$| (|fun_app$| ?v0 ?v1) (|map$| ?v0 ?v2))))
(let ((?x24 (|map$| ?v0 (|cons$| ?v1 ?v2))))
(= ?x24 ?x27))))
))
(let ((?x27 (|cons$| (|fun_app$| ?2 ?1) (|map$| ?2 ?0))))
(let ((?x24 (|map$| ?2 (|cons$| ?1 ?0))))
(let (($x28 (= ?x24 ?x27)))
(let ((@x156 (|mp~| (asserted $x29) (|nnf-pos| (refl (|~| $x28 $x28)) (|~| $x29 $x29)) $x29)))
(let ((@x186 (mp @x156 (|quant-intro| (refl (= $x28 $x28)) (= $x29 $x181)) $x181)))
(let (($x213 (not $x181)))
(let (($x331 (or $x213 $x328)))
(let ((@x332 ((_ |quant-inst| |uu$| (|nat$| 1) |nil$|) $x331)))
(let (($x339 (= ?x326 |nil$|)))
(let (($x173 (forall ((?v0 |Nat_nat_fun$|) )(!(= (|map$| ?v0 |nil$|) |nil$|) :pattern ( (|map$| ?v0 |nil$|) )))
))
(let (($x19 (forall ((?v0 |Nat_nat_fun$|) )(= (|map$| ?v0 |nil$|) |nil$|))
))
(let ((@x175 (refl (= (= (|map$| ?0 |nil$|) |nil$|) (= (|map$| ?0 |nil$|) |nil$|)))))
(let ((@x148 (refl (|~| (= (|map$| ?0 |nil$|) |nil$|) (= (|map$| ?0 |nil$|) |nil$|)))))
(let ((@x178 (mp (|mp~| (asserted $x19) (|nnf-pos| @x148 (|~| $x19 $x19)) $x19) (|quant-intro| @x175 (= $x19 $x173)) $x173)))
(let (($x343 (or (not $x173) $x339)))
(let ((@x344 ((_ |quant-inst| |uu$|) $x343)))
(let ((?x255 (|of_nat$| ?x32)))
(let ((?x340 (+ 1 ?x255)))
(let ((?x341 (|nat$| ?x340)))
(let (($x345 (= ?x325 ?x341)))
(let (($x85 (forall ((?v0 |Nat$|) )(!(let ((?x7 (|fun_app$| |uu$| ?v0)))
(= ?x7 (|nat$| (+ 1 (|of_nat$| ?v0))))) :pattern ( (|fun_app$| |uu$| ?v0) )))
))
(let ((?x7 (|fun_app$| |uu$| ?0)))
(let (($x82 (= ?x7 (|nat$| (+ 1 (|of_nat$| ?0))))))
(let (($x14 (forall ((?v0 |Nat$|) )(!(let ((?x7 (|fun_app$| |uu$| ?v0)))
(= ?x7 (|nat$| (+ (|of_nat$| ?v0) 1)))) :pattern ( (|fun_app$| |uu$| ?v0) )))
))
(let ((@x81 (monotonicity (rewrite (= (+ (|of_nat$| ?0) 1) (+ 1 (|of_nat$| ?0)))) (= (|nat$| (+ (|of_nat$| ?0) 1)) (|nat$| (+ 1 (|of_nat$| ?0)))))))
(let ((@x84 (monotonicity @x81 (= (= ?x7 (|nat$| (+ (|of_nat$| ?0) 1))) $x82))))
(let ((@x146 (|mp~| (mp (asserted $x14) (|quant-intro| @x84 (= $x14 $x85)) $x85) (|nnf-pos| (refl (|~| $x82 $x82)) (|~| $x85 $x85)) $x85)))
(let (($x348 (or (not $x85) $x345)))
(let ((@x349 ((_ |quant-inst| (|nat$| 1)) $x348)))
(let ((?x404 (|of_nat$| ?x341)))
(let ((?x454 (|nat$| ?x404)))
(let (($x455 (= ?x454 ?x341)))
(let (($x188 (forall ((?v0 |Nat$|) )(!(= (|nat$| (|of_nat$| ?v0)) ?v0) :pattern ( (|of_nat$| ?v0) )))
))
(let (($x44 (forall ((?v0 |Nat$|) )(= (|nat$| (|of_nat$| ?v0)) ?v0))
))
(let ((@x190 (refl (= (= (|nat$| (|of_nat$| ?0)) ?0) (= (|nat$| (|of_nat$| ?0)) ?0)))))
(let ((@x160 (refl (|~| (= (|nat$| (|of_nat$| ?0)) ?0) (= (|nat$| (|of_nat$| ?0)) ?0)))))
(let ((@x193 (mp (|mp~| (asserted $x44) (|nnf-pos| @x160 (|~| $x44 $x44)) $x44) (|quant-intro| @x190 (= $x44 $x188)) $x188)))
(let (($x461 (or (not $x188) $x455)))
(let ((@x462 ((_ |quant-inst| (|nat$| ?x340)) $x461)))
(let ((?x415 (* (~ 1) ?x404)))
(let ((?x416 (+ ?x255 ?x415)))
(let (($x432 (<= ?x416 (~ 1))))
(let (($x414 (= ?x416 (~ 1))))
(let (($x407 (>= ?x255 (~ 1))))
(let (($x401 (>= ?x255 1)))
(let (($x256 (= ?x255 1)))
(let (($x195 (forall ((?v0 Int) )(!(let (($x49 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
(let (($x103 (>= ?v0 0)))
(let (($x104 (not $x103)))
(or $x104 $x49)))) :pattern ( (|nat$| ?v0) )))
))
(let (($x110 (forall ((?v0 Int) )(let (($x49 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
(let (($x103 (>= ?v0 0)))
(let (($x104 (not $x103)))
(or $x104 $x49)))))
))
(let (($x49 (= (|of_nat$| (|nat$| ?0)) ?0)))
(let (($x103 (>= ?0 0)))
(let (($x104 (not $x103)))
(let (($x107 (or $x104 $x49)))
(let (($x51 (forall ((?v0 Int) )(let (($x49 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
(let (($x46 (<= 0 ?v0)))
(=> $x46 $x49))))
))
(let (($x98 (forall ((?v0 Int) )(let (($x49 (= (|of_nat$| (|nat$| ?v0)) ?v0)))
(or (not (<= 0 ?v0)) $x49)))
))
(let ((@x106 (monotonicity (rewrite (= (<= 0 ?0) $x103)) (= (not (<= 0 ?0)) $x104))))
(let ((@x112 (|quant-intro| (monotonicity @x106 (= (or (not (<= 0 ?0)) $x49) $x107)) (= $x98 $x110))))
(let ((@x97 (rewrite (= (=> (<= 0 ?0) $x49) (or (not (<= 0 ?0)) $x49)))))
(let ((@x115 (mp (asserted $x51) (trans (|quant-intro| @x97 (= $x51 $x98)) @x112 (= $x51 $x110)) $x110)))
(let ((@x200 (mp (|mp~| @x115 (|nnf-pos| (refl (|~| $x107 $x107)) (|~| $x110 $x110)) $x110) (|quant-intro| (refl (= $x107 $x107)) (= $x110 $x195)) $x195)))
(let (($x235 (not $x195)))
(let (($x271 (or $x235 $x256)))
(let ((@x225 (rewrite (= (not true) false))))
(let ((@x259 (rewrite (= (>= 1 0) true))))
(let ((@x263 (trans (monotonicity @x259 (= (not (>= 1 0)) (not true))) @x225 (= (not (>= 1 0)) false))))
(let ((@x266 (monotonicity @x263 (= (or (not (>= 1 0)) $x256) (or false $x256)))))
(let ((@x270 (trans @x266 (rewrite (= (or false $x256) $x256)) (= (or (not (>= 1 0)) $x256) $x256))))
(let ((@x275 (monotonicity @x270 (= (or $x235 (or (not (>= 1 0)) $x256)) $x271))))
(let ((@x278 (trans @x275 (rewrite (= $x271 $x271)) (= (or $x235 (or (not (>= 1 0)) $x256)) $x271))))
(let ((@x279 (mp ((_ |quant-inst| 1) (or $x235 (or (not (>= 1 0)) $x256))) @x278 $x271)))
(let ((@x477 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x256) $x401)) (|unit-resolution| @x279 @x200 $x256) $x401)))
(let (($x410 (not $x407)))
(let (($x421 (or $x235 $x410 $x414)))
(let (($x405 (= ?x404 ?x340)))
(let (($x402 (>= ?x340 0)))
(let (($x403 (not $x402)))
(let (($x406 (or $x403 $x405)))
(let (($x422 (or $x235 $x406)))
(let ((@x420 (monotonicity (monotonicity (rewrite (= $x402 $x407)) (= $x403 $x410)) (rewrite (= $x405 $x414)) (= $x406 (or $x410 $x414)))))
(let ((@x430 (trans (monotonicity @x420 (= $x422 (or $x235 (or $x410 $x414)))) (rewrite (= (or $x235 (or $x410 $x414)) $x421)) (= $x422 $x421))))
(let ((@x431 (mp ((_ |quant-inst| (+ 1 ?x255)) $x422) @x430 $x421)))
(let ((@x482 (|unit-resolution| @x431 @x200 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x401) $x407)) @x477 $x407) $x414)))
(let (($x433 (>= ?x416 (~ 1))))
(let (($x400 (<= ?x255 1)))
(let ((@x492 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x256) $x400)) (|unit-resolution| @x279 @x200 $x256) $x400)))
(let ((@x494 ((_ |th-lemma| arith eq-propagate -1 -1 1 1) @x477 @x492 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x414) $x433)) @x482 $x433) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x414) $x432)) @x482 $x432) (= ?x404 2))))
(let ((@x502 (trans (monotonicity (symm @x494 (= 2 ?x404)) (= ?x37 ?x454)) (|unit-resolution| @x462 @x193 $x455) (= ?x37 ?x341))))
(let ((@x504 (trans @x502 (symm (|unit-resolution| @x349 @x146 $x345) (= ?x341 ?x325)) (= ?x37 ?x325))))
(let ((@x506 (monotonicity @x504 (symm (|unit-resolution| @x344 @x178 $x339) (= |nil$| ?x326)) (= ?x38 ?x327))))
(let ((@x510 (trans @x506 (symm (|unit-resolution| @x332 @x186 $x328) (= ?x327 ?x208)) (= ?x38 ?x208))))
(let ((?x216 (|of_nat$| ?x31)))
(let ((?x329 (+ 1 ?x216)))
(let ((?x330 (|nat$| ?x329)))
(let ((?x207 (|fun_app$| |uu$| ?x31)))
(let (($x333 (= ?x207 ?x330)))
(let (($x337 (or (not $x85) $x333)))
(let ((@x338 ((_ |quant-inst| (|nat$| 0)) $x337)))
(let ((?x350 (|of_nat$| ?x330)))
(let ((?x452 (|nat$| ?x350)))
(let (($x453 (= ?x452 ?x330)))
(let (($x457 (or (not $x188) $x453)))
(let ((@x458 ((_ |quant-inst| (|nat$| ?x329)) $x457)))
(let ((?x362 (* (~ 1) ?x350)))
(let ((?x363 (+ ?x216 ?x362)))
(let (($x379 (<= ?x363 (~ 1))))
(let (($x361 (= ?x363 (~ 1))))
(let (($x354 (>= ?x216 (~ 1))))
(let (($x335 (>= ?x216 0)))
(let (($x217 (= ?x216 0)))
(let (($x236 (or $x235 $x217)))
(let ((@x220 (rewrite (= (>= 0 0) true))))
(let ((@x227 (trans (monotonicity @x220 (= (not (>= 0 0)) (not true))) @x225 (= (not (>= 0 0)) false))))
(let ((@x230 (monotonicity @x227 (= (or (not (>= 0 0)) $x217) (or false $x217)))))
(let ((@x234 (trans @x230 (rewrite (= (or false $x217) $x217)) (= (or (not (>= 0 0)) $x217) $x217))))
(let ((@x240 (monotonicity @x234 (= (or $x235 (or (not (>= 0 0)) $x217)) $x236))))
(let ((@x243 (trans @x240 (rewrite (= $x236 $x236)) (= (or $x235 (or (not (>= 0 0)) $x217)) $x236))))
(let ((@x244 (mp ((_ |quant-inst| 0) (or $x235 (or (not (>= 0 0)) $x217))) @x243 $x236)))
(let ((@x517 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x217) $x335)) (|unit-resolution| @x244 @x200 $x217) $x335)))
(let (($x357 (not $x354)))
(let (($x368 (or $x235 $x357 $x361)))
(let (($x351 (= ?x350 ?x329)))
(let (($x346 (>= ?x329 0)))
(let (($x347 (not $x346)))
(let (($x352 (or $x347 $x351)))
(let (($x369 (or $x235 $x352)))
(let ((@x367 (monotonicity (monotonicity (rewrite (= $x346 $x354)) (= $x347 $x357)) (rewrite (= $x351 $x361)) (= $x352 (or $x357 $x361)))))
(let ((@x377 (trans (monotonicity @x367 (= $x369 (or $x235 (or $x357 $x361)))) (rewrite (= (or $x235 (or $x357 $x361)) $x368)) (= $x369 $x368))))
(let ((@x378 (mp ((_ |quant-inst| (+ 1 ?x216)) $x369) @x377 $x368)))
(let ((@x522 (|unit-resolution| @x378 @x200 (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x335) $x354)) @x517 $x354) $x361)))
(let (($x380 (>= ?x363 (~ 1))))
(let (($x334 (<= ?x216 0)))
(let ((@x532 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x217) $x334)) (|unit-resolution| @x244 @x200 $x217) $x334)))
(let ((@x534 ((_ |th-lemma| arith eq-propagate -1 -1 1 1) @x517 @x532 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x361) $x380)) @x522 $x380) (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x361) $x379)) @x522 $x379) (= ?x350 1))))
(let ((@x542 (trans (monotonicity (symm @x534 (= 1 ?x350)) (= ?x32 ?x452)) (|unit-resolution| @x458 @x193 $x453) (= ?x32 ?x330))))
(let ((@x544 (trans @x542 (symm (|unit-resolution| @x338 @x146 $x333) (= ?x330 ?x207)) (= ?x32 ?x207))))
(let ((@x549 (symm (monotonicity @x544 @x510 (= ?x39 (|cons$| ?x207 ?x208))) (= (|cons$| ?x207 ?x208) ?x39))))
(let ((?x209 (|cons$| ?x207 ?x208)))
(let (($x210 (= ?x35 ?x209)))
(let (($x214 (or $x213 $x210)))
(let ((@x215 ((_ |quant-inst| |uu$| (|nat$| 0) (|cons$| ?x32 |nil$|)) $x214)))
(let (($x41 (not $x40)))
(let ((@x91 (asserted $x41)))
(|unit-resolution| @x91 (trans (|unit-resolution| @x215 @x186 $x210) @x549 $x40) false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

516b38db52977db0759f7a2fb4ee2c61d2623ab0 11 0
unsat
((set-logic AUFLIA)
(proof
(let (($x7 (forall ((?v0 |A$|) )(|p$| ?v0))
))
(let (($x8 (not $x7)))
(let (($x9 (or $x7 $x8)))
(let (($x10 (not $x9)))
(let ((@x40 (trans (monotonicity (rewrite (= $x9 true)) (= $x10 (not true))) (rewrite (= (not true) false)) (= $x10 false))))
(mp (asserted $x10) @x40 false))))))))

120a595aca724e41775e5a997277b8d456a7e9fe 183 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x24 (|nat$| 6)))
(let ((?x17 (|nat$| 4)))
(let ((?x18 (|dec_10$| ?x17)))
(let ((?x19 (|of_nat$| ?x18)))
(let ((?x20 (* 4 ?x19)))
(let ((?x21 (|nat$| ?x20)))
(let ((?x22 (|dec_10$| ?x21)))
(let (($x25 (= ?x22 ?x24)))
(let ((?x348 (|of_nat$| ?x24)))
(let ((?x393 (+ (~ 10) ?x348)))
(let ((?x394 (|nat$| ?x393)))
(let ((?x395 (|dec_10$| ?x394)))
(let (($x390 (>= ?x348 10)))
(let ((?x396 (ite $x390 ?x395 ?x24)))
(let (($x403 (= ?x24 ?x396)))
(let (($x404 (not $x390)))
(let (($x398 (<= ?x348 6)))
(let (($x349 (= ?x348 6)))
(let (($x188 (forall ((?v0 Int) )(!(let ((?x33 (|nat$| ?v0)))
(let ((?x34 (|of_nat$| ?x33)))
(let (($x35 (= ?x34 ?v0)))
(let (($x114 (>= ?v0 0)))
(let (($x115 (not $x114)))
(or $x115 $x35)))))) :pattern ( (|nat$| ?v0) )))
))
(let (($x121 (forall ((?v0 Int) )(let ((?x33 (|nat$| ?v0)))
(let ((?x34 (|of_nat$| ?x33)))
(let (($x35 (= ?x34 ?v0)))
(let (($x114 (>= ?v0 0)))
(let (($x115 (not $x114)))
(or $x115 $x35)))))))
))
(let ((?x33 (|nat$| ?0)))
(let ((?x34 (|of_nat$| ?x33)))
(let (($x35 (= ?x34 ?0)))
(let (($x114 (>= ?0 0)))
(let (($x115 (not $x114)))
(let (($x118 (or $x115 $x35)))
(let (($x37 (forall ((?v0 Int) )(let ((?x33 (|nat$| ?v0)))
(let ((?x34 (|of_nat$| ?x33)))
(let (($x35 (= ?x34 ?v0)))
(let (($x32 (<= 0 ?v0)))
(=> $x32 $x35))))))
))
(let (($x109 (forall ((?v0 Int) )(let ((?x33 (|nat$| ?v0)))
(let ((?x34 (|of_nat$| ?x33)))
(let (($x35 (= ?x34 ?v0)))
(or (not (<= 0 ?v0)) $x35)))))
))
(let ((@x117 (monotonicity (rewrite (= (<= 0 ?0) $x114)) (= (not (<= 0 ?0)) $x115))))
(let ((@x123 (|quant-intro| (monotonicity @x117 (= (or (not (<= 0 ?0)) $x35) $x118)) (= $x109 $x121))))
(let ((@x108 (rewrite (= (=> (<= 0 ?0) $x35) (or (not (<= 0 ?0)) $x35)))))
(let ((@x126 (mp (asserted $x37) (trans (|quant-intro| @x108 (= $x37 $x109)) @x123 (= $x37 $x121)) $x121)))
(let ((@x193 (mp (|mp~| @x126 (|nnf-pos| (refl (|~| $x118 $x118)) (|~| $x121 $x121)) $x121) (|quant-intro| (refl (= $x118 $x118)) (= $x121 $x188)) $x188)))
(let (($x274 (not $x188)))
(let (($x364 (or $x274 $x349)))
(let ((@x352 (rewrite (= (>= 6 0) true))))
(let ((@x356 (trans (monotonicity @x352 (= (not (>= 6 0)) (not true))) (rewrite (= (not true) false)) (= (not (>= 6 0)) false))))
(let ((@x359 (monotonicity @x356 (= (or (not (>= 6 0)) $x349) (or false $x349)))))
(let ((@x363 (trans @x359 (rewrite (= (or false $x349) $x349)) (= (or (not (>= 6 0)) $x349) $x349))))
(let ((@x368 (monotonicity @x363 (= (or $x274 (or (not (>= 6 0)) $x349)) $x364))))
(let ((@x371 (trans @x368 (rewrite (= $x364 $x364)) (= (or $x274 (or (not (>= 6 0)) $x349)) $x364))))
(let ((@x372 (mp ((_ |quant-inst| 6) (or $x274 (or (not (>= 6 0)) $x349))) @x371 $x364)))
(let ((@x422 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x349) $x398)) (|unit-resolution| @x372 @x193 $x349) $x398)))
(let ((@x427 (|unit-resolution| (|def-axiom| (or $x390 $x403)) (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x398) $x404)) @x422 $x404) $x403)))
(let ((?x389 (|dec_10$| ?x24)))
(let (($x397 (= ?x389 ?x396)))
(let (($x175 (forall ((?v0 |Nat$|) )(!(let ((?x69 (|dec_10$| (|nat$| (+ (~ 10) (|of_nat$| ?v0))))))
(let ((?x88 (ite (>= (|of_nat$| ?v0) 10) ?x69 ?v0)))
(let ((?x6 (|dec_10$| ?v0)))
(= ?x6 ?x88)))) :pattern ( (|dec_10$| ?v0) ) :pattern ( (|of_nat$| ?v0) )))
))
(let (($x96 (forall ((?v0 |Nat$|) )(let ((?x69 (|dec_10$| (|nat$| (+ (~ 10) (|of_nat$| ?v0))))))
(let ((?x88 (ite (>= (|of_nat$| ?v0) 10) ?x69 ?v0)))
(let ((?x6 (|dec_10$| ?v0)))
(= ?x6 ?x88)))))
))
(let ((?x69 (|dec_10$| (|nat$| (+ (~ 10) (|of_nat$| ?0))))))
(let ((?x88 (ite (>= (|of_nat$| ?0) 10) ?x69 ?0)))
(let ((?x6 (|dec_10$| ?0)))
(let (($x93 (= ?x6 ?x88)))
(let (($x15 (forall ((?v0 |Nat$|) )(let ((?x7 (|of_nat$| ?v0)))
(let (($x9 (< ?x7 10)))
(let ((?x6 (|dec_10$| ?v0)))
(= ?x6 (ite $x9 ?v0 (|dec_10$| (|nat$| (- ?x7 10)))))))))
))
(let (($x78 (forall ((?v0 |Nat$|) )(let ((?x69 (|dec_10$| (|nat$| (+ (~ 10) (|of_nat$| ?v0))))))
(let ((?x7 (|of_nat$| ?v0)))
(let (($x9 (< ?x7 10)))
(let ((?x72 (ite $x9 ?v0 ?x69)))
(let ((?x6 (|dec_10$| ?v0)))
(= ?x6 ?x72)))))))
))
(let ((?x7 (|of_nat$| ?0)))
(let (($x9 (< ?x7 10)))
(let ((?x72 (ite $x9 ?0 ?x69)))
(let ((@x87 (monotonicity (rewrite (= $x9 (not (>= ?x7 10)))) (= ?x72 (ite (not (>= ?x7 10)) ?0 ?x69)))))
(let ((@x92 (trans @x87 (rewrite (= (ite (not (>= ?x7 10)) ?0 ?x69) ?x88)) (= ?x72 ?x88))))
(let ((@x98 (|quant-intro| (monotonicity @x92 (= (= ?x6 ?x72) $x93)) (= $x78 $x96))))
(let (($x75 (= ?x6 ?x72)))
(let ((@x68 (monotonicity (rewrite (= (- ?x7 10) (+ (~ 10) ?x7))) (= (|nat$| (- ?x7 10)) (|nat$| (+ (~ 10) ?x7))))))
(let ((@x74 (monotonicity (monotonicity @x68 (= (|dec_10$| (|nat$| (- ?x7 10))) ?x69)) (= (ite $x9 ?0 (|dec_10$| (|nat$| (- ?x7 10)))) ?x72))))
(let ((@x77 (monotonicity @x74 (= (= ?x6 (ite $x9 ?0 (|dec_10$| (|nat$| (- ?x7 10))))) $x75))))
(let ((@x101 (mp (asserted $x15) (trans (|quant-intro| @x77 (= $x15 $x78)) @x98 (= $x15 $x96)) $x96)))
(let ((@x180 (mp (|mp~| @x101 (|nnf-pos| (refl (|~| $x93 $x93)) (|~| $x96 $x96)) $x96) (|quant-intro| (refl (= $x93 $x93)) (= $x96 $x175)) $x175)))
(let (($x209 (not $x175)))
(let (($x400 (or $x209 $x397)))
(let ((@x401 ((_ |quant-inst| (|nat$| 6)) $x400)))
(let ((?x200 (|of_nat$| ?x17)))
(let ((?x383 (* (~ 1) ?x200)))
(let ((?x384 (+ ?x19 ?x383)))
(let (($x385 (<= ?x384 0)))
(let (($x382 (= ?x19 ?x200)))
(let ((?x202 (+ (~ 10) ?x200)))
(let ((?x203 (|nat$| ?x202)))
(let ((?x204 (|dec_10$| ?x203)))
(let (($x201 (>= ?x200 10)))
(let ((?x205 (ite $x201 ?x204 ?x17)))
(let (($x213 (= ?x17 ?x205)))
(let (($x214 (not $x201)))
(let (($x284 (<= ?x200 4)))
(let (($x256 (= ?x200 4)))
(let (($x275 (or $x274 $x256)))
(let ((@x259 (rewrite (= (>= 4 0) true))))
(let ((@x266 (trans (monotonicity @x259 (= (not (>= 4 0)) (not true))) (rewrite (= (not true) false)) (= (not (>= 4 0)) false))))
(let ((@x269 (monotonicity @x266 (= (or (not (>= 4 0)) $x256) (or false $x256)))))
(let ((@x273 (trans @x269 (rewrite (= (or false $x256) $x256)) (= (or (not (>= 4 0)) $x256) $x256))))
(let ((@x279 (monotonicity @x273 (= (or $x274 (or (not (>= 4 0)) $x256)) $x275))))
(let ((@x282 (trans @x279 (rewrite (= $x275 $x275)) (= (or $x274 (or (not (>= 4 0)) $x256)) $x275))))
(let ((@x283 (mp ((_ |quant-inst| 4) (or $x274 (or (not (>= 4 0)) $x256))) @x282 $x275)))
(let ((@x433 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x256) $x284)) (|unit-resolution| @x283 @x193 $x256) $x284)))
(let ((@x438 (|unit-resolution| (|def-axiom| (or $x201 $x213)) (|unit-resolution| ((_ |th-lemma| arith farkas 1 1) (or (not $x284) $x214)) @x433 $x214) $x213)))
(let (($x206 (= ?x18 ?x205)))
(let (($x210 (or $x209 $x206)))
(let ((@x211 ((_ |quant-inst| (|nat$| 4)) $x210)))
(let ((@x443 (trans (|unit-resolution| @x211 @x180 $x206) (symm @x438 (= ?x205 ?x17)) (= ?x18 ?x17))))
(let ((@x448 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x382) $x385)) (monotonicity @x443 $x382) $x385)))
(let (($x386 (>= ?x384 0)))
(let ((@x451 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x382) $x386)) (monotonicity @x443 $x382) $x386)))
(let (($x285 (>= ?x200 4)))
(let ((@x454 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x256) $x285)) (|unit-resolution| @x283 @x193 $x256) $x285)))
(let ((?x207 (|of_nat$| ?x21)))
(let ((?x309 (* (~ 1) ?x207)))
(let ((?x310 (+ ?x20 ?x309)))
(let (($x325 (<= ?x310 0)))
(let (($x307 (= ?x310 0)))
(let (($x299 (>= ?x19 0)))
(let ((@x459 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 1) (or $x299 (not $x285) (not $x386))) @x454 @x451 $x299)))
(let (($x302 (not $x299)))
(let (($x311 (or $x302 $x307)))
(let (($x314 (or $x274 $x302 $x307)))
(let (($x297 (= ?x207 ?x20)))
(let (($x295 (>= ?x20 0)))
(let (($x296 (not $x295)))
(let (($x298 (or $x296 $x297)))
(let (($x315 (or $x274 $x298)))
(let ((@x313 (monotonicity (monotonicity (rewrite (= $x295 $x299)) (= $x296 $x302)) (rewrite (= $x297 $x307)) (= $x298 $x311))))
(let ((@x323 (trans (monotonicity @x313 (= $x315 (or $x274 $x311))) (rewrite (= (or $x274 $x311) $x314)) (= $x315 $x314))))
(let ((@x324 (mp ((_ |quant-inst| (* 4 ?x19)) $x315) @x323 $x314)))
(let ((@x465 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x307) $x325)) (|unit-resolution| (|unit-resolution| @x324 @x193 $x311) @x459 $x307) $x325)))
(let (($x326 (>= ?x310 0)))
(let ((@x468 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x307) $x326)) (|unit-resolution| (|unit-resolution| @x324 @x193 $x311) @x459 $x307) $x326)))
(let ((@x472 (monotonicity ((_ |th-lemma| arith eq-propagate 1 1 -4 -4 -4 -4) @x468 @x465 @x454 @x433 @x451 @x448 (= (+ (~ 10) ?x207) 6)) (= (|nat$| (+ (~ 10) ?x207)) ?x24))))
(let ((?x219 (+ (~ 10) ?x207)))
(let ((?x220 (|nat$| ?x219)))
(let ((?x221 (|dec_10$| ?x220)))
(let (($x208 (>= ?x207 10)))
(let ((?x222 (ite $x208 ?x221 ?x21)))
(let (($x228 (= ?x221 ?x222)))
(let ((@x476 (|unit-resolution| ((_ |th-lemma| arith assign-bounds 1 4 4) (or $x208 (not $x325) (not $x285) (not $x386))) @x454 @x465 @x451 $x208)))
(let ((@x480 (symm (|unit-resolution| (|def-axiom| (or (not $x208) $x228)) @x476 $x228) (= ?x222 ?x221))))
(let (($x223 (= ?x22 ?x222)))
(let (($x226 (or $x209 $x223)))
(let ((@x227 ((_ |quant-inst| (|nat$| ?x20)) $x226)))
(let ((@x488 (trans (trans (|unit-resolution| @x227 @x180 $x223) @x480 (= ?x22 ?x221)) (monotonicity @x472 (= ?x221 ?x389)) (= ?x22 ?x389))))
(let ((@x491 (trans (trans @x488 (|unit-resolution| @x401 @x180 $x397) (= ?x22 ?x396)) (symm @x427 (= ?x396 ?x24)) $x25)))
(let (($x26 (not $x25)))
(let ((@x102 (asserted $x26)))
(|unit-resolution| @x102 @x491 false))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

a25b64a8f04cffe57bd9a525d4bad154c19d2b20 310 0
unsat
((set-logic <null>)
(proof
(let ((?x42 (|map$| |uu$| |xs$|)))
(let ((?x43 (|eval_dioph$| |ks$| ?x42)))
(let ((?x145 (* (~ 1) ?x43)))
(let ((?x146 (+ |l$| ?x145)))
(let ((?x149 (|div$| ?x146 2)))
(let ((?x47 (|map$| |uua$| |xs$|)))
(let ((?x48 (|eval_dioph$| |ks$| ?x47)))
(let ((?x769 (+ ?x48 (* (~ 1) ?x149))))
(let (($x771 (>= ?x769 0)))
(let ((?x452 (* (~ 1) |l$|)))
(let ((?x39 (|eval_dioph$| |ks$| |xs$|)))
(let ((?x776 (+ ?x39 ?x452)))
(let (($x778 (>= ?x776 0)))
(let (($x41 (= ?x39 |l$|)))
(let (($x152 (= ?x48 ?x149)))
(let (($x362 (not $x152)))
(let ((?x45 (|mod$| |l$| 2)))
(let ((?x44 (|mod$| ?x43 2)))
(let (($x46 (= ?x44 ?x45)))
(let (($x361 (not $x46)))
(let (($x363 (or $x361 $x362)))
(let ((?x730 (div ?x43 2)))
(let ((?x913 (* (~ 1) ?x730)))
(let ((?x685 (mod ?x43 2)))
(let ((?x712 (* (~ 1) ?x685)))
(let ((?x645 (div |l$| 2)))
(let ((?x671 (* (~ 1) ?x645)))
(let ((?x599 (mod |l$| 2)))
(let ((?x626 (* (~ 1) ?x599)))
(let ((?x656 (* (~ 1) ?x48)))
(let (($x737 (>= (+ |l$| ?x44 ?x656 ?x626 ?x671 ?x712 ?x913) 1)))
(let ((?x658 (* (~ 2) ?x645)))
(let ((?x659 (+ |l$| ?x626 ?x658)))
(let (($x657 (= ?x659 0)))
(let ((@x108 (|true-axiom| true)))
(let ((@x945 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x657) (>= ?x659 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x657)) @x108 $x657) (>= ?x659 0))))
(let ((?x627 (+ ?x45 ?x626)))
(let (($x628 (= ?x627 0)))
(let (($x418 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x83 (mod ?v0 ?v1)))
(let ((?x230 (* (~ 1) ?v1)))
(let ((?x227 (* (~ 1) ?v0)))
(let ((?x273 (mod ?x227 ?x230)))
(let ((?x279 (* (~ 1) ?x273)))
(let (($x248 (<= ?v1 0)))
(let ((?x299 (ite $x248 ?x279 ?x83)))
(let (($x72 (= ?v1 0)))
(let ((?x304 (ite $x72 ?v0 ?x299)))
(let ((?x82 (|mod$| ?v0 ?v1)))
(= ?x82 ?x304))))))))))) :pattern ( (|mod$| ?v0 ?v1) )))
))
(let (($x310 (forall ((?v0 Int) (?v1 Int) )(let ((?x83 (mod ?v0 ?v1)))
(let ((?x230 (* (~ 1) ?v1)))
(let ((?x227 (* (~ 1) ?v0)))
(let ((?x273 (mod ?x227 ?x230)))
(let ((?x279 (* (~ 1) ?x273)))
(let (($x248 (<= ?v1 0)))
(let ((?x299 (ite $x248 ?x279 ?x83)))
(let (($x72 (= ?v1 0)))
(let ((?x304 (ite $x72 ?v0 ?x299)))
(let ((?x82 (|mod$| ?v0 ?v1)))
(= ?x82 ?x304))))))))))))
))
(let ((?x83 (mod ?1 ?0)))
(let ((?x230 (* (~ 1) ?0)))
(let ((?x227 (* (~ 1) ?1)))
(let ((?x273 (mod ?x227 ?x230)))
(let ((?x279 (* (~ 1) ?x273)))
(let (($x248 (<= ?0 0)))
(let ((?x299 (ite $x248 ?x279 ?x83)))
(let (($x72 (= ?0 0)))
(let ((?x304 (ite $x72 ?1 ?x299)))
(let ((?x82 (|mod$| ?1 ?0)))
(let (($x307 (= ?x82 ?x304)))
(let (($x89 (forall ((?v0 Int) (?v1 Int) )(let (($x72 (= ?v1 0)))
(let ((?x87 (ite $x72 ?v0 (ite (< 0 ?v1) (mod ?v0 ?v1) (- (mod (- ?v0) (- ?v1)))))))
(let ((?x82 (|mod$| ?v0 ?v1)))
(= ?x82 ?x87)))))
))
(let (($x293 (forall ((?v0 Int) (?v1 Int) )(let ((?x230 (* (~ 1) ?v1)))
(let ((?x227 (* (~ 1) ?v0)))
(let ((?x273 (mod ?x227 ?x230)))
(let ((?x279 (* (~ 1) ?x273)))
(let ((?x83 (mod ?v0 ?v1)))
(let (($x73 (< 0 ?v1)))
(let ((?x284 (ite $x73 ?x83 ?x279)))
(let (($x72 (= ?v1 0)))
(let ((?x287 (ite $x72 ?v0 ?x284)))
(let ((?x82 (|mod$| ?v0 ?v1)))
(= ?x82 ?x287))))))))))))
))
(let ((@x298 (monotonicity (rewrite (= (< 0 ?0) (not $x248))) (= (ite (< 0 ?0) ?x83 ?x279) (ite (not $x248) ?x83 ?x279)))))
(let ((@x303 (trans @x298 (rewrite (= (ite (not $x248) ?x83 ?x279) ?x299)) (= (ite (< 0 ?0) ?x83 ?x279) ?x299))))
(let ((@x306 (monotonicity @x303 (= (ite $x72 ?1 (ite (< 0 ?0) ?x83 ?x279)) ?x304))))
(let ((@x309 (monotonicity @x306 (= (= ?x82 (ite $x72 ?1 (ite (< 0 ?0) ?x83 ?x279))) $x307))))
(let (($x73 (< 0 ?0)))
(let ((?x284 (ite $x73 ?x83 ?x279)))
(let ((?x287 (ite $x72 ?1 ?x284)))
(let (($x290 (= ?x82 ?x287)))
(let (($x291 (= (= ?x82 (ite $x72 ?1 (ite $x73 ?x83 (- (mod (- ?1) (- ?0)))))) $x290)))
(let ((@x275 (monotonicity (rewrite (= (- ?1) ?x227)) (rewrite (= (- ?0) ?x230)) (= (mod (- ?1) (- ?0)) ?x273))))
(let ((@x283 (trans (monotonicity @x275 (= (- (mod (- ?1) (- ?0))) (- ?x273))) (rewrite (= (- ?x273) ?x279)) (= (- (mod (- ?1) (- ?0))) ?x279))))
(let ((@x286 (monotonicity @x283 (= (ite $x73 ?x83 (- (mod (- ?1) (- ?0)))) ?x284))))
(let ((@x289 (monotonicity @x286 (= (ite $x72 ?1 (ite $x73 ?x83 (- (mod (- ?1) (- ?0))))) ?x287))))
(let ((@x314 (trans (|quant-intro| (monotonicity @x289 $x291) (= $x89 $x293)) (|quant-intro| @x309 (= $x293 $x310)) (= $x89 $x310))))
(let ((@x360 (|mp~| (mp (asserted $x89) @x314 $x310) (|nnf-pos| (refl (|~| $x307 $x307)) (|~| $x310 $x310)) $x310)))
(let ((@x423 (mp @x360 (|quant-intro| (refl (= $x307 $x307)) (= $x310 $x418)) $x418)))
(let (($x633 (not $x418)))
(let (($x634 (or $x633 $x628)))
(let (($x440 (<= 2 0)))
(let ((?x600 (ite $x440 (* (~ 1) (mod ?x452 (* (~ 1) 2))) ?x599)))
(let (($x439 (= 2 0)))
(let ((?x601 (ite $x439 |l$| ?x600)))
(let (($x602 (= ?x45 ?x601)))
(let ((@x457 (rewrite (= (* (~ 1) 2) (~ 2)))))
(let ((@x608 (monotonicity (monotonicity @x457 (= (mod ?x452 (* (~ 1) 2)) (mod ?x452 (~ 2)))) (= (* (~ 1) (mod ?x452 (* (~ 1) 2))) (* (~ 1) (mod ?x452 (~ 2)))))))
(let ((@x451 (rewrite (= $x440 false))))
(let ((@x611 (monotonicity @x451 @x608 (= ?x600 (ite false (* (~ 1) (mod ?x452 (~ 2))) ?x599)))))
(let ((@x615 (trans @x611 (rewrite (= (ite false (* (~ 1) (mod ?x452 (~ 2))) ?x599) ?x599)) (= ?x600 ?x599))))
(let ((@x449 (rewrite (= $x439 false))))
(let ((@x622 (trans (monotonicity @x449 @x615 (= ?x601 (ite false |l$| ?x599))) (rewrite (= (ite false |l$| ?x599) ?x599)) (= ?x601 ?x599))))
(let ((@x632 (trans (monotonicity @x622 (= $x602 (= ?x45 ?x599))) (rewrite (= (= ?x45 ?x599) $x628)) (= $x602 $x628))))
(let ((@x641 (trans (monotonicity @x632 (= (or $x633 $x602) $x634)) (rewrite (= $x634 $x634)) (= (or $x633 $x602) $x634))))
(let ((@x950 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x628) (>= ?x627 0))) (|unit-resolution| (mp ((_ |quant-inst| |l$| 2) (or $x633 $x602)) @x641 $x634) @x423 $x628) (>= ?x627 0))))
(let (($x1021 (not $x778)))
(let (($x777 (<= ?x776 0)))
(let (($x770 (<= ?x769 0)))
(let (($x364 (not $x363)))
(let ((@x741 (hypothesis $x364)))
(let ((@x1018 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x362 $x770)) (|unit-resolution| (|def-axiom| (or $x363 $x152)) @x741 $x152) $x770)))
(let ((?x520 (+ |l$| ?x145 (* (~ 2) (div ?x146 2)) (* (~ 1) (mod (+ |l$| ?x43) 2)))))
(let (($x517 (= ?x520 0)))
(let ((@x876 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x517) (>= ?x520 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x517)) @x108 $x517) (>= ?x520 0))))
(let ((?x584 (* (~ 2) ?x48)))
(let ((?x585 (+ ?x39 ?x145 ?x584)))
(let (($x586 (= ?x585 0)))
(let (($x384 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(!(let ((?x24 (|eval_dioph$| ?v0 ?v1)))
(let ((?x136 (+ ?x24 (* (~ 1) (|eval_dioph$| ?v0 (|map$| |uu$| ?v1))) (* (~ 2) (|eval_dioph$| ?v0 (|map$| |uua$| ?v1))))))
(= ?x136 0))) :pattern ( (|eval_dioph$| ?v0 (|map$| |uu$| ?v1)) ) :pattern ( (|eval_dioph$| ?v0 (|map$| |uua$| ?v1)) )))
))
(let (($x138 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(let ((?x24 (|eval_dioph$| ?v0 ?v1)))
(let ((?x136 (+ ?x24 (* (~ 1) (|eval_dioph$| ?v0 (|map$| |uu$| ?v1))) (* (~ 2) (|eval_dioph$| ?v0 (|map$| |uua$| ?v1))))))
(= ?x136 0))))
))
(let ((?x24 (|eval_dioph$| ?1 ?0)))
(let ((?x136 (+ ?x24 (* (~ 1) (|eval_dioph$| ?1 (|map$| |uu$| ?0))) (* (~ 2) (|eval_dioph$| ?1 (|map$| |uua$| ?0))))))
(let (($x132 (= ?x136 0)))
(let (($x36 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(let ((?x24 (|eval_dioph$| ?v0 ?v1)))
(let ((?x27 (|eval_dioph$| ?v0 (|map$| |uu$| ?v1))))
(let ((?x34 (+ (* (|eval_dioph$| ?v0 (|map$| |uua$| ?v1)) 2) ?x27)))
(= ?x34 ?x24)))))
))
(let (($x127 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(let ((?x24 (|eval_dioph$| ?v0 ?v1)))
(let ((?x32 (|eval_dioph$| ?v0 (|map$| |uua$| ?v1))))
(let ((?x113 (* 2 ?x32)))
(let ((?x27 (|eval_dioph$| ?v0 (|map$| |uu$| ?v1))))
(let ((?x119 (+ ?x27 ?x113)))
(= ?x119 ?x24)))))))
))
(let ((?x32 (|eval_dioph$| ?1 (|map$| |uua$| ?0))))
(let ((?x113 (* 2 ?x32)))
(let ((?x27 (|eval_dioph$| ?1 (|map$| |uu$| ?0))))
(let ((?x119 (+ ?x27 ?x113)))
(let (($x124 (= ?x119 ?x24)))
(let ((@x118 (monotonicity (rewrite (= (* ?x32 2) ?x113)) (= (+ (* ?x32 2) ?x27) (+ ?x113 ?x27)))))
(let ((@x123 (trans @x118 (rewrite (= (+ ?x113 ?x27) ?x119)) (= (+ (* ?x32 2) ?x27) ?x119))))
(let ((@x129 (|quant-intro| (monotonicity @x123 (= (= (+ (* ?x32 2) ?x27) ?x24) $x124)) (= $x36 $x127))))
(let ((@x142 (trans @x129 (|quant-intro| (rewrite (= $x124 $x132)) (= $x127 $x138)) (= $x36 $x138))))
(let ((@x335 (|mp~| (mp (asserted $x36) @x142 $x138) (|nnf-pos| (refl (|~| $x132 $x132)) (|~| $x138 $x138)) $x138)))
(let ((@x389 (mp @x335 (|quant-intro| (refl (= $x132 $x132)) (= $x138 $x384)) $x384)))
(let ((@x883 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x586) (<= ?x585 0))) (|unit-resolution| ((_ |quant-inst| |ks$| |xs$|) (or (not $x384) $x586)) @x389 $x586) (<= ?x585 0))))
(let ((?x479 (+ ?x149 (* (~ 1) (div ?x146 2)))))
(let (($x480 (= ?x479 0)))
(let (($x411 (forall ((?v0 Int) (?v1 Int) )(!(let ((?x74 (div ?v0 ?v1)))
(let ((?x230 (* (~ 1) ?v1)))
(let ((?x227 (* (~ 1) ?v0)))
(let ((?x233 (div ?x227 ?x230)))
(let (($x248 (<= ?v1 0)))
(let ((?x255 (ite $x248 ?x233 ?x74)))
(let (($x72 (= ?v1 0)))
(let ((?x71 (|div$| ?v0 ?v1)))
(= ?x71 (ite $x72 0 ?x255)))))))))) :pattern ( (|div$| ?v0 ?v1) )))
))
(let (($x266 (forall ((?v0 Int) (?v1 Int) )(let ((?x74 (div ?v0 ?v1)))
(let ((?x230 (* (~ 1) ?v1)))
(let ((?x227 (* (~ 1) ?v0)))
(let ((?x233 (div ?x227 ?x230)))
(let (($x248 (<= ?v1 0)))
(let ((?x255 (ite $x248 ?x233 ?x74)))
(let (($x72 (= ?v1 0)))
(let ((?x71 (|div$| ?v0 ?v1)))
(= ?x71 (ite $x72 0 ?x255)))))))))))
))
(let ((?x71 (|div$| ?1 ?0)))
(let (($x263 (= ?x71 (ite $x72 0 (ite $x248 (div ?x227 ?x230) (div ?1 ?0))))))
(let (($x81 (forall ((?v0 Int) (?v1 Int) )(let (($x72 (= ?v1 0)))
(let ((?x79 (ite $x72 0 (ite (< 0 ?v1) (div ?v0 ?v1) (div (- ?v0) (- ?v1))))))
(let ((?x71 (|div$| ?v0 ?v1)))
(= ?x71 ?x79)))))
))
(let (($x245 (forall ((?v0 Int) (?v1 Int) )(let ((?x230 (* (~ 1) ?v1)))
(let ((?x227 (* (~ 1) ?v0)))
(let ((?x233 (div ?x227 ?x230)))
(let ((?x74 (div ?v0 ?v1)))
(let (($x73 (< 0 ?v1)))
(let ((?x236 (ite $x73 ?x74 ?x233)))
(let (($x72 (= ?v1 0)))
(let ((?x239 (ite $x72 0 ?x236)))
(let ((?x71 (|div$| ?v0 ?v1)))
(= ?x71 ?x239)))))))))))
))
(let ((?x233 (div ?x227 ?x230)))
(let ((?x74 (div ?1 ?0)))
(let ((?x236 (ite $x73 ?x74 ?x233)))
(let ((?x239 (ite $x72 0 ?x236)))
(let (($x242 (= ?x71 ?x239)))
(let ((@x254 (monotonicity (rewrite (= $x73 (not $x248))) (= ?x236 (ite (not $x248) ?x74 ?x233)))))
(let ((@x259 (trans @x254 (rewrite (= (ite (not $x248) ?x74 ?x233) (ite $x248 ?x233 ?x74))) (= ?x236 (ite $x248 ?x233 ?x74)))))
(let ((@x265 (monotonicity (monotonicity @x259 (= ?x239 (ite $x72 0 (ite $x248 ?x233 ?x74)))) (= $x242 $x263))))
(let (($x243 (= (= ?x71 (ite $x72 0 (ite $x73 ?x74 (div (- ?1) (- ?0))))) $x242)))
(let ((@x235 (monotonicity (rewrite (= (- ?1) ?x227)) (rewrite (= (- ?0) ?x230)) (= (div (- ?1) (- ?0)) ?x233))))
(let ((@x241 (monotonicity (monotonicity @x235 (= (ite $x73 ?x74 (div (- ?1) (- ?0))) ?x236)) (= (ite $x72 0 (ite $x73 ?x74 (div (- ?1) (- ?0)))) ?x239))))
(let ((@x270 (trans (|quant-intro| (monotonicity @x241 $x243) (= $x81 $x245)) (|quant-intro| @x265 (= $x245 $x266)) (= $x81 $x266))))
(let ((@x355 (|mp~| (mp (asserted $x81) @x270 $x266) (|nnf-pos| (refl (|~| $x263 $x263)) (|~| $x266 $x266)) $x266)))
(let ((@x416 (mp @x355 (|quant-intro| (refl (= $x263 $x263)) (= $x266 $x411)) $x411)))
(let (($x486 (or (not $x411) $x480)))
(let ((?x444 (div ?x146 2)))
(let ((?x445 (ite $x440 (div (* (~ 1) ?x146) (* (~ 1) 2)) ?x444)))
(let ((?x446 (ite $x439 0 ?x445)))
(let (($x447 (= ?x149 ?x446)))
(let ((@x460 (monotonicity (rewrite (= (* (~ 1) ?x146) (+ ?x452 ?x43))) @x457 (= (div (* (~ 1) ?x146) (* (~ 1) 2)) (div (+ ?x452 ?x43) (~ 2))))))
(let ((@x463 (monotonicity @x451 @x460 (= ?x445 (ite false (div (+ ?x452 ?x43) (~ 2)) ?x444)))))
(let ((@x467 (trans @x463 (rewrite (= (ite false (div (+ ?x452 ?x43) (~ 2)) ?x444) ?x444)) (= ?x445 ?x444))))
(let ((@x474 (trans (monotonicity @x449 @x467 (= ?x446 (ite false 0 ?x444))) (rewrite (= (ite false 0 ?x444) ?x444)) (= ?x446 ?x444))))
(let ((@x484 (trans (monotonicity @x474 (= $x447 (= ?x149 ?x444))) (rewrite (= (= ?x149 ?x444) $x480)) (= $x447 $x480))))
(let ((@x493 (trans (monotonicity @x484 (= (or (not $x411) $x447) $x486)) (rewrite (= $x486 $x486)) (= (or (not $x411) $x447) $x486))))
(let ((@x885 (|unit-resolution| (mp ((_ |quant-inst| (+ |l$| ?x145) 2) (or (not $x411) $x447)) @x493 $x486) @x416 $x480)))
(let ((@x889 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x480) (<= ?x479 0))) @x885 (<= ?x479 0))))
(let ((@x892 (|unit-resolution| ((_ |th-lemma| arith) (or false (>= (mod (+ |l$| ?x43) 2) 0))) @x108 (>= (mod (+ |l$| ?x43) 2) 0))))
(let ((@x893 ((_ |th-lemma| arith farkas 1 -2 -2 -1 1 1) @x892 @x889 (hypothesis $x770) @x883 (hypothesis (not $x777)) @x876 false)))
(let (($x169 (not $x41)))
(let (($x370 (= $x41 $x363)))
(let ((@x369 (monotonicity (rewrite (= (and $x46 $x152) $x364)) (= (= $x169 (and $x46 $x152)) (= $x169 $x364)))))
(let ((@x374 (trans @x369 (rewrite (= (= $x169 $x364) $x370)) (= (= $x169 (and $x46 $x152)) $x370))))
(let (($x155 (and $x46 $x152)))
(let (($x170 (= $x169 $x155)))
(let (($x53 (= $x41 (and $x46 (= ?x48 (|div$| (- |l$| ?x43) 2))))))
(let (($x54 (not $x53)))
(let ((@x151 (monotonicity (rewrite (= (- |l$| ?x43) ?x146)) (= (|div$| (- |l$| ?x43) 2) ?x149))))
(let ((@x157 (monotonicity (monotonicity @x151 (= (= ?x48 (|div$| (- |l$| ?x43) 2)) $x152)) (= (and $x46 (= ?x48 (|div$| (- |l$| ?x43) 2))) $x155))))
(let ((@x165 (trans (monotonicity @x157 (= $x53 (= $x41 $x155))) (rewrite (= (= $x41 $x155) (= $x41 $x155))) (= $x53 (= $x41 $x155)))))
(let ((@x174 (trans (monotonicity @x165 (= $x54 (not (= $x41 $x155)))) (rewrite (= (not (= $x41 $x155)) $x170)) (= $x54 $x170))))
(let ((@x375 (mp (mp (asserted $x54) @x174 $x170) @x374 $x370)))
(let ((@x438 (|unit-resolution| (|def-axiom| (or $x169 $x363 (not $x370))) @x375 (or $x169 $x363))))
(let ((@x1025 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x41 (not $x777) $x1021)) (|unit-resolution| @x438 @x741 $x169) (or (not $x777) $x1021))))
(let ((@x1026 (|unit-resolution| @x1025 (|unit-resolution| (lemma @x893 (or $x777 (not $x770))) @x1018 $x777) $x1021)))
(let ((@x1029 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x361 (>= (+ ?x44 (* (~ 1) ?x45)) 0))) (|unit-resolution| (|def-axiom| (or $x363 $x46)) @x741 $x46) (>= (+ ?x44 (* (~ 1) ?x45)) 0))))
(let ((?x744 (+ ?x43 ?x712 (* (~ 2) ?x730))))
(let (($x742 (= ?x744 0)))
(let ((@x1032 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x742) (>= ?x744 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x742)) @x108 $x742) (>= ?x744 0))))
(let ((?x713 (+ ?x44 ?x712)))
(let (($x714 (= ?x713 0)))
(let (($x719 (or $x633 $x714)))
(let ((?x686 (ite $x440 (* (~ 1) (mod ?x145 (* (~ 1) 2))) ?x685)))
(let ((?x687 (ite $x439 ?x43 ?x686)))
(let (($x688 (= ?x44 ?x687)))
(let ((@x694 (monotonicity (monotonicity @x457 (= (mod ?x145 (* (~ 1) 2)) (mod ?x145 (~ 2)))) (= (* (~ 1) (mod ?x145 (* (~ 1) 2))) (* (~ 1) (mod ?x145 (~ 2)))))))
(let ((@x697 (monotonicity @x451 @x694 (= ?x686 (ite false (* (~ 1) (mod ?x145 (~ 2))) ?x685)))))
(let ((@x701 (trans @x697 (rewrite (= (ite false (* (~ 1) (mod ?x145 (~ 2))) ?x685) ?x685)) (= ?x686 ?x685))))
(let ((@x708 (trans (monotonicity @x449 @x701 (= ?x687 (ite false ?x43 ?x685))) (rewrite (= (ite false ?x43 ?x685) ?x685)) (= ?x687 ?x685))))
(let ((@x718 (trans (monotonicity @x708 (= $x688 (= ?x44 ?x685))) (rewrite (= (= ?x44 ?x685) $x714)) (= $x688 $x714))))
(let ((@x726 (trans (monotonicity @x718 (= (or $x633 $x688) $x719)) (rewrite (= $x719 $x719)) (= (or $x633 $x688) $x719))))
(let ((@x1035 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x714) (>= ?x713 0))) (|unit-resolution| (mp ((_ |quant-inst| (|eval_dioph$| |ks$| ?x42) 2) (or $x633 $x688)) @x726 $x719) @x423 $x714) (>= ?x713 0))))
(let ((@x992 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x586) (>= ?x585 0))) (|unit-resolution| ((_ |quant-inst| |ks$| |xs$|) (or (not $x384) $x586)) @x389 $x586) (>= ?x585 0))))
(let ((?x773 (+ ?x44 (* (~ 1) ?x45))))
(let (($x774 (<= ?x773 0)))
(let ((@x1010 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x361 $x774)) (|unit-resolution| (|def-axiom| (or $x363 $x46)) @x741 $x46) $x774)))
(let ((@x1014 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x362 $x771)) (|unit-resolution| (|def-axiom| (or $x363 $x152)) @x741 $x152) $x771)))
(let ((@x963 (|unit-resolution| ((_ |th-lemma| arith) (or false (not (>= (mod (+ |l$| ?x43) 2) 2)))) @x108 (not (>= (mod (+ |l$| ?x43) 2) 2)))))
(let ((@x748 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x628) (<= ?x627 0))) (|unit-resolution| (mp ((_ |quant-inst| |l$| 2) (or $x633 $x602)) @x641 $x634) @x423 $x628) (<= ?x627 0))))
(let ((@x932 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x742) (<= ?x744 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x742)) @x108 $x742) (<= ?x744 0))))
(let ((@x852 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x657) (<= ?x659 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x657)) @x108 $x657) (<= ?x659 0))))
(let ((@x937 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x714) (<= ?x713 0))) (|unit-resolution| (mp ((_ |quant-inst| (|eval_dioph$| |ks$| ?x42) 2) (or $x633 $x688)) @x726 $x719) @x423 $x714) (<= ?x713 0))))
(let ((@x954 (hypothesis $x771)))
(let ((@x957 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x480) (>= ?x479 0))) @x885 (>= ?x479 0))))
(let ((@x960 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or (not $x517) (<= ?x520 0))) (|unit-resolution| ((_ |th-lemma| arith) (or false $x517)) @x108 $x517) (<= ?x520 0))))
(let ((@x515 ((_ |th-lemma| arith farkas 1 -2 -2 -2 1 1 1 1 1 1) @x960 @x957 @x954 (hypothesis $x737) @x937 @x852 @x932 (hypothesis $x774) @x748 @x963 false)))
(let ((@x1015 (|unit-resolution| (lemma @x515 (or (not $x737) (not $x771) (not $x774))) @x1014 @x1010 (not $x737))))
(let ((@x1037 (|unit-resolution| @x1015 ((_ |th-lemma| arith) @x992 @x1035 @x1032 @x1029 @x1026 @x950 @x945 $x737) false)))
(let ((@x1038 (lemma @x1037 $x363)))
(let ((@x434 (|unit-resolution| (|def-axiom| (or $x41 $x364 (not $x370))) @x375 (or $x41 $x364))))
(let ((@x1120 (|unit-resolution| @x434 @x1038 $x41)))
(let ((@x1125 ((_ |th-lemma| arith farkas 2 2 1 1 1 1) (hypothesis (not $x771)) @x889 @x892 @x876 @x883 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x169 $x778)) @x1120 $x778) false)))
(let ((@x1048 ((_ |th-lemma| arith farkas -1 1 1 -2 -2 1) @x992 (|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x169 $x777)) @x1120 $x777) @x960 @x957 (hypothesis (not $x770)) @x963 false)))
(let ((?x587 (|mod$| ?x39 2)))
(let (($x588 (= ?x587 ?x44)))
(let (($x377 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(!(= (|mod$| (|eval_dioph$| ?v0 ?v1) 2) (|mod$| (|eval_dioph$| ?v0 (|map$| |uu$| ?v1)) 2)) :pattern ( (|eval_dioph$| ?v0 (|map$| |uu$| ?v1)) )))
))
(let (($x30 (forall ((?v0 |Int_list$|) (?v1 |Nat_list$|) )(= (|mod$| (|eval_dioph$| ?v0 ?v1) 2) (|mod$| (|eval_dioph$| ?v0 (|map$| |uu$| ?v1)) 2)))
))
(let (($x29 (= (|mod$| ?x24 2) (|mod$| ?x27 2))))
(let ((@x330 (|mp~| (asserted $x30) (|nnf-pos| (refl (|~| $x29 $x29)) (|~| $x30 $x30)) $x30)))
(let ((@x382 (mp @x330 (|quant-intro| (refl (= $x29 $x29)) (= $x30 $x377)) $x377)))
(let ((@x1104 (symm (|unit-resolution| ((_ |quant-inst| |ks$| |xs$|) (or (not $x377) $x588)) @x382 $x588) (= ?x44 ?x587))))
(let ((@x763 (|unit-resolution| (hypothesis $x361) (trans @x1104 (monotonicity @x1120 (= ?x587 ?x45)) $x46) false)))
(let ((@x1050 (|unit-resolution| (|unit-resolution| (|def-axiom| (or $x364 $x361 $x362)) @x1038 $x363) (lemma @x763 $x46) $x362)))
(|unit-resolution| ((_ |th-lemma| arith triangle-eq) (or $x152 (not $x770) (not $x771))) @x1050 (lemma @x1048 $x770) (lemma @x1125 $x771) false)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

d4d0e08ac1741a77a8448ec3a55e48fb2a240ee9 62 0
unsat
((set-logic AUFLIA)
(proof
(let ((?x32 (|collect$| |uu$|)))
(let ((?x33 (|sup$| ?x32)))
(let (($x38 (|less_eq$| ?x33 ?x33)))
(let (($x39 (not $x38)))
(let ((@x117 (asserted $x39)))
(let ((?x34 (|collect$| |uua$|)))
(let ((?x35 (|sup$| ?x34)))
(let (($x37 (|less_eq$| ?x35 ?x33)))
(let ((@x115 (asserted $x37)))
(let (($x36 (|less_eq$| ?x33 ?x35)))
(let ((@x114 (asserted $x36)))
(let (($x159 (forall ((?v0 |A$|) (?v1 |A$|) (?v2 |A$|) )(!(let (($x29 (|less_eq$| ?v0 ?v2)))
(let (($x27 (|less_eq$| ?v1 ?v2)))
(let (($x136 (not $x27)))
(let (($x26 (|less_eq$| ?v0 ?v1)))
(let (($x135 (not $x26)))
(or $x135 $x136 $x29)))))) :pattern ( (|less_eq$| ?v0 ?v1) (|less_eq$| ?v1 ?v2) )))
))
(let (($x154 (forall ((?v0 |A$|) (?v1 |A$|) (?v2 |A$|) )(let (($x29 (|less_eq$| ?v0 ?v2)))
(let (($x27 (|less_eq$| ?v1 ?v2)))
(let (($x136 (not $x27)))
(let (($x26 (|less_eq$| ?v0 ?v1)))
(let (($x135 (not $x26)))
(or $x135 $x136 $x29)))))))
))
(let (($x29 (|less_eq$| ?2 ?0)))
(let (($x27 (|less_eq$| ?1 ?0)))
(let (($x136 (not $x27)))
(let (($x26 (|less_eq$| ?2 ?1)))
(let (($x135 (not $x26)))
(let (($x149 (or $x135 $x136 $x29)))
(let (($x111 (forall ((?v0 |A$|) (?v1 |A$|) (?v2 |A$|) )(let (($x29 (|less_eq$| ?v0 ?v2)))
(let (($x27 (|less_eq$| ?v1 ?v2)))
(let (($x26 (|less_eq$| ?v0 ?v1)))
(let (($x28 (and $x26 $x27)))
(let (($x106 (not $x28)))
(or $x106 $x29)))))))
))
(let ((@x141 (monotonicity (rewrite (= (and $x26 $x27) (not (or $x135 $x136)))) (= (not (and $x26 $x27)) (not (not (or $x135 $x136)))))))
(let ((@x145 (trans @x141 (rewrite (= (not (not (or $x135 $x136))) (or $x135 $x136))) (= (not (and $x26 $x27)) (or $x135 $x136)))))
(let ((@x148 (monotonicity @x145 (= (or (not (and $x26 $x27)) $x29) (or (or $x135 $x136) $x29)))))
(let ((@x153 (trans @x148 (rewrite (= (or (or $x135 $x136) $x29) $x149)) (= (or (not (and $x26 $x27)) $x29) $x149))))
(let ((@x129 (refl (|~| (or (not (and $x26 $x27)) $x29) (or (not (and $x26 $x27)) $x29)))))
(let (($x31 (forall ((?v0 |A$|) (?v1 |A$|) (?v2 |A$|) )(let (($x29 (|less_eq$| ?v0 ?v2)))
(let (($x27 (|less_eq$| ?v1 ?v2)))
(let (($x26 (|less_eq$| ?v0 ?v1)))
(let (($x28 (and $x26 $x27)))
(=> $x28 $x29))))))
))
(let ((@x110 (rewrite (= (=> (and $x26 $x27) $x29) (or (not (and $x26 $x27)) $x29)))))
(let ((@x132 (|mp~| (mp (asserted $x31) (|quant-intro| @x110 (= $x31 $x111)) $x111) (|nnf-pos| @x129 (|~| $x111 $x111)) $x111)))
(let ((@x164 (mp (mp @x132 (|quant-intro| @x153 (= $x111 $x154)) $x154) (|quant-intro| (refl (= $x149 $x149)) (= $x154 $x159)) $x159)))
(let (($x166 (not $x37)))
(let (($x165 (not $x36)))
(let (($x170 (not $x159)))
(let (($x171 (or $x170 $x165 $x166 $x38)))
(let ((@x176 (mp ((_ |quant-inst| (|sup$| ?x32) (|sup$| ?x34) (|sup$| ?x32)) (or $x170 (or $x165 $x166 $x38))) (rewrite (= (or $x170 (or $x165 $x166 $x38)) $x171)) $x171)))
(|unit-resolution| @x176 @x164 @x114 @x115 @x117 false)))))))))))))))))))))))))))))))))))))

ce2ba5128c1bc3cef10c9328de9b15558b908319 25 0
unsat
((set-logic AUFLIA)
(proof
(let (($x51 (|pred$e| 1)))
(let (($x52 (not $x51)))
(let ((@x142 (asserted $x52)))
(let (($x198 (forall ((?v0 Int) )(!(|pred$e| ?v0) :pattern ( (|pred$e| ?v0) )))
))
(let (($x139 (forall ((?v0 Int) )(|pred$e| ?v0))
))
(let (($x49 (forall ((?v0 Int) )(let (($x47 (or (|pred$d| (|cons$d| ?v0 |nil$d|)) (not (|pred$d| (|cons$d| ?v0 |nil$d|))))))
(let (($x42 (|pred$e| ?v0)))
(and $x42 $x47))))
))
(let (($x42 (|pred$e| ?0)))
(let (($x47 (or (|pred$d| (|cons$d| ?0 |nil$d|)) (not (|pred$d| (|cons$d| ?0 |nil$d|))))))
(let (($x48 (and $x42 $x47)))
(let ((@x134 (monotonicity (rewrite (= $x47 true)) (= $x48 (and $x42 true)))))
(let ((@x141 (|quant-intro| (trans @x134 (rewrite (= (and $x42 true) $x42)) (= $x48 $x42)) (= $x49 $x139))))
(let ((@x168 (|mp~| (mp (asserted $x49) @x141 $x139) (|nnf-pos| (refl (|~| $x42 $x42)) (|~| $x139 $x139)) $x139)))
(let ((@x203 (mp @x168 (|quant-intro| (refl (= $x42 $x42)) (= $x139 $x198)) $x198)))
(let (($x207 (or (not $x198) $x51)))
(let ((@x208 ((_ |quant-inst| 1) $x207)))
(|unit-resolution| @x208 @x203 @x142 false))))))))))))))))))