From e306d14db5b26b12ba080fa69e8390472cb32e07 Mon Sep 17 00:00:00 2001
From: Denis Varlakov <cordial.egg6523@fastmail.com>
Date: Thu, 15 Oct 2026 14:44:50 +0200
Subject: [PATCH 1/7] Replace glass_pumpkin dependency by copy-pasting code and
 adjusting it

I've taken the only primarity test that we are using in our library from `glass_pumpkin v2.0.0`. I
modified the code to work with version of `rand_core` that we depend on.

Signed-off-by: Denis Varlakov <cordial.egg6523@fastmail.com>
---
 Cargo.lock                |  40 -----
 Cargo.toml                |   8 +-
 src/backend/num_bigint.rs | 329 +++++++++++++++++++++++++++++++++++++-
 3 files changed, 330 insertions(+), 47 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 9bed866..519e1df 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -134,15 +134,6 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 
-[[package]]
-name = "core2"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b49ba7ef1ad6107f8824dbe97de947cbaac53c44e7f9756a1fba0d37c1eec505"
-dependencies = [
- "memchr",
-]
-
 [[package]]
 name = "criterion"
 version = "0.5.1"
@@ -179,12 +170,6 @@ dependencies = [
  "itertools",
 ]
 
-[[package]]
-name = "critical-section"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
-
 [[package]]
 name = "crossbeam-deque"
 version = "0.8.6"
@@ -258,7 +243,6 @@ dependencies = [
  "bytemuck",
  "ciborium",
  "criterion",
- "glass_pumpkin",
  "libpaillier",
  "num-bigint",
  "num-integer",
@@ -294,20 +278,6 @@ dependencies = [
  "wasi",
 ]
 
-[[package]]
-name = "glass_pumpkin"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17567f20aa6eef73871963dfa01cde07c6300d46f4ab4ed82681100fa0a6012c"
-dependencies = [
- "core2",
- "num-bigint",
- "num-integer",
- "num-traits",
- "once_cell",
- "rand_core",
-]
-
 [[package]]
 name = "gmp-mpfr-sys"
 version = "1.6.8"
@@ -448,10 +418,6 @@ name = "once_cell"
 version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
-dependencies = [
- "critical-section",
- "portable-atomic",
-]
 
 [[package]]
 name = "oorandom"
@@ -487,12 +453,6 @@ dependencies = [
  "plotters-backend",
 ]
 
-[[package]]
-name = "portable-atomic"
-version = "1.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
-
 [[package]]
 name = "ppv-lite86"
 version = "0.2.21"
diff --git a/Cargo.toml b/Cargo.toml
index 4586565..78caa0b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,7 +18,6 @@ bytemuck = { version = "1.5", features = ["derive"], optional = true }
 num-bigint = { version = "0.4.6", optional = true, default-features = false, features = ["rand"] }
 num-traits = { version = "0.2.19", optional = true, default-features = false }
 num-integer = { version = "0.1.46", optional = true, default-features = false }
-glass_pumpkin = { version = "1.8", optional = true, default-features = false }
 rand = { version = "0.8", optional = true, default-features = false }
 
 rand_core = "0.6"
@@ -45,14 +44,14 @@ libpaillier = { version = "0.5", default-features = false, features = ["gmp"] }
 [features]
 default = ["backend-num-bigint", "std"]
 
-std = ["glass_pumpkin?/std"]
-no_std = ["glass_pumpkin?/no_std"]
+std = []
+no_std = []
 
 serde = ["dep:serde"]
 quickcheck = ["dep:quickcheck"]
 
 backend-rug = ["dep:rug", "dep:bytemuck"]
-backend-num-bigint = ["dep:num-bigint", "dep:num-traits", "dep:num-integer", "dep:glass_pumpkin", "dep:rand"]
+backend-num-bigint = ["dep:num-bigint", "dep:num-traits", "dep:num-integer", "dep:rand"]
 
 [[bench]]
 name = "comparison"
@@ -63,4 +62,3 @@ harness = false
 num-bigint.opt-level = 3
 num-traits.opt-level = 3
 num-integer.opt-level = 3
-glass_pumpkin.opt-level = 3
diff --git a/src/backend/num_bigint.rs b/src/backend/num_bigint.rs
index 7025f49..ed22ed0 100644
--- a/src/backend/num_bigint.rs
+++ b/src/backend/num_bigint.rs
@@ -297,7 +297,7 @@ impl Integer {
     pub fn is_probably_prime(&self, _reps: u32, rng: &mut impl rand_core::RngCore) -> IsPrime {
         if self.cmp0().is_le() {
             IsPrime::No
-        } else if glass_pumpkin::prime::check_with(self.0.magnitude(), rng) {
+        } else if glass_pumpkin::is_prime(self.0.magnitude(), rng) {
             IsPrime::Yes
         } else {
             IsPrime::No
@@ -310,7 +310,7 @@ impl Integer {
             x.assign_random_bits(bit_size, rng);
             x.set_bit(bit_size - 1, true);
             x |= 1u32;
-            if glass_pumpkin::prime::check_with(x.0.magnitude(), rng) {
+            if glass_pumpkin::is_prime(x.0.magnitude(), rng) {
                 break x;
             }
         }
@@ -424,6 +424,331 @@ impl quickcheck::Arbitrary for Integer {
     }
 }
 
+/// This module was taken from <https://docs.rs/glass_pumpkin/2.0.0/src/glass_pumpkin/common.rs.html>
+/// preserving only function that performs primarity test. The code was modified to work with
+/// older version of the `rand_core` crate.
+///
+/// We cannot use the latest version of the library as it requires introducing breaking changes
+/// in the code. We cannot use older version of the library, which has compatible `rand_core`
+/// dependency, as it is buggy.
+///
+/// We can migrate back to that dependency when we update our ecosystem to latest `rand_core`.
+mod glass_pumpkin {
+    use num_bigint::{BigUint, RandBigInt as _};
+    use num_integer::Integer as _;
+    use num_traits::{One as _, ToPrimitive as _};
+    use rand_core::RngCore;
+
+    /// Test if number is prime by
+    ///
+    /// 1- Trial division by first 2048 primes
+    /// 2- Perform log2(bitlength) + 5 rounds of Miller-Rabin
+    ///    depending on the number of bits
+    pub fn is_prime<R: RngCore + ?Sized>(candidate: &BigUint, rng: &mut R) -> bool {
+        is_prime_with_rng(
+            candidate,
+            required_checks(candidate.bits() as usize),
+            false,
+            rng,
+        )
+    }
+
+    fn is_prime_with_rng<R: RngCore + ?Sized>(
+        candidate: &BigUint,
+        checks: usize,
+        q_check: bool,
+        rng: &mut R,
+    ) -> bool {
+        if candidate.to_u64() == Some(2) {
+            return true;
+        }
+
+        if candidate.is_even() || candidate.is_one() {
+            return false;
+        }
+
+        if !passes_small_prime_sieve(candidate, q_check) {
+            return false;
+        }
+        if candidate
+            .to_u32()
+            .is_some_and(|value| value <= MAX_SMALL_PRIME)
+        {
+            return true;
+        }
+
+        // Finally, do a Miller-Rabin test
+        // See https://eprint.iacr.org/2018/749.pdf for good choices on appropriate number of tests
+        if !MillerRabin::new(candidate).random_checks(checks, rng) {
+            return false;
+        }
+
+        true
+    }
+
+    /// Minimum checks to be considered okay
+    #[inline]
+    fn required_checks(bits: usize) -> usize {
+        (bits.checked_ilog2().unwrap_or(1) as usize) + 5
+    }
+
+    /// Candidate-specific values shared by every Miller-Rabin base.
+    struct MillerRabin<'a> {
+        candidate: &'a BigUint,
+        candidate_minus_one: BigUint,
+        odd_part: BigUint,
+        trials: u64,
+    }
+
+    impl<'a> MillerRabin<'a> {
+        fn new(candidate: &'a BigUint) -> Self {
+            let candidate_minus_one = candidate - 1_u8;
+            let trials = candidate_minus_one.trailing_zeros().unwrap_or_default();
+            let odd_part = &candidate_minus_one >> trials;
+            Self {
+                candidate,
+                candidate_minus_one,
+                odd_part,
+                trials,
+            }
+        }
+
+        fn check_base(&self, basis: &BigUint) -> bool {
+            let mut test = basis.modpow(&self.odd_part, self.candidate);
+
+            if test.is_one() || test == self.candidate_minus_one {
+                return true;
+            }
+
+            for _ in 1..self.trials {
+                test = (&test * &test) % self.candidate;
+                if test == self.candidate_minus_one {
+                    return true;
+                }
+                if test.is_one() {
+                    return false;
+                }
+            }
+
+            false
+        }
+
+        fn random_checks<R: RngCore + ?Sized>(&self, limit: usize, rng: &mut R) -> bool {
+            // Sampling [0, n-3) and adding two produces exactly [2, n-1),
+            // without rebuilding that span for every base.
+            let basis_span = self.candidate - 3_u8;
+            for _ in 0..limit {
+                let basis = rng.gen_biguint_below(&basis_span) + 2_u8;
+                if !self.check_base(&basis) {
+                    return false;
+                }
+            }
+
+            true
+        }
+    }
+
+    fn passes_small_prime_sieve(candidate: &BigUint, q_check: bool) -> bool {
+        if let Some(small) = candidate.to_u32() {
+            if small <= MAX_SMALL_PRIME {
+                return small == 2 || PRIMES.binary_search(&small).is_ok();
+            }
+        }
+
+        // Batch adjacent primes into the largest product that fits in a `u32`.
+        // This roughly halves the number of big-integer remainder operations while
+        // retaining the scalar fast path in `num-bigint`.
+        let use_native_remainder = cfg!(debug_assertions) || candidate.bits() > 6144;
+        let mut start = 0;
+        while start < PRIMES.len() {
+            let mut product = 1_u32;
+            let mut end = start;
+            while end < PRIMES.len() {
+                let Some(next) = product.checked_mul(PRIMES[end]) else {
+                    break;
+                };
+                product = next;
+                end += 1;
+            }
+
+            let batch_remainder = if use_native_remainder {
+                (candidate % product)
+                    .iter_u32_digits()
+                    .next()
+                    .unwrap_or_default()
+            } else {
+                rem_u32(candidate, product)
+            };
+            for &prime in &PRIMES[start..end] {
+                let remainder = batch_remainder % prime;
+                if remainder == 0 || q_check && remainder == (prime - 1) / 2 {
+                    return false;
+                }
+            }
+            start = end;
+        }
+
+        true
+    }
+
+    /// Compute a small remainder through `num-bigint`'s public arithmetic traits.
+    #[inline]
+    fn rem_u32(n: &BigUint, modulus: u32) -> u32 {
+        let modulus = u64::from(modulus);
+        let remainder = n.iter_u32_digits().rev().fold(0_u64, |remainder, digit| {
+            ((remainder << 32) | u64::from(digit)) % modulus
+        });
+        remainder as u32
+    }
+
+    static PRIMES: &[u32] = &[
+        3_u32, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83,
+        89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179,
+        181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277,
+        281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389,
+        397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499,
+        503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617,
+        619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739,
+        743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859,
+        863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991,
+        997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091,
+        1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201,
+        1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301,
+        1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433,
+        1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531,
+        1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621,
+        1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747,
+        1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873,
+        1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997,
+        1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099,
+        2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237,
+        2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341,
+        2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441,
+        2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591,
+        2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693,
+        2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797,
+        2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917,
+        2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049,
+        3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191,
+        3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319,
+        3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449,
+        3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547,
+        3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671,
+        3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793,
+        3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917,
+        3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027,
+        4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157,
+        4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273,
+        4283, 4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423,
+        4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549,
+        4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673,
+        4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801,
+        4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951,
+        4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, 5039, 5051, 5059,
+        5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189, 5197,
+        5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347,
+        5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471,
+        5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581,
+        5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711,
+        5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843,
+        5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981,
+        5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113,
+        6121, 6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247,
+        6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353,
+        6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491,
+        6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, 6607, 6619, 6637, 6653,
+        6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779,
+        6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, 6857, 6863, 6869, 6871, 6883, 6899,
+        6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013,
+        7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121, 7127, 7129, 7151, 7159, 7177,
+        7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309,
+        7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481,
+        7487, 7489, 7499, 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577,
+        7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 7699,
+        7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853,
+        7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951, 7963, 7993,
+        8009, 8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123,
+        8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221, 8231, 8233, 8237, 8243, 8263, 8269,
+        8273, 8287, 8291, 8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, 8389, 8419,
+        8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, 8513, 8521, 8527, 8537, 8539, 8543, 8563,
+        8573, 8581, 8597, 8599, 8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, 8681, 8689,
+        8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, 8747, 8753, 8761, 8779, 8783, 8803, 8807,
+        8819, 8821, 8831, 8837, 8839, 8849, 8861, 8863, 8867, 8887, 8893, 8923, 8929, 8933, 8941,
+        8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, 9013, 9029, 9041, 9043, 9049, 9059, 9067,
+        9091, 9103, 9109, 9127, 9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, 9203, 9209,
+        9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, 9293, 9311, 9319, 9323, 9337, 9341, 9343,
+        9349, 9371, 9377, 9391, 9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, 9461, 9463,
+        9467, 9473, 9479, 9491, 9497, 9511, 9521, 9533, 9539, 9547, 9551, 9587, 9601, 9613, 9619,
+        9623, 9629, 9631, 9643, 9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739, 9743,
+        9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, 9817, 9829, 9833, 9839, 9851, 9857, 9859,
+        9871, 9883, 9887, 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973, 10007, 10009,
+        10037, 10039, 10061, 10067, 10069, 10079, 10091, 10093, 10099, 10103, 10111, 10133, 10139,
+        10141, 10151, 10159, 10163, 10169, 10177, 10181, 10193, 10211, 10223, 10243, 10247, 10253,
+        10259, 10267, 10271, 10273, 10289, 10301, 10303, 10313, 10321, 10331, 10333, 10337, 10343,
+        10357, 10369, 10391, 10399, 10427, 10429, 10433, 10453, 10457, 10459, 10463, 10477, 10487,
+        10499, 10501, 10513, 10529, 10531, 10559, 10567, 10589, 10597, 10601, 10607, 10613, 10627,
+        10631, 10639, 10651, 10657, 10663, 10667, 10687, 10691, 10709, 10711, 10723, 10729, 10733,
+        10739, 10753, 10771, 10781, 10789, 10799, 10831, 10837, 10847, 10853, 10859, 10861, 10867,
+        10883, 10889, 10891, 10903, 10909, 10937, 10939, 10949, 10957, 10973, 10979, 10987, 10993,
+        11003, 11027, 11047, 11057, 11059, 11069, 11071, 11083, 11087, 11093, 11113, 11117, 11119,
+        11131, 11149, 11159, 11161, 11171, 11173, 11177, 11197, 11213, 11239, 11243, 11251, 11257,
+        11261, 11273, 11279, 11287, 11299, 11311, 11317, 11321, 11329, 11351, 11353, 11369, 11383,
+        11393, 11399, 11411, 11423, 11437, 11443, 11447, 11467, 11471, 11483, 11489, 11491, 11497,
+        11503, 11519, 11527, 11549, 11551, 11579, 11587, 11593, 11597, 11617, 11621, 11633, 11657,
+        11677, 11681, 11689, 11699, 11701, 11717, 11719, 11731, 11743, 11777, 11779, 11783, 11789,
+        11801, 11807, 11813, 11821, 11827, 11831, 11833, 11839, 11863, 11867, 11887, 11897, 11903,
+        11909, 11923, 11927, 11933, 11939, 11941, 11953, 11959, 11969, 11971, 11981, 11987, 12007,
+        12011, 12037, 12041, 12043, 12049, 12071, 12073, 12097, 12101, 12107, 12109, 12113, 12119,
+        12143, 12149, 12157, 12161, 12163, 12197, 12203, 12211, 12227, 12239, 12241, 12251, 12253,
+        12263, 12269, 12277, 12281, 12289, 12301, 12323, 12329, 12343, 12347, 12373, 12377, 12379,
+        12391, 12401, 12409, 12413, 12421, 12433, 12437, 12451, 12457, 12473, 12479, 12487, 12491,
+        12497, 12503, 12511, 12517, 12527, 12539, 12541, 12547, 12553, 12569, 12577, 12583, 12589,
+        12601, 12611, 12613, 12619, 12637, 12641, 12647, 12653, 12659, 12671, 12689, 12697, 12703,
+        12713, 12721, 12739, 12743, 12757, 12763, 12781, 12791, 12799, 12809, 12821, 12823, 12829,
+        12841, 12853, 12889, 12893, 12899, 12907, 12911, 12917, 12919, 12923, 12941, 12953, 12959,
+        12967, 12973, 12979, 12983, 13001, 13003, 13007, 13009, 13033, 13037, 13043, 13049, 13063,
+        13093, 13099, 13103, 13109, 13121, 13127, 13147, 13151, 13159, 13163, 13171, 13177, 13183,
+        13187, 13217, 13219, 13229, 13241, 13249, 13259, 13267, 13291, 13297, 13309, 13313, 13327,
+        13331, 13337, 13339, 13367, 13381, 13397, 13399, 13411, 13417, 13421, 13441, 13451, 13457,
+        13463, 13469, 13477, 13487, 13499, 13513, 13523, 13537, 13553, 13567, 13577, 13591, 13597,
+        13613, 13619, 13627, 13633, 13649, 13669, 13679, 13681, 13687, 13691, 13693, 13697, 13709,
+        13711, 13721, 13723, 13729, 13751, 13757, 13759, 13763, 13781, 13789, 13799, 13807, 13829,
+        13831, 13841, 13859, 13873, 13877, 13879, 13883, 13901, 13903, 13907, 13913, 13921, 13931,
+        13933, 13963, 13967, 13997, 13999, 14009, 14011, 14029, 14033, 14051, 14057, 14071, 14081,
+        14083, 14087, 14107, 14143, 14149, 14153, 14159, 14173, 14177, 14197, 14207, 14221, 14243,
+        14249, 14251, 14281, 14293, 14303, 14321, 14323, 14327, 14341, 14347, 14369, 14387, 14389,
+        14401, 14407, 14411, 14419, 14423, 14431, 14437, 14447, 14449, 14461, 14479, 14489, 14503,
+        14519, 14533, 14537, 14543, 14549, 14551, 14557, 14561, 14563, 14591, 14593, 14621, 14627,
+        14629, 14633, 14639, 14653, 14657, 14669, 14683, 14699, 14713, 14717, 14723, 14731, 14737,
+        14741, 14747, 14753, 14759, 14767, 14771, 14779, 14783, 14797, 14813, 14821, 14827, 14831,
+        14843, 14851, 14867, 14869, 14879, 14887, 14891, 14897, 14923, 14929, 14939, 14947, 14951,
+        14957, 14969, 14983, 15013, 15017, 15031, 15053, 15061, 15073, 15077, 15083, 15091, 15101,
+        15107, 15121, 15131, 15137, 15139, 15149, 15161, 15173, 15187, 15193, 15199, 15217, 15227,
+        15233, 15241, 15259, 15263, 15269, 15271, 15277, 15287, 15289, 15299, 15307, 15313, 15319,
+        15329, 15331, 15349, 15359, 15361, 15373, 15377, 15383, 15391, 15401, 15413, 15427, 15439,
+        15443, 15451, 15461, 15467, 15473, 15493, 15497, 15511, 15527, 15541, 15551, 15559, 15569,
+        15581, 15583, 15601, 15607, 15619, 15629, 15641, 15643, 15647, 15649, 15661, 15667, 15671,
+        15679, 15683, 15727, 15731, 15733, 15737, 15739, 15749, 15761, 15767, 15773, 15787, 15791,
+        15797, 15803, 15809, 15817, 15823, 15859, 15877, 15881, 15887, 15889, 15901, 15907, 15913,
+        15919, 15923, 15937, 15959, 15971, 15973, 15991, 16001, 16007, 16033, 16057, 16061, 16063,
+        16067, 16069, 16073, 16087, 16091, 16097, 16103, 16111, 16127, 16139, 16141, 16183, 16187,
+        16189, 16193, 16217, 16223, 16229, 16231, 16249, 16253, 16267, 16273, 16301, 16319, 16333,
+        16339, 16349, 16361, 16363, 16369, 16381, 16411, 16417, 16421, 16427, 16433, 16447, 16451,
+        16453, 16477, 16481, 16487, 16493, 16519, 16529, 16547, 16553, 16561, 16567, 16573, 16603,
+        16607, 16619, 16631, 16633, 16649, 16651, 16657, 16661, 16673, 16691, 16693, 16699, 16703,
+        16729, 16741, 16747, 16759, 16763, 16787, 16811, 16823, 16829, 16831, 16843, 16871, 16879,
+        16883, 16889, 16901, 16903, 16921, 16927, 16931, 16937, 16943, 16963, 16979, 16981, 16987,
+        16993, 17011, 17021, 17027, 17029, 17033, 17041, 17047, 17053, 17077, 17093, 17099, 17107,
+        17117, 17123, 17137, 17159, 17167, 17183, 17189, 17191, 17203, 17207, 17209, 17231, 17239,
+        17257, 17291, 17293, 17299, 17317, 17321, 17327, 17333, 17341, 17351, 17359, 17377, 17383,
+        17387, 17389, 17393, 17401, 17417, 17419, 17431, 17443, 17449, 17467, 17471, 17477, 17483,
+        17489, 17491, 17497, 17509, 17519, 17539, 17551, 17569, 17573, 17579, 17581, 17597, 17599,
+        17609, 17623, 17627, 17657, 17659, 17669, 17681, 17683, 17707, 17713, 17729, 17737, 17747,
+        17749, 17761, 17783, 17789, 17791, 17807, 17827, 17837, 17839, 17851, 17863,
+    ];
+    const MAX_SMALL_PRIME: u32 = PRIMES[PRIMES.len() - 1];
+}
+
 #[cfg(test)]
 mod test {
     use super::Integer;

From f7bfe18db4c42e62be01b0d04f3989c3350f6de0 Mon Sep 17 00:00:00 2001
From: Denis Varlakov <cordial.egg6523@fastmail.com>
Date: Thu, 15 Oct 2026 14:51:05 +0200
Subject: [PATCH 2/7] Update changelog

Signed-off-by: Denis Varlakov <cordial.egg6523@fastmail.com>
---
 CHANGELOG.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 42ad34c..c8a96cf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,8 +1,10 @@
 ## v0.3.3
 * Unify encoding of integer=0 across backends [#45]
 * Deserialize returns an error on invalid radix, instead of panicking [#45]
+* Fix primality test on num-bigint backend [#46]
 
 [#45]: https://github.com/LFDT-Lockness/fast-paillier/pull/45
+[#46]: https://github.com/LFDT-Lockness/fast-paillier/pull/46
 
 ## v0.3.2
 * Make `random_below`, `random_below_ref`, `random_bits`, `random_bits_signed`,

From b0db700a2fbfd59b1a29ee8474dece710c8c67cd Mon Sep 17 00:00:00 2001
From: Denis Varlakov <cordial.egg6523@fastmail.com>
Date: Thu, 15 Oct 2026 16:12:28 +0200
Subject: [PATCH 3/7] Use `is_prime_baillie_psw` (aka check_strong) instead

Signed-off-by: Denis Varlakov <cordial.egg6523@fastmail.com>
---
 Cargo.lock                |  76 +++++++++++++++++++++++--
 Cargo.toml                |  12 +++-
 src/backend/num_bigint.rs | 114 +++++++++++++++++++++-----------------
 3 files changed, 147 insertions(+), 55 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 519e1df..1195f9d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -35,6 +35,12 @@ version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7b7e4c2464d97fe331d41de9d5db0def0a96f4d823b8b32a2efd503578988973"
 
+[[package]]
+name = "base16ct"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd307490d624467aa6f74b0eabb77633d1f758a7b25f12bceb0b22e08d9726f6"
+
 [[package]]
 name = "block-buffer"
 version = "0.10.4"
@@ -134,6 +140,18 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 
+[[package]]
+name = "cmov"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c9ea0ac24bc397ab3c98583a3c9ba74fa56b09a4449bbe172b9b1ddb016027a"
+
+[[package]]
+name = "cpubits"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15b85f9c39137c3a891689859392b1bd49812121d0d61c9caf00d46ed5ce06ae"
+
 [[package]]
 name = "criterion"
 version = "0.5.1"
@@ -201,6 +219,19 @@ version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
 
+[[package]]
+name = "crypto-bigint"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a52aa3fcda4e6302a9f48734f234d35d4721b96f8fe07d073f07ce9df4f0271"
+dependencies = [
+ "cpubits",
+ "ctutils",
+ "num-traits",
+ "rand_core 0.10.1",
+ "serdect",
+]
+
 [[package]]
 name = "crypto-common"
 version = "0.1.6"
@@ -211,6 +242,25 @@ dependencies = [
  "typenum",
 ]
 
+[[package]]
+name = "crypto-primes"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3633a51a39c69ebbaa4feaa694bd83d241e4093901c84a0963b19d9bb3f0cf8f"
+dependencies = [
+ "crypto-bigint",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "ctutils"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03bb0e1cc970d482d121d9a1744999169b69a07470b3d644a7894e53fcaf4574"
+dependencies = [
+ "cmov",
+]
+
 [[package]]
 name = "digest"
 version = "0.9.0"
@@ -243,13 +293,15 @@ dependencies = [
  "bytemuck",
  "ciborium",
  "criterion",
+ "crypto-bigint",
+ "crypto-primes",
  "libpaillier",
  "num-bigint",
  "num-integer",
  "num-traits",
  "quickcheck",
  "rand",
- "rand_core",
+ "rand_core 0.6.4",
  "rand_dev",
  "rug",
  "serde",
@@ -497,7 +549,7 @@ checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
  "libc",
  "rand_chacha",
- "rand_core",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
@@ -507,7 +559,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
  "ppv-lite86",
- "rand_core",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
@@ -519,6 +571,12 @@ dependencies = [
  "getrandom",
 ]
 
+[[package]]
+name = "rand_core"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
+
 [[package]]
 name = "rand_dev"
 version = "0.1.1"
@@ -527,7 +585,7 @@ checksum = "cbee97c27dada05f03db49ffe6516872f6c926e0fd525f9ce0cb3c051adf145c"
 dependencies = [
  "hex",
  "rand_chacha",
- "rand_core",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
@@ -667,6 +725,16 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "serdect"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66cf8fedced2fcf12406bcb34223dffb92eaf34908ede12fed414c82b7f00b3e"
+dependencies = [
+ "base16ct",
+ "serde",
+]
+
 [[package]]
 name = "subtle"
 version = "2.6.1"
diff --git a/Cargo.toml b/Cargo.toml
index 78caa0b..50823f7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,6 +18,8 @@ bytemuck = { version = "1.5", features = ["derive"], optional = true }
 num-bigint = { version = "0.4.6", optional = true, default-features = false, features = ["rand"] }
 num-traits = { version = "0.2.19", optional = true, default-features = false }
 num-integer = { version = "0.1.46", optional = true, default-features = false }
+crypto-bigint = { version = "0.7", default-features = false, features = ["alloc"], optional = true }
+crypto-primes = { version = "0.7", default-features = false, optional = true }
 rand = { version = "0.8", optional = true, default-features = false }
 
 rand_core = "0.6"
@@ -51,7 +53,10 @@ serde = ["dep:serde"]
 quickcheck = ["dep:quickcheck"]
 
 backend-rug = ["dep:rug", "dep:bytemuck"]
-backend-num-bigint = ["dep:num-bigint", "dep:num-traits", "dep:num-integer", "dep:rand"]
+backend-num-bigint = [
+  "dep:num-bigint", "dep:num-traits", "dep:num-integer", "dep:rand", "dep:crypto-bigint",
+  "dep:crypto-primes",
+]
 
 [[bench]]
 name = "comparison"
@@ -62,3 +67,8 @@ harness = false
 num-bigint.opt-level = 3
 num-traits.opt-level = 3
 num-integer.opt-level = 3
+
+# See https://docs.rs/cpubits/0.1.1/cpubits/#lint-configuration-for-cfgcpubits
+[lints.rust.unexpected_cfgs]
+level = "warn"
+check-cfg = ['cfg(cpubits, values("16", "32", "64"))']
diff --git a/src/backend/num_bigint.rs b/src/backend/num_bigint.rs
index ed22ed0..157bbae 100644
--- a/src/backend/num_bigint.rs
+++ b/src/backend/num_bigint.rs
@@ -294,10 +294,10 @@ impl Integer {
     }
 
     // TODO reps is unused here, need to unify with rug
-    pub fn is_probably_prime(&self, _reps: u32, rng: &mut impl rand_core::RngCore) -> IsPrime {
+    pub fn is_probably_prime(&self, _reps: u32, _rng: &mut impl rand_core::RngCore) -> IsPrime {
         if self.cmp0().is_le() {
             IsPrime::No
-        } else if glass_pumpkin::is_prime(self.0.magnitude(), rng) {
+        } else if glass_pumpkin::is_prime_baillie_psw(self.0.magnitude()) {
             IsPrime::Yes
         } else {
             IsPrime::No
@@ -310,7 +310,7 @@ impl Integer {
             x.assign_random_bits(bit_size, rng);
             x.set_bit(bit_size - 1, true);
             x |= 1u32;
-            if glass_pumpkin::is_prime(x.0.magnitude(), rng) {
+            if glass_pumpkin::is_prime_baillie_psw(x.0.magnitude()) {
                 break x;
             }
         }
@@ -425,7 +425,7 @@ impl quickcheck::Arbitrary for Integer {
 }
 
 /// This module was taken from <https://docs.rs/glass_pumpkin/2.0.0/src/glass_pumpkin/common.rs.html>
-/// preserving only function that performs primarity test. The code was modified to work with
+/// preserving only function that performs primality test. The code was modified to work with
 /// older version of the `rand_core` crate.
 ///
 /// We cannot use the latest version of the library as it requires introducing breaking changes
@@ -434,39 +434,28 @@ impl quickcheck::Arbitrary for Integer {
 ///
 /// We can migrate back to that dependency when we update our ecosystem to latest `rand_core`.
 mod glass_pumpkin {
-    use num_bigint::{BigUint, RandBigInt as _};
+    use crypto_bigint::{nlimbs, BoxedUint, Odd, Uint};
+    use crypto_primes::hazmat::{lucas_test, LucasCheck, SelfridgeBase};
+    use num_bigint::BigUint;
     use num_integer::Integer as _;
     use num_traits::{One as _, ToPrimitive as _};
-    use rand_core::RngCore;
 
-    /// Test if number is prime by
+    /// Checks if a number is probably prime using the deterministic-base
+    /// Baillie-PSW test.
     ///
-    /// 1- Trial division by first 2048 primes
-    /// 2- Perform log2(bitlength) + 5 rounds of Miller-Rabin
-    ///    depending on the number of bits
-    pub fn is_prime<R: RngCore + ?Sized>(candidate: &BigUint, rng: &mut R) -> bool {
-        is_prime_with_rng(
-            candidate,
-            required_checks(candidate.bits() as usize),
-            false,
-            rng,
-        )
-    }
-
-    fn is_prime_with_rng<R: RngCore + ?Sized>(
-        candidate: &BigUint,
-        checks: usize,
-        q_check: bool,
-        rng: &mut R,
-    ) -> bool {
-        if candidate.to_u64() == Some(2) {
+    /// The RNG parameter is retained for API compatibility and is not consumed.
+    pub fn is_prime_baillie_psw(candidate: &BigUint) -> bool {
+        baillie_psw(candidate, false)
+    }
+
+    /// Run the conventional Baillie-PSW probable-prime test.
+    fn baillie_psw(candidate: &BigUint, q_check: bool) -> bool {
+        if candidate == &BigUint::from(2_u8) {
             return true;
         }
-
-        if candidate.is_even() || candidate.is_one() {
+        if candidate < &BigUint::from(2_u8) || candidate.is_even() {
             return false;
         }
-
         if !passes_small_prime_sieve(candidate, q_check) {
             return false;
         }
@@ -477,19 +466,13 @@ mod glass_pumpkin {
             return true;
         }
 
-        // Finally, do a Miller-Rabin test
-        // See https://eprint.iacr.org/2018/749.pdf for good choices on appropriate number of tests
-        if !MillerRabin::new(candidate).random_checks(checks, rng) {
-            return false;
-        }
-
-        true
+        baillie_psw_presieved(candidate)
     }
 
-    /// Minimum checks to be considered okay
-    #[inline]
-    fn required_checks(bits: usize) -> usize {
-        (bits.checked_ilog2().unwrap_or(1) as usize) + 5
+    /// Run the two conventional BPSW components after small-factor screening:
+    /// a strong base-2 Miller-Rabin test and a strong Lucas-Selfridge test.
+    fn baillie_psw_presieved(candidate: &BigUint) -> bool {
+        MillerRabin::new(candidate).passes_bpsw()
     }
 
     /// Candidate-specific values shared by every Miller-Rabin base.
@@ -533,18 +516,49 @@ mod glass_pumpkin {
             false
         }
 
-        fn random_checks<R: RngCore + ?Sized>(&self, limit: usize, rng: &mut R) -> bool {
-            // Sampling [0, n-3) and adding two produces exactly [2, n-1),
-            // without rebuilding that span for every base.
-            let basis_span = self.candidate - 3_u8;
-            for _ in 0..limit {
-                let basis = rng.gen_biguint_below(&basis_span) + 2_u8;
-                if !self.check_base(&basis) {
-                    return false;
-                }
+        fn passes_bpsw(&self) -> bool {
+            self.check_base_two() && strong_lucas_selfridge(self.candidate)
+        }
+
+        fn check_base_two(&self) -> bool {
+            self.check_base(&BigUint::from(2_u8))
+        }
+    }
+
+    /// Strong Lucas probable-prime test with Selfridge's method-A parameters.
+    ///
+    /// This is the Lucas half of the conventional Baillie-PSW test. It chooses
+    /// `D = 5, -7, 9, -11, ...`, `P = 1`, and `Q = (1-D)/4`, then checks the
+    /// strong Lucas conditions for the odd part of `n + 1`.
+    fn strong_lucas_selfridge(n: &BigUint) -> bool {
+        if !cfg!(debug_assertions) {
+            match n.bits().div_ceil(8) {
+                128 => return strong_lucas_fixed::<{ nlimbs(1024) }>(n),
+                256 => return strong_lucas_fixed::<{ nlimbs(2048) }>(n),
+                512 => return strong_lucas_fixed::<{ nlimbs(4096) }>(n),
+                _ => {}
             }
+        }
+
+        Odd::new(boxed_uint(n))
+            .into_option()
+            .is_some_and(|candidate| {
+                lucas_test(candidate, SelfridgeBase, LucasCheck::Strong).is_probably_prime()
+            })
+    }
+
+    fn strong_lucas_fixed<const LIMBS: usize>(n: &BigUint) -> bool {
+        Odd::new(Uint::<LIMBS>::from_be_slice(&n.to_bytes_be()))
+            .into_option()
+            .is_some_and(|candidate| {
+                lucas_test(candidate, SelfridgeBase, LucasCheck::Strong).is_probably_prime()
+            })
+    }
 
-            true
+    fn boxed_uint(n: &BigUint) -> BoxedUint {
+        crypto_bigint::cpubits! {
+            16 | 32 => { BoxedUint::from_words(n.iter_u32_digits()) }
+            64 => { BoxedUint::from_words(n.iter_u64_digits()) }
         }
     }
 

From 219cdc5f0bfbc585436b40cdc4f50aaec6cb637f Mon Sep 17 00:00:00 2001
From: Denis Varlakov <cordial.egg6523@fastmail.com>
Date: Thu, 15 Oct 2026 16:42:02 +0200
Subject: [PATCH 4/7] Fixing issues found by quickcheck

Signed-off-by: Denis Varlakov <cordial.egg6523@fastmail.com>
---
 src/backend/num_bigint.rs    |    7 +-
 tests/integration/backend.rs |   39 +-
 wtf                          | 5804 ++++++++++++++++++++++++++++++++++
 3 files changed, 5828 insertions(+), 22 deletions(-)
 create mode 100644 wtf

diff --git a/src/backend/num_bigint.rs b/src/backend/num_bigint.rs
index 157bbae..1bb8231 100644
--- a/src/backend/num_bigint.rs
+++ b/src/backend/num_bigint.rs
@@ -215,6 +215,11 @@ impl Integer {
         self.invert_ref(modulo)
     }
     pub fn invert_ref(&self, modulo: &Self) -> Option<Self> {
+        // Nbi returns wrong result if modulo = 1, and self is negative. Correct response is `0`,
+        // but nbi gives `1`.
+        if self.cmp0().is_lt() && modulo.is_one() {
+            return Some(Self::zero());
+        }
         let r = self.0.modinv(&modulo.0).map(Integer)?;
         // Rug always produces a positive result here. Num-bigint always
         // produces a result between zero and modulo. When modulo is negative,
@@ -298,7 +303,7 @@ impl Integer {
         if self.cmp0().is_le() {
             IsPrime::No
         } else if glass_pumpkin::is_prime_baillie_psw(self.0.magnitude()) {
-            IsPrime::Yes
+            IsPrime::Probably
         } else {
             IsPrime::No
         }
diff --git a/tests/integration/backend.rs b/tests/integration/backend.rs
index 6a9cf80..24a5b97 100644
--- a/tests/integration/backend.rs
+++ b/tests/integration/backend.rs
@@ -20,12 +20,15 @@ macro_rules! make_quickcheck {
                 #[allow(unused_mut)]
                 let mut rug = RugInteger::from_bytes_msf_signed(&bytes, sign);
 
+
                 let r1 = {
                     // Since Arg::to_nbi takes mutable reference to the arg, we clone them,
                     // so the `rug` method below receives the same args as provided by
                     // quickcheck without any modification
+                    eprintln!("int: {nbi:?}");
                     $(
                         let mut $arg = $arg.clone();
+                        eprintln!("arg: {:?}", $arg);
                     )*
                     nbi.$method(
                         $(
@@ -125,7 +128,6 @@ make_quickcheck!(Self::random_bits(bits: SmallU32, rng: Prng));
 make_quickcheck!(Self::random_bits_signed(bits: SmallU32, rng: Prng));
 make_quickcheck!(assign_random_below(self: NbiInteger, modulo: Positive<RefInteger>, rng: Prng));
 make_quickcheck!(assign_random_bits(self: NbiInteger, bits: SmallU32, rng: Prng));
-make_quickcheck!(is_probably_prime(self: NbiInteger, const25: Const<25>, rng: Prng));
 make_quickcheck!(jacobi(self: NbiInteger, n: OddPositive));
 make_quickcheck!(
     combine(
@@ -163,6 +165,21 @@ quickcheck::quickcheck! {
         let r2 = serde_json::to_string(&rug).unwrap();
         r1 == r2
     }
+
+    fn is_probably_prime(nbi: NbiInteger, rng: Prng) -> bool {
+        use fast_paillier::backend::IsPrime;
+
+        let mut rng = rng;
+        let (bytes, sign) = nbi.to_bytes_msf_signed();
+        let rug = RugInteger::from_bytes_msf_signed(&bytes, sign);
+
+        let r1 = nbi.is_probably_prime(25, &mut rng.rng);
+        let r2 = rug.is_probably_prime(25, &mut rng.rng);
+
+        // It doesn't matter if one backend returns `Yes`, and the other returns `Probably`.
+        // It matters to check if one returns `Yes|Probably`, and the other returns `No`
+        matches!((r1, r2), (IsPrime::Yes | IsPrime::Probably, IsPrime::Yes | IsPrime::Probably) | (IsPrime::No, IsPrime::No))
+    }
 }
 
 ///// Helper traits for macro /////
@@ -343,26 +360,6 @@ impl quickcheck::Arbitrary for SmallU32 {
     }
 }
 
-/// Helper quickcheck newtype: generates a constant u32. Convenient for the
-/// macros above, since they don't accept constant values
-#[derive(Clone, Debug)]
-struct Const<const N: u32>;
-impl<const N: u32> Arg<'_> for Const<N> {
-    type NbiArg = u32;
-    type RugArg = u32;
-    fn to_nbi(&mut self) -> Self::NbiArg {
-        N
-    }
-    fn to_rug(&mut self) -> Self::RugArg {
-        N
-    }
-}
-impl<const N: u32> quickcheck::Arbitrary for Const<N> {
-    fn arbitrary(_: &mut quickcheck::Gen) -> Self {
-        Const
-    }
-}
-
 /// Helper quickcheck newtype: generates a non-zero integral value
 #[derive(Clone, Debug)]
 struct NonZero<T>(T);
diff --git a/wtf b/wtf
new file mode 100644
index 0000000..fc83cad
--- /dev/null
+++ b/wtf
@@ -0,0 +1,5804 @@
+    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.02s
+     Running tests/integration/main.rs (target/debug/deps/integration-c561df37baeccefc)
+int: Integer(3159069600019554194022657100715805333242276989416388470653064737629674007777869470792440373876027175134226671041423790281306823148413784356151067460389343712245685356745591710491123)
+arg: Positive(Integer(206081497958678073734815386575575894310383909958715941603467233632150792249101063257532561260528649453960182261739345586155393754341139162240158086606795555731000617981788811718182766856748787203544429733690))
+Some(Integer(93423507563504960316312295000134630188420469667006050911235435093325344616288319452319732751876381485317042107056208056905718863983417986493382792222504508897601941459690883934762582963752356808340771660927)) != Some(Integer(93423507563504960316312295000134630188420469667006050911235435093325344616288319452319732751876381485317042107056208056905718863983417986493382792222504508897601941459690883934762582963752356808340771660927))
+int: Integer(10221746329734546230375257378613832009634233133827215326514562301849953766765895526382284162531535643462121345853344869955959235569398951674216051680484863957087639343087086158941681488393119036189161527421393086399920712651891443)
+arg: Positive(Integer(3399413517900442150942910184795291920732192829452316031624077661009835529710753268449382498245359398))
+Some(Integer(2120960707543514393151060137493651294564627763082492955137191133491796069584493621525678091646893019)) != Some(Integer(2120960707543514393151060137493651294564627763082492955137191133491796069584493621525678091646893019))
+int: Integer(5460397076671608011562212465762501128800092082962227678070857038481917371705723886929866888220889559221723257185751988801873542355248125841254348593761285125331014851185480967555193609744933978496129446)
+arg: Positive(Integer(138906882941471930519049748903594527326338637153097351039980513842293741995211464345523385963660277788876762164281896652926648169663798045857760697600055130493076596997586782136225026))
+None != None
+int: Integer(-33184543787759964141547192377931243097362104517357286649559382613900547816003212155135597275614492205666248473715533007533464107221524615798759049223496669817112)
+arg: Positive(Integer(14080037710595326216833738711196290441991021928920959849913370318739129565261759028555883936778127159558791161157100355018188314146967994667399610757426651955268462728915356007897847780606183))
+Some(Integer(4483997182335513636935299446440704861864627515741900927991939254119061688110748029565584482931649288917284424610634481411751927901750227391213230719510961518391381712444738457002159909774529)) != Some(Integer(4483997182335513636935299446440704861864627515741900927991939254119061688110748029565584482931649288917284424610634481411751927901750227391213230719510961518391381712444738457002159909774529))
+int: Integer(-41845305487048242527472428629543477420453859494995448407044001186156951172997678259170503536502483185201203701298336797244242933170814843531606310796794787582600063961700396827079869104048750305648406228742914208)
+arg: Positive(Integer(13800726014106030846965541426567511455133520865804520836975278792796123037292843772154272654688098743059182840166368300121129499820678666168187870584632121016474384822789069313))
+Some(Integer(12806495751683088886823359772221011999738517286490327309448804196458105010653964344548538555476649074669712142836867896442315161995972142753628165986836792775047042926540196765)) != Some(Integer(12806495751683088886823359772221011999738517286490327309448804196458105010653964344548538555476649074669712142836867896442315161995972142753628165986836792775047042926540196765))
+int: Integer(27271795799987201592887497301064882545106761343013158304999353025767535193474775)
+arg: Positive(Integer(463835802035234651236131736115665619359125963631503708316689035169587009387237968656176023842331282576053638146183015777772705961733373089789208751))
+None != None
+int: Integer(26906551112530404168575405641154124020054492547790053336413104209664)
+arg: Positive(Integer(542328860758127283680220841093200146620184807709594962569542194957830637463903798449520956424744804411530804278961481419943892221034677))
+Some(Integer(149677360758815156746182881403671076543546978646938783435696288708484548968328354650018374112139320667287751760796135183929254416164720)) != Some(Integer(149677360758815156746182881403671076543546978646938783435696288708484548968328354650018374112139320667287751760796135183929254416164720))
+int: Integer(34461165762466966326023278807801936726653841324784171063672902892888033859385086058340903647831870670808160912180501847996923605648455071406721897581853148552001)
+arg: Positive(Integer(128175429627505419221965019167495042393906168511422518105630076507626443295176531538404495498448672768839633829314913155508295205968057679077859991665622168414882))
+Some(Integer(36646266214596208185896324170969704647743748141612282699604292038249478142419290064629075531242468086264038041369833580616690308260722374224167203357424094639343)) != Some(Integer(36646266214596208185896324170969704647743748141612282699604292038249478142419290064629075531242468086264038041369833580616690308260722374224167203357424094639343))
+int: Integer(38700440973167803)
+arg: Positive(Integer(39572705467840112616964131164982426787582095074740603291948682354251866662578651934504137625257163649785093206879371959296715342494534474381187779326436757193514920461153759121))
+Some(Integer(5158318408371568203666235294380078053244212483065513813821264766353963640277893032149503247852203055868376228902623458558814066610709377560034359865435065332747120685999670766)) != Some(Integer(5158318408371568203666235294380078053244212483065513813821264766353963640277893032149503247852203055868376228902623458558814066610709377560034359865435065332747120685999670766))
+int: Integer(2950474297419306914934138189265726706823126913588455670372115625284525590770210273595491841427122193956277114711346270647011539904119296679)
+arg: Positive(Integer(21054894604691820250450794060858377225079617737973140776051244353348206315344661866347367439812411056667462172199428909981680989))
+None != None
+int: Integer(-66062269358461534899196825950973840834406150134114534429885110164711268363578015390945837577926321197204037193874013827635381)
+arg: Positive(Integer(576363513558967636058445759018579240601956155043470077708679554402739322373039314034082324934340216204383851284564368791091547783157296337099968239719188273986804133715993))
+Some(Integer(512607522209711735796967562740788469290605515335467144627471572395800868952493213308377863414894060025500418437276867778399431733007048565967921493048931106323327811178549)) != Some(Integer(512607522209711735796967562740788469290605515335467144627471572395800868952493213308377863414894060025500418437276867778399431733007048565967921493048931106323327811178549))
+int: Integer(-3602243072329606578919234752580778505164609341939343118657261779748800819803815966507018215033)
+arg: Positive(Integer(7703565))
+Some(Integer(1194763)) != Some(Integer(1194763))
+int: Integer(20497377663362627077957629168109826564817633471860361171)
+arg: Positive(Integer(1348664239803045160159622297797768341010581045705862225048410039495691005902994068768893826973485733708949269981693243656405003815633633745198668))
+Some(Integer(572685861681683429289116496648527905261890256253462639647542470960671187797156440944717345147905323478122076278968933395382935024513711178175327)) != Some(Integer(572685861681683429289116496648527905261890256253462639647542470960671187797156440944717345147905323478122076278968933395382935024513711178175327))
+int: Integer(5571382794149580783830577677990556798799078278490130423896390438397454601859485496634273570058264274576707018936906083)
+arg: Positive(Integer(38713016916520294180234606312236980692477604782631299500710970459397481151856895737232673349289190074316095488341))
+None != None
+int: Integer(1082137576163352027699917090319317812538581120566911456250491874000727427885388226391345340853661689936443221015955098275541565344507594557318559109977559530740079820138250863511757941721826171)
+arg: Positive(Integer(35042717255746189560596465682981754546848242444708157058341663351007999830443320156321524945781244368240998643398435491351545969648808702330026330148521030158074869830654654867984450702582413033388))
+None != None
+int: Integer(-2082239090)
+arg: Positive(Integer(118765853491520759494558410130255931822701572091525322631962846587714544159277657209730617389373412650569387657307))
+Some(Integer(38631317333663705118702918201790723894783666589614438612410788214522336885526048878532604995832193773883290434311)) != Some(Integer(38631317333663705118702918201790723894783666589614438612410788214522336885526048878532604995832193773883290434311))
+int: Integer(-10067551596193683895864369517226664416318542590571562320632756698129094765090018166793705515923565420663650915958935581547267311586158127277)
+arg: Positive(Integer(1240168922535564757068481482172291574164105353319268669118692))
+Some(Integer(80914326105274387982619031804221556660076417520523852069607)) != Some(Integer(80914326105274387982619031804221556660076417520523852069607))
+int: Integer(-31670424761379338213086506692723231222948612498481315)
+arg: Positive(Integer(7106274445397153718867332249000004966289930132732251298851526039412597955636503944960286246690231662161892227592069580067461149146699169933405240295745133))
+Some(Integer(884955677979684858483628002872376991810485396462567682123951573868544816927327457843814851190611855462094586698955643910405487099212717415723885393200400)) != Some(Integer(884955677979684858483628002872376991810485396462567682123951573868544816927327457843814851190611855462094586698955643910405487099212717415723885393200400))
+int: Integer(6419235254774732345513740641731385124747023185859798403)
+arg: Positive(Integer(240742183242732361771931716531123208533609222117700613978157932778351331359))
+Some(Integer(38492961043130419821654155711607236467235762433736084548087702012431108219)) != Some(Integer(38492961043130419821654155711607236467235762433736084548087702012431108219))
+int: Integer(-246713932740788889936563735368734547735090064071916849285375244228931543868823719769319041789962713100196872457386160065958412025678445409517135063952756612965101922823382906120302825088650902895959014941167103)
+arg: Positive(Integer(277072196625728))
+Some(Integer(167125734289793)) != Some(Integer(167125734289793))
+int: Integer(948814452951848394277342618377664301334919765662075976492810878349995858957574923018553356173917365493287376746172963544864956946934800632272806380017683818200761532821575402724960065169496653081276363381608)
+arg: Positive(Integer(2034))
+None != None
+int: Integer(-16168394608437904117924073514094334223923957745626389324510034981338574924390093922429888666096736520299904214617404279855363564291263726958526232631227920224261605033619225398896)
+arg: Positive(Integer(3347340325276334559007644929593987306810470207751023195205558136572230))
+None != None
+int: Integer(849907565503714923979626663871490381584604791891727078579767137516077892225265989385255812708041173297743955464647847526964313485068753470826315532975015377017)
+arg: Positive(Integer(1195132094896773060594118429808457016217587796178858275226162781873326431234945011873031693910223025548739874356322552633317587550777023148531813))
+Some(Integer(598616922528068633999600187547208226765804537707494243674237091778872609437533047640256271433421137669291897375062618960986623105625432954691494)) != Some(Integer(598616922528068633999600187547208226765804537707494243674237091778872609437533047640256271433421137669291897375062618960986623105625432954691494))
+int: Integer(-186)
+arg: Positive(Integer(114726413728427911834441))
+Some(Integer(11719364843226507122873)) != Some(Integer(11719364843226507122873))
+int: Integer(-390390869688902702176657554058378944771722268032838764912084454210764721773919081458107923955155872364890588875683107108986962625842749392523820320208058903628956392008842305371818737540071744058445861535165033618960912519274817316)
+arg: Positive(Integer(15360328573537092650100332669426833233476950167815017621629298825086574246424600263526429297164507674138350648746786765029824367046093091572868661780552717258097820595563355566099840606245456))
+None != None
+int: Integer(10174341165738932342387363679570036508429775439071809223720863944576451056115222819803682748930829171854836284937773021100778556581)
+arg: Positive(Integer(129265709558294514425459647752255033389575722259725960158493617674079370289440024301002259375307235080241292240696))
+Some(Integer(8105462231193088830528263192161098914557990480593133710371816456217023963978498348463399777596241315073174770085)) != Some(Integer(8105462231193088830528263192161098914557990480593133710371816456217023963978498348463399777596241315073174770085))
+int: Integer(30398756336183572)
+arg: Positive(Integer(14535850803766979963696456633744742114414306488304396488712824365943173247427))
+Some(Integer(12121822423061820432740745065509456963494140032265739437232031636006592329018)) != Some(Integer(12121822423061820432740745065509456963494140032265739437232031636006592329018))
+int: Integer(2770268300122623958844669338478999746346835753606256532123541008993738881457634415494505448057684904025654203938061768302465874148555461079412810828850685)
+arg: Positive(Integer(10209907653059288723416799384211166491985792911056197015112741562597792589550631414997547921592840885266765929485322683156970218509979226096624885586811125511273182122604016100223880762555871147117731))
+Some(Integer(6573723871986790912042561761495906841510882400663590740185024165477230209658294212479997266344462153346303874794575714904699211461370996589103752513352560629433357162272316483819202396507851868468791)) != Some(Integer(6573723871986790912042561761495906841510882400663590740185024165477230209658294212479997266344462153346303874794575714904699211461370996589103752513352560629433357162272316483819202396507851868468791))
+int: Integer(-3341767896999213630105660438464793802363970368051299565778950301018993769411244946681815888937629457091863564195134610152260238650692583912807593387655231590)
+arg: Positive(Integer(41764792852333410613574057691314017919685))
+None != None
+int: Integer(-1114980562394482451793290722800104352459394864827146975363501905158787262104367173173702236328705014823989842999081060311047379538147863315260457274737999450395426560898811821358366403242984514054174654893926783048028289)
+arg: Positive(Integer(92454014208295604012257077639200854384470285576963206368091818051099095359131728963007429))
+Some(Integer(60764927440221551848018324605630580928185191576353686313120306568607082814675681902323724)) != Some(Integer(60764927440221551848018324605630580928185191576353686313120306568607082814675681902323724))
+int: Integer(-4796)
+arg: Positive(Integer(501865570767534837787609078394589614759996744443))
+Some(Integer(169416255019315867885350103820025143097671961896)) != Some(Integer(169416255019315867885350103820025143097671961896))
+int: Integer(-5870818593143744454376804707063447104071516078576702456474309983843020981483384611)
+arg: Positive(Integer(87721041152673869540287225086369263172326266784032316094739615440526157576615855054770658))
+Some(Integer(44637766433422062746469262499585559067595108316018581528779660922477864420411882289835139)) != Some(Integer(44637766433422062746469262499585559067595108316018581528779660922477864420411882289835139))
+int: Integer(-8645950250668392342139710370195996604997133356279154995790606110025001403913568349429804391285983563617167606274216975227835027307)
+arg: Positive(Integer(384540926406690398126308887563696068983060261397243304150047787544284088485376639988699711945401314371474843154668485431005749360339666322077885964417814608447475728203301335))
+Some(Integer(235967098619580031997317623628085655181726099440804850677407437125486105447382881635794389301106424883995402160478548797864141341311017004099791284144218426616183450448312622)) != Some(Integer(235967098619580031997317623628085655181726099440804850677407437125486105447382881635794389301106424883995402160478548797864141341311017004099791284144218426616183450448312622))
+int: Integer(1364874660907080121974129992371799337612453216916918930212933558109242696057708391675823950242458405289224359968507480026920560051966186653720119568991513854986276899085992980872802472221909916413456022080)
+arg: Positive(Integer(28329))
+Some(Integer(10190)) != Some(Integer(10190))
+int: Integer(-240305332163314943181965740995915040048568713451930817440419950695131891564696061142676948754901911330418575843615499209772583335443144122133599524834567961494019096716964990748128869651011988383787723044760845)
+arg: Positive(Integer(4422715720747481363411982175104340274945623840457652234093178029327))
+Some(Integer(1939208606340475414041419049171086708767148933497508159286612301618)) != Some(Integer(1939208606340475414041419049171086708767148933497508159286612301618))
+int: Integer(3203720193)
+arg: Positive(Integer(13571144027725908176055114266155464712540155817579840213624684513698500343435193642507573002828360888342686448614495619155732179026198005757394896667930512333513701285845688057977320083433834558958785795159025258))
+Some(Integer(12201666119562127723527684374231026524691511516349101852486470104417452329374626038093526886399264659419823059811203307854627368714124464316629017186507998429579672360910265822948358012356780627147585509490734591)) != Some(Integer(12201666119562127723527684374231026524691511516349101852486470104417452329374626038093526886399264659419823059811203307854627368714124464316629017186507998429579672360910265822948358012356780627147585509490734591))
+int: Integer(-3858712345482550262411596779496159435534961958615997789472829281416094967515277125633583939995106348829119483497456369743609081328892523788875952765810843809437851247440369560025746916516599739251193661348)
+arg: Positive(Integer(2358530444869944859624237040958114797788819662))
+None != None
+int: Integer(-1539824474755942853972315343432935729353453981124323470350429900355411699234972190337673746569824096137184704785947570536074458820778351975220871223036680733464485775886250657514876937166101225007815975977302577097045518539624848385)
+arg: Positive(Integer(84911590590585868905827084684512333701154451747246484049868771973544677668507540401355303102113353043924533979394546684482495542543904466076399641320628373182535407213260398789360723788435223674960718408105229488778877581590567565))
+None != None
+int: Integer(2463647562996069975557609917346160742740875851883)
+arg: Positive(Integer(11051336058744460015404700188550566995989931121856061341589997612766988324874943781412932528864231645015596727823679896605583580566582167855000968311083105065803291))
+Some(Integer(6183293502570041664365767574228984615676691119054456940149843035898195077269817500479716592692323154292234890577021027066128504404842104927844063915277745136740630)) != Some(Integer(6183293502570041664365767574228984615676691119054456940149843035898195077269817500479716592692323154292234890577021027066128504404842104927844063915277745136740630))
+int: Integer(7143754863084967822610043518099229895532294247863381553314707183747030424133013082727977992812939653915295)
+arg: Positive(Integer(208089849253932409075428087697322672321))
+Some(Integer(47210419647845304730637299871214452773)) != Some(Integer(47210419647845304730637299871214452773))
+int: Integer(28593)
+arg: Positive(Integer(391002586936467005327517266301459957376714080112798832375277122995336249147))
+Some(Integer(347133937305711710217151953452333124121564261310929191055377531816759720372)) != Some(Integer(347133937305711710217151953452333124121564261310929191055377531816759720372))
+int: Integer(25270079899826701722072362511296634357940911355081500142589320447073)
+arg: Positive(Integer(24317614292755115116441621217452904224323780761714252716902643733782555223337455003339638423))
+Some(Integer(20311811466080159125069044588138414849377687371471854139516369579863644100699940766404825494)) != Some(Integer(20311811466080159125069044588138414849377687371471854139516369579863644100699940766404825494))
+int: Integer(394279319633404754616398114092771510525215657615080889280797160723170698732584132176915852379507242464498818058887953344110977618903163483967143738)
+arg: Positive(Integer(7146781421251534484433336993432755805247824106888285254862002895071688998402953723249018252653925066192639324996247194441413901269432967708906749688117972636329961265141231189063557653966026954984086922336920076423))
+Some(Integer(4037334062613706924808288353204029125154237377742058401692265951221664301109194721423277248888437586085384017376579407199970018845210534989206461737372178995732337909136119202041031875935386512420355414502730416254)) != Some(Integer(4037334062613706924808288353204029125154237377742058401692265951221664301109194721423277248888437586085384017376579407199970018845210534989206461737372178995732337909136119202041031875935386512420355414502730416254))
+int: Integer(114026187583626693619621340381869516474146588025102349870522686955022751684382673551134627390291947797634530154832158100314212864204405706497639386598)
+arg: Positive(Integer(92309301655988213590065644357096531476631359029576727737682461164411520701986100975208372513786260202271519928626719403575906900644929007987741227642847390476044852154410022228231196577279778713244381536292156065717251650486))
+None != None
+int: Integer(245210765531991452411101527979744164481254541098483498652209339580532527788200786884221823757684473351913281323167819976116326183569948495578665037569165826505187784756393774825216753542032615137862595418300757832694828800)
+arg: Positive(Integer(1599766612000048246717469574076693455348347928507311222156978108748025566303608379558592654145972797343654063979459177606744021992235))
+None != None
+int: Integer(-165343642150967075443842761513472182874424147146559288926014200301720139323764337140895298913484048961363697660579524526678468129767898595)
+arg: Positive(Integer(127544029195856473224883723271588829338650847531242728138562437831803386449861423124548096301143291463342141946397852867293022183160746085006564843173718344887543))
+Some(Integer(125187475714951339812407485478599277580212899858900509084494788210907941838327899473801667877826324501612930892817928503405071386880368126391668613098037175268152)) != Some(Integer(125187475714951339812407485478599277580212899858900509084494788210907941838327899473801667877826324501612930892817928503405071386880368126391668613098037175268152))
+int: Integer(89666965096574798428361427616112493133921355383040118620906726608648057246971619603900928)
+arg: Positive(Integer(32524152053946078886863739600040665443396704194726032407302485769057647997751106938526571923701935612050198965524571825479214624578750222228274054448581))
+Some(Integer(17432900293427674777018959312392680064961614303331734165663056677228254327545030974985164168177960088200421449589038576951027601433703780051223314630615)) != Some(Integer(17432900293427674777018959312392680064961614303331734165663056677228254327545030974985164168177960088200421449589038576951027601433703780051223314630615))
+int: Integer(-12274440753993629404668076066759262423337001728061613443224467082021986082685237268883501110776319030415786548335652410875876754702230632347124548018009404455822397159348005053497549231914344)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-6137220376996814702334038033379631211668500864030806721612233541010993041342618634441750555388159515207893274167826205437938377351115316173562274009004702227911198579674002526748774615957172)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3068610188498407351167019016689815605834250432015403360806116770505496520671309317220875277694079757603946637083913102718969188675557658086781137004502351113955599289837001263374387307978586)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1534305094249203675583509508344907802917125216007701680403058385252748260335654658610437638847039878801973318541956551359484594337778829043390568502251175556977799644918500631687193653989293)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-767152547124601837791754754172453901458562608003850840201529192626374130167827329305218819423519939400986659270978275679742297168889414521695284251125587778488899822459250315843596826994647)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-383576273562300918895877377086226950729281304001925420100764596313187065083913664652609409711759969700493329635489137839871148584444707260847642125562793889244449911229625157921798413497324)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-191788136781150459447938688543113475364640652000962710050382298156593532541956832326304704855879984850246664817744568919935574292222353630423821062781396944622224955614812578960899206748662)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-95894068390575229723969344271556737682320326000481355025191149078296766270978416163152352427939992425123332408872284459967787146111176815211910531390698472311112477807406289480449603374331)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-47947034195287614861984672135778368841160163000240677512595574539148383135489208081576176213969996212561666204436142229983893573055588407605955265695349236155556238903703144740224801687166)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-23973517097643807430992336067889184420580081500120338756297787269574191567744604040788088106984998106280833102218071114991946786527794203802977632847674618077778119451851572370112400843583)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-11986758548821903715496168033944592210290040750060169378148893634787095783872302020394044053492499053140416551109035557495973393263897101901488816423837309038889059725925786185056200421792)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5993379274410951857748084016972296105145020375030084689074446817393547891936151010197022026746249526570208275554517778747986696631948550950744408211918654519444529862962893092528100210896)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2996689637205475928874042008486148052572510187515042344537223408696773945968075505098511013373124763285104137777258889373993348315974275475372204105959327259722264931481446546264050105448)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1498344818602737964437021004243074026286255093757521172268611704348386972984037752549255506686562381642552068888629444686996674157987137737686102052979663629861132465740723273132025052724)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-749172409301368982218510502121537013143127546878760586134305852174193486492018876274627753343281190821276034444314722343498337078993568868843051026489831814930566232870361636566012526362)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-374586204650684491109255251060768506571563773439380293067152926087096743246009438137313876671640595410638017222157361171749168539496784434421525513244915907465283116435180818283006263181)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-187293102325342245554627625530384253285781886719690146533576463043548371623004719068656938335820297705319008611078680585874584269748392217210762756622457953732641558217590409141503131591)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-93646551162671122777313812765192126642890943359845073266788231521774185811502359534328469167910148852659504305539340292937292134874196108605381378311228976866320779108795204570751565796)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-46823275581335561388656906382596063321445471679922536633394115760887092905751179767164234583955074426329752152769670146468646067437098054302690689155614488433160389554397602285375782898)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-23411637790667780694328453191298031660722735839961268316697057880443546452875589883582117291977537213164876076384835073234323033718549027151345344577807244216580194777198801142687891449)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-11705818895333890347164226595649015830361367919980634158348528940221773226437794941791058645988768606582438038192417536617161516859274513575672672288903622108290097388599400571343945725)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5852909447666945173582113297824507915180683959990317079174264470110886613218897470895529322994384303291219019096208768308580758429637256787836336144451811054145048694299700285671972863)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2926454723833472586791056648912253957590341979995158539587132235055443306609448735447764661497192151645609509548104384154290379214818628393918168072225905527072524347149850142835986432)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1463227361916736293395528324456126978795170989997579269793566117527721653304724367723882330748596075822804754774052192077145189607409314196959084036112952763536262173574925071417993216)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-731613680958368146697764162228063489397585494998789634896783058763860826652362183861941165374298037911402377387026096038572594803704657098479542018056476381768131086787462535708996608)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-365806840479184073348882081114031744698792747499394817448391529381930413326181091930970582687149018955701188693513048019286297401852328549239771009028238190884065543393731267854498304)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-182903420239592036674441040557015872349396373749697408724195764690965206663090545965485291343574509477850594346756524009643148700926164274619885504514119095442032771696865633927249152)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-91451710119796018337220520278507936174698186874848704362097882345482603331545272982742645671787254738925297173378262004821574350463082137309942752257059547721016385848432816963624576)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-45725855059898009168610260139253968087349093437424352181048941172741301665772636491371322835893627369462648586689131002410787175231541068654971376128529773860508192924216408481812288)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-22862927529949004584305130069626984043674546718712176090524470586370650832886318245685661417946813684731324293344565501205393587615770534327485688064264886930254096462108204240906144)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-11431463764974502292152565034813492021837273359356088045262235293185325416443159122842830708973406842365662146672282750602696793807885267163742844032132443465127048231054102120453072)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5715731882487251146076282517406746010918636679678044022631117646592662708221579561421415354486703421182831073336141375301348396903942633581871422016066221732563524115527051060226536)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2857865941243625573038141258703373005459318339839022011315558823296331354110789780710707677243351710591415536668070687650674198451971316790935711008033110866281762057763525530113268)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1428932970621812786519070629351686502729659169919511005657779411648165677055394890355353838621675855295707768334035343825337099225985658395467855504016555433140881028881762765056634)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-714466485310906393259535314675843251364829584959755502828889705824082838527697445177676919310837927647853884167017671912668549612992829197733927752008277716570440514440881382528317)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-357233242655453196629767657337921625682414792479877751414444852912041419263848722588838459655418963823926942083508835956334274806496414598866963876004138858285220257220440691264159)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-178616621327726598314883828668960812841207396239938875707222426456020709631924361294419229827709481911963471041754417978167137403248207299433481938002069429142610128610220345632080)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-89308310663863299157441914334480406420603698119969437853611213228010354815962180647209614913854740955981735520877208989083568701624103649716740969001034714571305064305110172816040)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-44654155331931649578720957167240203210301849059984718926805606614005177407981090323604807456927370477990867760438604494541784350812051824858370484500517357285652532152555086408020)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-22327077665965824789360478583620101605150924529992359463402803307002588703990545161802403728463685238995433880219302247270892175406025912429185242250258678642826266076277543204010)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-11163538832982912394680239291810050802575462264996179731701401653501294351995272580901201864231842619497716940109651123635446087703012956214592621125129339321413133038138771602005)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5581769416491456197340119645905025401287731132498089865850700826750647175997636290450600932115921309748858470054825561817723043851506478107296310562564669660706566519069385801003)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2790884708245728098670059822952512700643865566249044932925350413375323587998818145225300466057960654874429235027412780908861521925753239053648155281282334830353283259534692900502)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1395442354122864049335029911476256350321932783124522466462675206687661793999409072612650233028980327437214617513706390454430760962876619526824077640641167415176641629767346450251)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-697721177061432024667514955738128175160966391562261233231337603343830896999704536306325116514490163718607308756853195227215380481438309763412038820320583707588320814883673225126)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-348860588530716012333757477869064087580483195781130616615668801671915448499852268153162558257245081859303654378426597613607690240719154881706019410160291853794160407441836612563)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-174430294265358006166878738934532043790241597890565308307834400835957724249926134076581279128622540929651827189213298806803845120359577440853009705080145926897080203720918306282)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-87215147132679003083439369467266021895120798945282654153917200417978862124963067038290639564311270464825913594606649403401922560179788720426504852540072963448540101860459153141)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-43607573566339501541719684733633010947560399472641327076958600208989431062481533519145319782155635232412956797303324701700961280089894360213252426270036481724270050930229576571)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-21803786783169750770859842366816505473780199736320663538479300104494715531240766759572659891077817616206478398651662350850480640044947180106626213135018240862135025465114788286)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-10901893391584875385429921183408252736890099868160331769239650052247357765620383379786329945538908808103239199325831175425240320022473590053313106567509120431067512732557394143)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5450946695792437692714960591704126368445049934080165884619825026123678882810191689893164972769454404051619599662915587712620160011236795026656553283754560215533756366278697072)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2725473347896218846357480295852063184222524967040082942309912513061839441405095844946582486384727202025809799831457793856310080005618397513328276641877280107766878183139348536)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1362736673948109423178740147926031592111262483520041471154956256530919720702547922473291243192363601012904899915728896928155040002809198756664138320938640053883439091569674268)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-681368336974054711589370073963015796055631241760020735577478128265459860351273961236645621596181800506452449957864448464077520001404599378332069160469320026941719545784837134)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-340684168487027355794685036981507898027815620880010367788739064132729930175636980618322810798090900253226224978932224232038760000702299689166034580234660013470859772892418567)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-170342084243513677897342518490753949013907810440005183894369532066364965087818490309161405399045450126613112489466112116019380000351149844583017290117330006735429886446209284)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-85171042121756838948671259245376974506953905220002591947184766033182482543909245154580702699522725063306556244733056058009690000175574922291508645058665003367714943223104642)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-42585521060878419474335629622688487253476952610001295973592383016591241271954622577290351349761362531653278122366528029004845000087787461145754322529332501683857471611552321)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-21292760530439209737167814811344243626738476305000647986796191508295620635977311288645175674880681265826639061183264014502422500043893730572877161264666250841928735805776161)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-10646380265219604868583907405672121813369238152500323993398095754147810317988655644322587837440340632913319530591632007251211250021946865286438580632333125420964367902888081)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5323190132609802434291953702836060906684619076250161996699047877073905158994327822161293918720170316456659765295816003625605625010973432643219290316166562710482183951444041)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2661595066304901217145976851418030453342309538125080998349523938536952579497163911080646959360085158228329882647908001812802812505486716321609645158083281355241091975722021)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1330797533152450608572988425709015226671154769062540499174761969268476289748581955540323479680042579114164941323954000906401406252743358160804822579041640677620545987861011)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-665398766576225304286494212854507613335577384531270249587380984634238144874290977770161739840021289557082470661977000453200703126371679080402411289520820338810272993930506)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-332699383288112652143247106427253806667788692265635124793690492317119072437145488885080869920010644778541235330988500226600351563185839540201205644760410169405136496965253)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-166349691644056326071623553213626903333894346132817562396845246158559536218572744442540434960005322389270617665494250113300175781592919770100602822380205084702568248482627)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-83174845822028163035811776606813451666947173066408781198422623079279768109286372221270217480002661194635308832747125056650087890796459885050301411190102542351284124241314)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-41587422911014081517905888303406725833473586533204390599211311539639884054643186110635108740001330597317654416373562528325043945398229942525150705595051271175642062120657)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-20793711455507040758952944151703362916736793266602195299605655769819942027321593055317554370000665298658827208186781264162521972699114971262575352797525635587821031060329)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-10396855727753520379476472075851681458368396633301097649802827884909971013660796527658777185000332649329413604093390632081260986349557485631287676398762817793910515530165)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5198427863876760189738236037925840729184198316650548824901413942454985506830398263829388592500166324664706802046695316040630493174778742815643838199381408896955257765083)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2599213931938380094869118018962920364592099158325274412450706971227492753415199131914694296250083162332353401023347658020315246587389371407821919099690704448477628882542)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1299606965969190047434559009481460182296049579162637206225353485613746376707599565957347148125041581166176700511673829010157623293694685703910959549845352224238814441271)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-649803482984595023717279504740730091148024789581318603112676742806873188353799782978673574062520790583088350255836914505078811646847342851955479774922676112119407220636)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-324901741492297511858639752370365045574012394790659301556338371403436594176899891489336787031260395291544175127918457252539405823423671425977739887461338056059703610318)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-162450870746148755929319876185182522787006197395329650778169185701718297088449945744668393515630197645772087563959228626269702911711835712988869943730669028029851805159)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-81225435373074377964659938092591261393503098697664825389084592850859148544224972872334196757815098822886043781979614313134851455855917856494434971865334514014925902580)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-40612717686537188982329969046295630696751549348832412694542296425429574272112486436167098378907549411443021890989807156567425727927958928247217485932667257007462951290)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-20306358843268594491164984523147815348375774674416206347271148212714787136056243218083549189453774705721510945494903578283712863963979464123608742966333628503731475645)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-10153179421634297245582492261573907674187887337208103173635574106357393568028121609041774594726887352860755472747451789141856431981989732061804371483166814251865737823)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5076589710817148622791246130786953837093943668604051586817787053178696784014060804520887297363443676430377736373725894570928215990994866030902185741583407125932868912)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2538294855408574311395623065393476918546971834302025793408893526589348392007030402260443648681721838215188868186862947285464107995497433015451092870791703562966434456)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1269147427704287155697811532696738459273485917151012896704446763294674196003515201130221824340860919107594434093431473642732053997748716507725546435395851781483217228)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-634573713852143577848905766348369229636742958575506448352223381647337098001757600565110912170430459553797217046715736821366026998874358253862773217697925890741608614)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-317286856926071788924452883174184614818371479287753224176111690823668549000878800282555456085215229776898608523357868410683013499437179126931386608848962945370804307)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-158643428463035894462226441587092307409185739643876612088055845411834274500439400141277728042607614888449304261678934205341506749718589563465693304424481472685402154)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-79321714231517947231113220793546153704592869821938306044027922705917137250219700070638864021303807444224652130839467102670753374859294781732846652212240736342701077)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-39660857115758973615556610396773076852296434910969153022013961352958568625109850035319432010651903722112326065419733551335376687429647390866423326106120368171350539)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-19830428557879486807778305198386538426148217455484576511006980676479284312554925017659716005325951861056163032709866775667688343714823695433211663053060184085675270)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-9915214278939743403889152599193269213074108727742288255503490338239642156277462508829858002662975930528081516354933387833844171857411847716605831526530092042837635)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4957607139469871701944576299596634606537054363871144127751745169119821078138731254414929001331487965264040758177466693916922085928705923858302915763265046021418818)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2478803569734935850972288149798317303268527181935572063875872584559910539069365627207464500665743982632020379088733346958461042964352961929151457881632523010709409)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1239401784867467925486144074899158651634263590967786031937936292279955269534682813603732250332871991316010189544366673479230521482176480964575728940816261505354705)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-619700892433733962743072037449579325817131795483893015968968146139977634767341406801866125166435995658005094772183336739615260741088240482287864470408130752677353)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-309850446216866981371536018724789662908565897741946507984484073069988817383670703400933062583217997829002547386091668369807630370544120241143932235204065376338677)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-154925223108433490685768009362394831454282948870973253992242036534994408691835351700466531291608998914501273693045834184903815185272060120571966117602032688169339)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-77462611554216745342884004681197415727141474435486626996121018267497204345917675850233265645804499457250636846522917092451907592636030060285983058801016344084670)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-38731305777108372671442002340598707863570737217743313498060509133748602172958837925116632822902249728625318423261458546225953796318015030142991529400508172042335)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-19365652888554186335721001170299353931785368608871656749030254566874301086479418962558316411451124864312659211630729273112976898159007515071495764700254086021168)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-9682826444277093167860500585149676965892684304435828374515127283437150543239709481279158205725562432156329605815364636556488449079503757535747882350127043010584)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4841413222138546583930250292574838482946342152217914187257563641718575271619854740639579102862781216078164802907682318278244224539751878767873941175063521505292)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2420706611069273291965125146287419241473171076108957093628781820859287635809927370319789551431390608039082401453841159139122112269875939383936970587531760752646)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1210353305534636645982562573143709620736585538054478546814390910429643817904963685159894775715695304019541200726920579569561056134937969691968485293765880376323)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-605176652767318322991281286571854810368292769027239273407195455214821908952481842579947387857847652009770600363460289784780528067468984845984242646882940188162)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-302588326383659161495640643285927405184146384513619636703597727607410954476240921289973693928923826004885300181730144892390264033734492422992121323441470094081)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-151294163191829580747820321642963702592073192256809818351798863803705477238120460644986846964461913002442650090865072446195132016867246211496060661720735047041)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-75647081595914790373910160821481851296036596128404909175899431901852738619060230322493423482230956501221325045432536223097566008433623105748030330860367523521)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-37823540797957395186955080410740925648018298064202454587949715950926369309530115161246711741115478250610662522716268111548783004216811552874015165430183761761)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-18911770398978697593477540205370462824009149032101227293974857975463184654765057580623355870557739125305331261358134055774391502108405776437007582715091880881)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-9455885199489348796738770102685231412004574516050613646987428987731592327382528790311677935278869562652665630679067027887195751054202888218503791357545940441)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4727942599744674398369385051342615706002287258025306823493714493865796163691264395155838967639434781326332815339533513943597875527101444109251895678772970221)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2363971299872337199184692525671307853001143629012653411746857246932898081845632197577919483819717390663166407669766756971798937763550722054625947839386485111)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1181985649936168599592346262835653926500571814506326705873428623466449040922816098788959741909858695331583203834883378485899468881775361027312973919693242556)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-590992824968084299796173131417826963250285907253163352936714311733224520461408049394479870954929347665791601917441689242949734440887680513656486959846621278)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-295496412484042149898086565708913481625142953626581676468357155866612260230704024697239935477464673832895800958720844621474867220443840256828243479923310639)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-147748206242021074949043282854456740812571476813290838234178577933306130115352012348619967738732336916447900479360422310737433610221920128414121739961655320)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-73874103121010537474521641427228370406285738406645419117089288966653065057676006174309983869366168458223950239680211155368716805110960064207060869980827660)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-36937051560505268737260820713614185203142869203322709558544644483326532528838003087154991934683084229111975119840105577684358402555480032103530434990413830)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-18468525780252634368630410356807092601571434601661354779272322241663266264419001543577495967341542114555987559920052788842179201277740016051765217495206915)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-9234262890126317184315205178403546300785717300830677389636161120831633132209500771788747983670771057277993779960026394421089600638870008025882608747603458)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4617131445063158592157602589201773150392858650415338694818080560415816566104750385894373991835385528638996889980013197210544800319435004012941304373801729)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2308565722531579296078801294600886575196429325207669347409040280207908283052375192947186995917692764319498444990006598605272400159717502006470652186900865)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1154282861265789648039400647300443287598214662603834673704520140103954141526187596473593497958846382159749222495003299302636200079858751003235326093450433)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-577141430632894824019700323650221643799107331301917336852260070051977070763093798236796748979423191079874611247501649651318100039929375501617663046725217)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-288570715316447412009850161825110821899553665650958668426130035025988535381546899118398374489711595539937305623750824825659050019964687750808831523362609)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-144285357658223706004925080912555410949776832825479334213065017512994267690773449559199187244855797769968652811875412412829525009982343875404415761681305)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-72142678829111853002462540456277705474888416412739667106532508756497133845386724779599593622427898884984326405937706206414762504991171937702207880840653)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-36071339414555926501231270228138852737444208206369833553266254378248566922693362389799796811213949442492163202968853103207381252495585968851103940420327)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-18035669707277963250615635114069426368722104103184916776633127189124283461346681194899898405606974721246081601484426551603690626247792984425551970210164)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-9017834853638981625307817557034713184361052051592458388316563594562141730673340597449949202803487360623040800742213275801845313123896492212775985105082)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4508917426819490812653908778517356592180526025796229194158281797281070865336670298724974601401743680311520400371106637900922656561948246106387992552541)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2254458713409745406326954389258678296090263012898114597079140898640535432668335149362487300700871840155760200185553318950461328280974123053193996276271)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1127229356704872703163477194629339148045131506449057298539570449320267716334167574681243650350435920077880100092776659475230664140487061526596998138136)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-563614678352436351581738597314669574022565753224528649269785224660133858167083787340621825175217960038940050046388329737615332070243530763298499069068)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-281807339176218175790869298657334787011282876612264324634892612330066929083541893670310912587608980019470025023194164868807666035121765381649249534534)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-140903669588109087895434649328667393505641438306132162317446306165033464541770946835155456293804490009735012511597082434403833017560882690824624767267)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-70451834794054543947717324664333696752820719153066081158723153082516732270885473417577728146902245004867506255798541217201916508780441345412312383634)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-35225917397027271973858662332166848376410359576533040579361576541258366135442736708788864073451122502433753127899270608600958254390220672706156191817)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-17612958698513635986929331166083424188205179788266520289680788270629183067721368354394432036725561251216876563949635304300479127195110336353078095909)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-8806479349256817993464665583041712094102589894133260144840394135314591533860684177197216018362780625608438281974817652150239563597555168176539047955)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4403239674628408996732332791520856047051294947066630072420197067657295766930342088598608009181390312804219140987408826075119781798777584088269523978)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2201619837314204498366166395760428023525647473533315036210098533828647883465171044299304004590695156402109570493704413037559890899388792044134761989)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1100809918657102249183083197880214011762823736766657518105049266914323941732585522149652002295347578201054785246852206518779945449694396022067380995)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-550404959328551124591541598940107005881411868383328759052524633457161970866292761074826001147673789100527392623426103259389972724847198011033690498)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-275202479664275562295770799470053502940705934191664379526262316728580985433146380537413000573836894550263696311713051629694986362423599005516845249)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-137601239832137781147885399735026751470352967095832189763131158364290492716573190268706500286918447275131848155856525814847493181211799502758422625)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-68800619916068890573942699867513375735176483547916094881565579182145246358286595134353250143459223637565924077928262907423746590605899751379211313)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-34400309958034445286971349933756687867588241773958047440782789591072623179143297567176625071729611818782962038964131453711873295302949875689605657)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-17200154979017222643485674966878343933794120886979023720391394795536311589571648783588312535864805909391481019482065726855936647651474937844802829)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-8600077489508611321742837483439171966897060443489511860195697397768155794785824391794156267932402954695740509741032863427968323825737468922401415)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4300038744754305660871418741719585983448530221744755930097848698884077897392912195897078133966201477347870254870516431713984161912868734461200708)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2150019372377152830435709370859792991724265110872377965048924349442038948696456097948539066983100738673935127435258215856992080956434367230600354)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1075009686188576415217854685429896495862132555436188982524462174721019474348228048974269533491550369336967563717629107928496040478217183615300177)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-537504843094288207608927342714948247931066277718094491262231087360509737174114024487134766745775184668483781858814553964248020239108591807650089)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-268752421547144103804463671357474123965533138859047245631115543680254868587057012243567383372887592334241890929407276982124010119554295903825045)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-134376210773572051902231835678737061982766569429523622815557771840127434293528506121783691686443796167120945464703638491062005059777147951912523)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-67188105386786025951115917839368530991383284714761811407778885920063717146764253060891845843221898083560472732351819245531002529888573975956262)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-33594052693393012975557958919684265495691642357380905703889442960031858573382126530445922921610949041780236366175909622765501264944286987978131)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-16797026346696506487778979459842132747845821178690452851944721480015929286691063265222961460805474520890118183087954811382750632472143493989066)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-8398513173348253243889489729921066373922910589345226425972360740007964643345531632611480730402737260445059091543977405691375316236071746994533)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4199256586674126621944744864960533186961455294672613212986180370003982321672765816305740365201368630222529545771988702845687658118035873497267)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2099628293337063310972372432480266593480727647336306606493090185001991160836382908152870182600684315111264772885994351422843829059017936748634)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1049814146668531655486186216240133296740363823668153303246545092500995580418191454076435091300342157555632386442997175711421914529508968374317)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-524907073334265827743093108120066648370181911834076651623272546250497790209095727038217545650171078777816193221498587855710957264754484187159)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-262453536667132913871546554060033324185090955917038325811636273125248895104547863519108772825085539388908096610749293927855478632377242093580)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-131226768333566456935773277030016662092545477958519162905818136562624447552273931759554386412542769694454048305374646963927739316188621046790)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-65613384166783228467886638515008331046272738979259581452909068281312223776136965879777193206271384847227024152687323481963869658094310523395)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-32806692083391614233943319257504165523136369489629790726454534140656111888068482939888596603135692423613512076343661740981934829047155261698)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-16403346041695807116971659628752082761568184744814895363227267070328055944034241469944298301567846211806756038171830870490967414523577630849)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-8201673020847903558485829814376041380784092372407447681613633535164027972017120734972149150783923105903378019085915435245483707261788815425)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4100836510423951779242914907188020690392046186203723840806816767582013986008560367486074575391961552951689009542957717622741853630894407713)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2050418255211975889621457453594010345196023093101861920403408383791006993004280183743037287695980776475844504771478858811370926815447203857)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1025209127605987944810728726797005172598011546550930960201704191895503496502140091871518643847990388237922252385739429405685463407723601929)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-512604563802993972405364363398502586299005773275465480100852095947751748251070045935759321923995194118961126192869714702842731703861800965)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-256302281901496986202682181699251293149502886637732740050426047973875874125535022967879660961997597059480563096434857351421365851930900483)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-128151140950748493101341090849625646574751443318866370025213023986937937062767511483939830480998798529740281548217428675710682925965450242)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-64075570475374246550670545424812823287375721659433185012606511993468968531383755741969915240499399264870140774108714337855341462982725121)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-32037785237687123275335272712406411643687860829716592506303255996734484265691877870984957620249699632435070387054357168927670731491362561)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-16018892618843561637667636356203205821843930414858296253151627998367242132845938935492478810124849816217535193527178584463835365745681281)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-8009446309421780818833818178101602910921965207429148126575813999183621066422969467746239405062424908108767596763589292231917682872840641)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4004723154710890409416909089050801455460982603714574063287906999591810533211484733873119702531212454054383798381794646115958841436420321)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2002361577355445204708454544525400727730491301857287031643953499795905266605742366936559851265606227027191899190897323057979420718210161)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1001180788677722602354227272262700363865245650928643515821976749897952633302871183468279925632803113513595949595448661528989710359105081)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-500590394338861301177113636131350181932622825464321757910988374948976316651435591734139962816401556756797974797724330764494855179552541)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-250295197169430650588556818065675090966311412732160878955494187474488158325717795867069981408200778378398987398862165382247427589776271)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-125147598584715325294278409032837545483155706366080439477747093737244079162858897933534990704100389189199493699431082691123713794888136)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-62573799292357662647139204516418772741577853183040219738873546868622039581429448966767495352050194594599746849715541345561856897444068)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-31286899646178831323569602258209386370788926591520109869436773434311019790714724483383747676025097297299873424857770672780928448722034)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-15643449823089415661784801129104693185394463295760054934718386717155509895357362241691873838012548648649936712428885336390464224361017)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-7821724911544707830892400564552346592697231647880027467359193358577754947678681120845936919006274324324968356214442668195232112180509)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3910862455772353915446200282276173296348615823940013733679596679288877473839340560422968459503137162162484178107221334097616056090255)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1955431227886176957723100141138086648174307911970006866839798339644438736919670280211484229751568581081242089053610667048808028045128)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-977715613943088478861550070569043324087153955985003433419899169822219368459835140105742114875784290540621044526805333524404014022564)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-488857806971544239430775035284521662043576977992501716709949584911109684229917570052871057437892145270310522263402666762202007011282)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-244428903485772119715387517642260831021788488996250858354974792455554842114958785026435528718946072635155261131701333381101003505641)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-122214451742886059857693758821130415510894244498125429177487396227777421057479392513217764359473036317577630565850666690550501752821)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-61107225871443029928846879410565207755447122249062714588743698113888710528739696256608882179736518158788815282925333345275250876411)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-30553612935721514964423439705282603877723561124531357294371849056944355264369848128304441089868259079394407641462666672637625438206)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-15276806467860757482211719852641301938861780562265678647185924528472177632184924064152220544934129539697203820731333336318812719103)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-7638403233930378741105859926320650969430890281132839323592962264236088816092462032076110272467064769848601910365666668159406359552)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3819201616965189370552929963160325484715445140566419661796481132118044408046231016038055136233532384924300955182833334079703179776)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1909600808482594685276464981580162742357722570283209830898240566059022204023115508019027568116766192462150477591416667039851589888)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-954800404241297342638232490790081371178861285141604915449120283029511102011557754009513784058383096231075238795708333519925794944)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-477400202120648671319116245395040685589430642570802457724560141514755551005778877004756892029191548115537619397854166759962897472)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-238700101060324335659558122697520342794715321285401228862280070757377775502889438502378446014595774057768809698927083379981448736)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-119350050530162167829779061348760171397357660642700614431140035378688887751444719251189223007297887028884404849463541689990724368)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-59675025265081083914889530674380085698678830321350307215570017689344443875722359625594611503648943514442202424731770844995362184)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-29837512632540541957444765337190042849339415160675153607785008844672221937861179812797305751824471757221101212365885422497681092)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-14918756316270270978722382668595021424669707580337576803892504422336110968930589906398652875912235878610550606182942711248840546)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-7459378158135135489361191334297510712334853790168788401946252211168055484465294953199326437956117939305275303091471355624420273)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3729689079067567744680595667148755356167426895084394200973126105584027742232647476599663218978058969652637651545735677812210137)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1864844539533783872340297833574377678083713447542197100486563052792013871116323738299831609489029484826318825772867838906105069)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-932422269766891936170148916787188839041856723771098550243281526396006935558161869149915804744514742413159412886433919453052535)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-466211134883445968085074458393594419520928361885549275121640763198003467779080934574957902372257371206579706443216959726526268)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-233105567441722984042537229196797209760464180942774637560820381599001733889540467287478951186128685603289853221608479863263134)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-116552783720861492021268614598398604880232090471387318780410190799500866944770233643739475593064342801644926610804239931631567)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-58276391860430746010634307299199302440116045235693659390205095399750433472385116821869737796532171400822463305402119965815784)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-29138195930215373005317153649599651220058022617846829695102547699875216736192558410934868898266085700411231652701059982907892)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-14569097965107686502658576824799825610029011308923414847551273849937608368096279205467434449133042850205615826350529991453946)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-7284548982553843251329288412399912805014505654461707423775636924968804184048139602733717224566521425102807913175264995726973)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3642274491276921625664644206199956402507252827230853711887818462484402092024069801366858612283260712551403956587632497863487)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1821137245638460812832322103099978201253626413615426855943909231242201046012034900683429306141630356275701978293816248931744)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-910568622819230406416161051549989100626813206807713427971954615621100523006017450341714653070815178137850989146908124465872)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-455284311409615203208080525774994550313406603403856713985977307810550261503008725170857326535407589068925494573454062232936)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-227642155704807601604040262887497275156703301701928356992988653905275130751504362585428663267703794534462747286727031116468)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-113821077852403800802020131443748637578351650850964178496494326952637565375752181292714331633851897267231373643363515558234)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-56910538926201900401010065721874318789175825425482089248247163476318782687876090646357165816925948633615686821681757779117)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-28455269463100950200505032860937159394587912712741044624123581738159391343938045323178582908462974316807843410840878889559)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-14227634731550475100252516430468579697293956356370522312061790869079695671969022661589291454231487158403921705420439444780)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-7113817365775237550126258215234289848646978178185261156030895434539847835984511330794645727115743579201960852710219722390)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3556908682887618775063129107617144924323489089092630578015447717269923917992255665397322863557871789600980426355109861195)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1778454341443809387531564553808572462161744544546315289007723858634961958996127832698661431778935894800490213177554930598)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-889227170721904693765782276904286231080872272273157644503861929317480979498063916349330715889467947400245106588777465299)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-444613585360952346882891138452143115540436136136578822251930964658740489749031958174665357944733973700122553294388732650)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-222306792680476173441445569226071557770218068068289411125965482329370244874515979087332678972366986850061276647194366325)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-111153396340238086720722784613035778885109034034144705562982741164685122437257989543666339486183493425030638323597183163)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-55576698170119043360361392306517889442554517017072352781491370582342561218628994771833169743091746712515319161798591582)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-27788349085059521680180696153258944721277258508536176390745685291171280609314497385916584871545873356257659580899295791)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-13894174542529760840090348076629472360638629254268088195372842645585640304657248692958292435772936678128829790449647896)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-6947087271264880420045174038314736180319314627134044097686421322792820152328624346479146217886468339064414895224823948)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3473543635632440210022587019157368090159657313567022048843210661396410076164312173239573108943234169532207447612411974)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1736771817816220105011293509578684045079828656783511024421605330698205038082156086619786554471617084766103723806205987)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-868385908908110052505646754789342022539914328391755512210802665349102519041078043309893277235808542383051861903102994)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-434192954454055026252823377394671011269957164195877756105401332674551259520539021654946638617904271191525930951551497)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-217096477227027513126411688697335505634978582097938878052700666337275629760269510827473319308952135595762965475775749)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-108548238613513756563205844348667752817489291048969439026350333168637814880134755413736659654476067797881482737887875)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-54274119306756878281602922174333876408744645524484719513175166584318907440067377706868329827238033898940741368943938)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-27137059653378439140801461087166938204372322762242359756587583292159453720033688853434164913619016949470370684471969)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-13568529826689219570400730543583469102186161381121179878293791646079726860016844426717082456809508474735185342235985)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-6784264913344609785200365271791734551093080690560589939146895823039863430008422213358541228404754237367592671117993)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3392132456672304892600182635895867275546540345280294969573447911519931715004211106679270614202377118683796335558997)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1696066228336152446300091317947933637773270172640147484786723955759965857502105553339635307101188559341898167779499)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-848033114168076223150045658973966818886635086320073742393361977879982928751052776669817653550594279670949083889750)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-424016557084038111575022829486983409443317543160036871196680988939991464375526388334908826775297139835474541944875)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-212008278542019055787511414743491704721658771580018435598340494469995732187763194167454413387648569917737270972438)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-106004139271009527893755707371745852360829385790009217799170247234997866093881597083727206693824284958868635486219)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-53002069635504763946877853685872926180414692895004608899585123617498933046940798541863603346912142479434317743110)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-26501034817752381973438926842936463090207346447502304449792561808749466523470399270931801673456071239717158871555)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-13250517408876190986719463421468231545103673223751152224896280904374733261735199635465900836728035619858579435778)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-6625258704438095493359731710734115772551836611875576112448140452187366630867599817732950418364017809929289717889)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3312629352219047746679865855367057886275918305937788056224070226093683315433799908866475209182008904964644858945)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1656314676109523873339932927683528943137959152968894028112035113046841657716899954433237604591004452482322429473)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-828157338054761936669966463841764471568979576484447014056017556523420828858449977216618802295502226241161214737)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-414078669027380968334983231920882235784489788242223507028008778261710414429224988608309401147751113120580607369)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-207039334513690484167491615960441117892244894121111753514004389130855207214612494304154700573875556560290303685)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-103519667256845242083745807980220558946122447060555876757002194565427603607306247152077350286937778280145151843)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-51759833628422621041872903990110279473061223530277938378501097282713801803653123576038675143468889140072575922)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-25879916814211310520936451995055139736530611765138969189250548641356900901826561788019337571734444570036287961)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-12939958407105655260468225997527569868265305882569484594625274320678450450913280894009668785867222285018143981)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-6469979203552827630234112998763784934132652941284742297312637160339225225456640447004834392933611142509071991)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3234989601776413815117056499381892467066326470642371148656318580169612612728320223502417196466805571254535996)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1617494800888206907558528249690946233533163235321185574328159290084806306364160111751208598233402785627267998)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-808747400444103453779264124845473116766581617660592787164079645042403153182080055875604299116701392813633999)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-404373700222051726889632062422736558383290808830296393582039822521201576591040027937802149558350696406817000)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-202186850111025863444816031211368279191645404415148196791019911260600788295520013968901074779175348203408500)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-101093425055512931722408015605684139595822702207574098395509955630300394147760006984450537389587674101704250)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-50546712527756465861204007802842069797911351103787049197754977815150197073880003492225268694793837050852125)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-25273356263878232930602003901421034898955675551893524598877488907575098536940001746112634347396918525426063)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-12636678131939116465301001950710517449477837775946762299438744453787549268470000873056317173698459262713032)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-6318339065969558232650500975355258724738918887973381149719372226893774634235000436528158586849229631356516)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3159169532984779116325250487677629362369459443986690574859686113446887317117500218264079293424614815678258)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1579584766492389558162625243838814681184729721993345287429843056723443658558750109132039646712307407839129)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-789792383246194779081312621919407340592364860996672643714921528361721829279375054566019823356153703919565)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-394896191623097389540656310959703670296182430498336321857460764180860914639687527283009911678076851959783)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-197448095811548694770328155479851835148091215249168160928730382090430457319843763641504955839038425979892)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-98724047905774347385164077739925917574045607624584080464365191045215228659921881820752477919519212989946)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-49362023952887173692582038869962958787022803812292040232182595522607614329960940910376238959759606494973)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-24681011976443586846291019434981479393511401906146020116091297761303807164980470455188119479879803247487)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-12340505988221793423145509717490739696755700953073010058045648880651903582490235227594059739939901623744)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-6170252994110896711572754858745369848377850476536505029022824440325951791245117613797029869969950811872)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3085126497055448355786377429372684924188925238268252514511412220162975895622558806898514934984975405936)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1542563248527724177893188714686342462094462619134126257255706110081487947811279403449257467492487702968)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-771281624263862088946594357343171231047231309567063128627853055040743973905639701724628733746243851484)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-385640812131931044473297178671585615523615654783531564313926527520371986952819850862314366873121925742)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-192820406065965522236648589335792807761807827391765782156963263760185993476409925431157183436560962871)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-96410203032982761118324294667896403880903913695882891078481631880092996738204962715578591718280481436)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-48205101516491380559162147333948201940451956847941445539240815940046498369102481357789295859140240718)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-24102550758245690279581073666974100970225978423970722769620407970023249184551240678894647929570120359)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-12051275379122845139790536833487050485112989211985361384810203985011624592275620339447323964785060180)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-6025637689561422569895268416743525242556494605992680692405101992505812296137810169723661982392530090)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3012818844780711284947634208371762621278247302996340346202550996252906148068905084861830991196265045)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1506409422390355642473817104185881310639123651498170173101275498126453074034452542430915495598132523)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-753204711195177821236908552092940655319561825749085086550637749063226537017226271215457747799066262)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-376602355597588910618454276046470327659780912874542543275318874531613268508613135607728873899533131)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-188301177798794455309227138023235163829890456437271271637659437265806634254306567803864436949766566)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-94150588899397227654613569011617581914945228218635635818829718632903317127153283901932218474883283)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-47075294449698613827306784505808790957472614109317817909414859316451658563576641950966109237441642)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-23537647224849306913653392252904395478736307054658908954707429658225829281788320975483054618720821)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-11768823612424653456826696126452197739368153527329454477353714829112914640894160487741527309360411)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5884411806212326728413348063226098869684076763664727238676857414556457320447080243870763654680206)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2942205903106163364206674031613049434842038381832363619338428707278228660223540121935381827340103)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1471102951553081682103337015806524717421019190916181809669214353639114330111770060967690913670052)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-735551475776540841051668507903262358710509595458090904834607176819557165055885030483845456835026)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-367775737888270420525834253951631179355254797729045452417303588409778582527942515241922728417513)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-183887868944135210262917126975815589677627398864522726208651794204889291263971257620961364208757)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-91943934472067605131458563487907794838813699432261363104325897102444645631985628810480682104379)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-45971967236033802565729281743953897419406849716130681552162948551222322815992814405240341052190)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-22985983618016901282864640871976948709703424858065340776081474275611161407996407202620170526095)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-11492991809008450641432320435988474354851712429032670388040737137805580703998203601310085263048)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5746495904504225320716160217994237177425856214516335194020368568902790351999101800655042631524)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2873247952252112660358080108997118588712928107258167597010184284451395175999550900327521315762)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1436623976126056330179040054498559294356464053629083798505092142225697587999775450163760657881)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-718311988063028165089520027249279647178232026814541899252546071112848793999887725081880328941)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-359155994031514082544760013624639823589116013407270949626273035556424396999943862540940164471)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-179577997015757041272380006812319911794558006703635474813136517778212198499971931270470082236)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-89788998507878520636190003406159955897279003351817737406568258889106099249985965635235041118)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-44894499253939260318095001703079977948639501675908868703284129444553049624992982817617520559)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-22447249626969630159047500851539988974319750837954434351642064722276524812496491408808760280)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-11223624813484815079523750425769994487159875418977217175821032361138262406248245704404380140)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5611812406742407539761875212884997243579937709488608587910516180569131203124122852202190070)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2805906203371203769880937606442498621789968854744304293955258090284565601562061426101095035)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1402953101685601884940468803221249310894984427372152146977629045142282800781030713050547518)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-701476550842800942470234401610624655447492213686076073488814522571141400390515356525273759)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-350738275421400471235117200805312327723746106843038036744407261285570700195257678262636880)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-175369137710700235617558600402656163861873053421519018372203630642785350097628839131318440)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-87684568855350117808779300201328081930936526710759509186101815321392675048814419565659220)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-43842284427675058904389650100664040965468263355379754593050907660696337524407209782829610)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-21921142213837529452194825050332020482734131677689877296525453830348168762203604891414805)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-10960571106918764726097412525166010241367065838844938648262726915174084381101802445707403)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5480285553459382363048706262583005120683532919422469324131363457587042190550901222853702)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2740142776729691181524353131291502560341766459711234662065681728793521095275450611426851)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1370071388364845590762176565645751280170883229855617331032840864396760547637725305713426)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-685035694182422795381088282822875640085441614927808665516420432198380273818862652856713)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-342517847091211397690544141411437820042720807463904332758210216099190136909431326428357)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-171258923545605698845272070705718910021360403731952166379105108049595068454715663214179)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-85629461772802849422636035352859455010680201865976083189552554024797534227357831607090)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-42814730886401424711318017676429727505340100932988041594776277012398767113678915803545)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-21407365443200712355659008838214863752670050466494020797388138506199383556839457901773)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-10703682721600356177829504419107431876335025233247010398694069253099691778419728950887)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5351841360800178088914752209553715938167512616623505199347034626549845889209864475444)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2675920680400089044457376104776857969083756308311752599673517313274922944604932237722)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1337960340200044522228688052388428984541878154155876299836758656637461472302466118861)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-668980170100022261114344026194214492270939077077938149918379328318730736151233059431)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-334490085050011130557172013097107246135469538538969074959189664159365368075616529716)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-167245042525005565278586006548553623067734769269484537479594832079682684037808264858)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-83622521262502782639293003274276811533867384634742268739797416039841342018904132429)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-41811260631251391319646501637138405766933692317371134369898708019920671009452066215)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-20905630315625695659823250818569202883466846158685567184949354009960335504726033108)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-10452815157812847829911625409284601441733423079342783592474677004980167752363016554)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5226407578906423914955812704642300720866711539671391796237338502490083876181508277)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2613203789453211957477906352321150360433355769835695898118669251245041938090754139)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1306601894726605978738953176160575180216677884917847949059334625622520969045377070)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-653300947363302989369476588080287590108338942458923974529667312811260484522688535)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-326650473681651494684738294040143795054169471229461987264833656405630242261344268)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-163325236840825747342369147020071897527084735614730993632416828202815121130672134)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-81662618420412873671184573510035948763542367807365496816208414101407560565336067)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-40831309210206436835592286755017974381771183903682748408104207050703780282668034)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-20415654605103218417796143377508987190885591951841374204052103525351890141334017)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-10207827302551609208898071688754493595442795975920687102026051762675945070667009)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5103913651275804604449035844377246797721397987960343551013025881337972535333505)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2551956825637902302224517922188623398860698993980171775506512940668986267666753)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1275978412818951151112258961094311699430349496990085887753256470334493133833377)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-637989206409475575556129480547155849715174748495042943876628235167246566916689)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-318994603204737787778064740273577924857587374247521471938314117583623283458345)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-159497301602368893889032370136788962428793687123760735969157058791811641729173)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-79748650801184446944516185068394481214396843561880367984578529395905820864587)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-39874325400592223472258092534197240607198421780940183992289264697952910432294)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-19937162700296111736129046267098620303599210890470091996144632348976455216147)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-9968581350148055868064523133549310151799605445235045998072316174488227608074)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4984290675074027934032261566774655075899802722617522999036158087244113804037)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2492145337537013967016130783387327537949901361308761499518079043622056902019)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1246072668768506983508065391693663768974950680654380749759039521811028451010)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-623036334384253491754032695846831884487475340327190374879519760905514225505)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-311518167192126745877016347923415942243737670163595187439759880452757112753)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-155759083596063372938508173961707971121868835081797593719879940226378556377)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-77879541798031686469254086980853985560934417540898796859939970113189278189)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-38939770899015843234627043490426992780467208770449398429969985056594639095)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-19469885449507921617313521745213496390233604385224699214984992528297319548)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-9734942724753960808656760872606748195116802192612349607492496264148659774)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4867471362376980404328380436303374097558401096306174803746248132074329887)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2433735681188490202164190218151687048779200548153087401873124066037164944)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1216867840594245101082095109075843524389600274076543700936562033018582472)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-608433920297122550541047554537921762194800137038271850468281016509291236)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-304216960148561275270523777268960881097400068519135925234140508254645618)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-152108480074280637635261888634480440548700034259567962617070254127322809)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-76054240037140318817630944317240220274350017129783981308535127063661405)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-38027120018570159408815472158620110137175008564891990654267563531830703)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-19013560009285079704407736079310055068587504282445995327133781765915352)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-9506780004642539852203868039655027534293752141222997663566890882957676)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4753390002321269926101934019827513767146876070611498831783445441478838)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2376695001160634963050967009913756883573438035305749415891722720739419)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1188347500580317481525483504956878441786719017652874707945861360369710)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-594173750290158740762741752478439220893359508826437353972930680184855)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-297086875145079370381370876239219610446679754413218676986465340092428)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-148543437572539685190685438119609805223339877206609338493232670046214)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-74271718786269842595342719059804902611669938603304669246616335023107)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-37135859393134921297671359529902451305834969301652334623308167511554)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-18567929696567460648835679764951225652917484650826167311654083755777)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-9283964848283730324417839882475612826458742325413083655827041877889)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4641982424141865162208919941237806413229371162706541827913520938945)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2320991212070932581104459970618903206614685581353270913956760469473)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1160495606035466290552229985309451603307342790676635456978380234737)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-580247803017733145276114992654725801653671395338317728489190117369)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-290123901508866572638057496327362900826835697669158864244595058685)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-145061950754433286319028748163681450413417848834579432122297529343)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-72530975377216643159514374081840725206708924417289716061148764672)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-36265487688608321579757187040920362603354462208644858030574382336)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-18132743844304160789878593520460181301677231104322429015287191168)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-9066371922152080394939296760230090650838615552161214507643595584)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4533185961076040197469648380115045325419307776080607253821797792)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2266592980538020098734824190057522662709653888040303626910898896)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1133296490269010049367412095028761331354826944020151813455449448)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-566648245134505024683706047514380665677413472010075906727724724)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-283324122567252512341853023757190332838706736005037953363862362)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-141662061283626256170926511878595166419353368002518976681931181)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-70831030641813128085463255939297583209676684001259488340965591)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-35415515320906564042731627969648791604838342000629744170482796)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-17707757660453282021365813984824395802419171000314872085241398)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-8853878830226641010682906992412197901209585500157436042620699)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4426939415113320505341453496206098950604792750078718021310350)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2213469707556660252670726748103049475302396375039359010655175)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1106734853778330126335363374051524737651198187519679505327588)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-553367426889165063167681687025762368825599093759839752663794)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-276683713444582531583840843512881184412799546879919876331897)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-138341856722291265791920421756440592206399773439959938165949)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-69170928361145632895960210878220296103199886719979969082975)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-34585464180572816447980105439110148051599943359989984541488)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-17292732090286408223990052719555074025799971679994992270744)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-8646366045143204111995026359777537012899985839997496135372)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4323183022571602055997513179888768506449992919998748067686)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2161591511285801027998756589944384253224996459999374033843)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1080795755642900513999378294972192126612498229999687016922)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-540397877821450256999689147486096063306249114999843508461)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-270198938910725128499844573743048031653124557499921754231)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-135099469455362564249922286871524015826562278749960877116)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-67549734727681282124961143435762007913281139374980438558)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-33774867363840641062480571717881003956640569687490219279)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-16887433681920320531240285858940501978320284843745109640)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-8443716840960160265620142929470250989160142421872554820)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4221858420480080132810071464735125494580071210936277410)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2110929210240040066405035732367562747290035605468138705)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1055464605120020033202517866183781373645017802734069353)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-527732302560010016601258933091890686822508901367034677)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-263866151280005008300629466545945343411254450683517339)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-131933075640002504150314733272972671705627225341758670)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-65966537820001252075157366636486335852813612670879335)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-32983268910000626037578683318243167926406806335439668)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-16491634455000313018789341659121583963203403167719834)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-8245817227500156509394670829560791981601701583859917)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4122908613750078254697335414780395990800850791929959)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2061454306875039127348667707390197995400425395964980)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1030727153437519563674333853695098997700212697982490)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-515363576718759781837166926847549498850106348991245)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-257681788359379890918583463423774749425053174495623)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-128840894179689945459291731711887374712526587247812)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-64420447089844972729645865855943687356263293623906)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-32210223544922486364822932927971843678131646811953)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-16105111772461243182411466463985921839065823405977)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-8052555886230621591205733231992960919532911702989)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-4026277943115310795602866615996480459766455851495)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2013138971557655397801433307998240229883227925748)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1006569485778827698900716653999120114941613962874)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-503284742889413849450358326999560057470806981437)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-251642371444706924725179163499780028735403490719)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-125821185722353462362589581749890014367701745360)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-62910592861176731181294790874945007183850872680)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-31455296430588365590647395437472503591925436340)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-15727648215294182795323697718736251795962718170)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-7863824107647091397661848859368125897981359085)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3931912053823545698830924429684062948990679543)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1965956026911772849415462214842031474495339772)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-982978013455886424707731107421015737247669886)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-491489006727943212353865553710507868623834943)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-245744503363971606176932776855253934311917472)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-122872251681985803088466388427626967155958736)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-61436125840992901544233194213813483577979368)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-30718062920496450772116597106906741788989684)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-15359031460248225386058298553453370894494842)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-7679515730124112693029149276726685447247421)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3839757865062056346514574638363342723623711)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1919878932531028173257287319181671361811856)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-959939466265514086628643659590835680905928)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-479969733132757043314321829795417840452964)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-239984866566378521657160914897708920226482)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-119992433283189260828580457448854460113241)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-59996216641594630414290228724427230056621)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-29998108320797315207145114362213615028311)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-14999054160398657603572557181106807514156)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-7499527080199328801786278590553403757078)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3749763540099664400893139295276701878539)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1874881770049832200446569647638350939270)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-937440885024916100223284823819175469635)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-468720442512458050111642411909587734818)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-234360221256229025055821205954793867409)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-117180110628114512527910602977396933705)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-58590055314057256263955301488698466853)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-29295027657028628131977650744349233427)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-14647513828514314065988825372174616714)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-7323756914257157032994412686087308357)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3661878457128578516497206343043654179)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1830939228564289258248603171521827090)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-915469614282144629124301585760913545)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-457734807141072314562150792880456773)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-228867403570536157281075396440228387)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-114433701785268078640537698220114194)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-57216850892634039320268849110057097)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-28608425446317019660134424555028549)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-14304212723158509830067212277514275)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-7152106361579254915033606138757138)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3576053180789627457516803069378569)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1788026590394813728758401534689285)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-894013295197406864379200767344643)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-447006647598703432189600383672322)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-223503323799351716094800191836161)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-111751661899675858047400095918081)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-55875830949837929023700047959041)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-27937915474918964511850023979521)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-13968957737459482255925011989761)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-6984478868729741127962505994881)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3492239434364870563981252997441)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1746119717182435281990626498721)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-873059858591217640995313249361)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-436529929295608820497656624681)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-218264964647804410248828312341)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-109132482323902205124414156171)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-54566241161951102562207078086)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-27283120580975551281103539043)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-13641560290487775640551769522)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-6820780145243887820275884761)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3410390072621943910137942381)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1705195036310971955068971191)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-852597518155485977534485596)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-426298759077742988767242798)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-213149379538871494383621399)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-106574689769435747191810700)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-53287344884717873595905350)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-26643672442358936797952675)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-13321836221179468398976338)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-6660918110589734199488169)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3330459055294867099744085)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1665229527647433549872043)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-832614763823716774936022)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-416307381911858387468011)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-208153690955929193734006)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-104076845477964596867003)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-52038422738982298433502)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-26019211369491149216751)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-13009605684745574608376)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-6504802842372787304188)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3252401421186393652094)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1626200710593196826047)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-813100355296598413024)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-406550177648299206512)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-203275088824149603256)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-101637544412074801628)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-50818772206037400814)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-25409386103018700407)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-12704693051509350204)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-6352346525754675102)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3176173262877337551)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1588086631438668776)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-794043315719334388)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-397021657859667194)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-198510828929833597)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-99255414464916799)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-49627707232458400)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-24813853616229200)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-12406926808114600)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-6203463404057300)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3101731702028650)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1550865851014325)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-775432925507163)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-387716462753582)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-193858231376791)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-96929115688396)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-48464557844198)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-24232278922099)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-12116139461050)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-6058069730525)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3029034865263)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1514517432632)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-757258716316)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-378629358158)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-189314679079)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-94657339540)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-47328669770)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-23664334885)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-11832167443)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5916083722)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2958041861)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1479020931)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-739510466)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-369755233)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-184877617)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-92438809)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-46219405)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-23109703)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-11554852)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5777426)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2888713)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1444357)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-722179)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-361090)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-180545)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-90273)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-45137)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-22569)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-11285)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-5643)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2822)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1411)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-706)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-353)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-177)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-89)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-45)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-23)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-12)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-6)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-3)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-2)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(1)) != Some(Integer(0))
+int: Integer(-1)
+arg: Positive(Integer(1))
+Some(Integer(
+thread 'backend::invert' (165017) has overflowed its stack
+fatal runtime error: stack overflow, aborting
+error: test failed, to rerun pass `--test integration`
+
+Caused by:
+  process didn't exit successfully: `/home/user/fast-paillier/target/debug/deps/integration-c561df37baeccefc 'backend::invert' --exact --nocapture` (signal: 6, SIGABRT: process abort signal)

From 10169446857012edd3a8c8190396e599cbbbc437 Mon Sep 17 00:00:00 2001
From: Denis Varlakov <cordial.egg6523@fastmail.com>
Date: Thu, 15 Oct 2026 17:26:23 +0200
Subject: [PATCH 5/7] Migrate fully to crypto_primes

Signed-off-by: Denis Varlakov <cordial.egg6523@fastmail.com>
---
 src/backend/num_bigint.rs | 327 +-------------------------------------
 1 file changed, 7 insertions(+), 320 deletions(-)

diff --git a/src/backend/num_bigint.rs b/src/backend/num_bigint.rs
index 1bb8231..14d12dd 100644
--- a/src/backend/num_bigint.rs
+++ b/src/backend/num_bigint.rs
@@ -302,7 +302,7 @@ impl Integer {
     pub fn is_probably_prime(&self, _reps: u32, _rng: &mut impl rand_core::RngCore) -> IsPrime {
         if self.cmp0().is_le() {
             IsPrime::No
-        } else if glass_pumpkin::is_prime_baillie_psw(self.0.magnitude()) {
+        } else if glass_pumpkin::is_prime(self.0.magnitude()) {
             IsPrime::Probably
         } else {
             IsPrime::No
@@ -315,7 +315,7 @@ impl Integer {
             x.assign_random_bits(bit_size, rng);
             x.set_bit(bit_size - 1, true);
             x |= 1u32;
-            if glass_pumpkin::is_prime_baillie_psw(x.0.magnitude()) {
+            if glass_pumpkin::is_prime(x.0.magnitude()) {
                 break x;
             }
         }
@@ -439,333 +439,20 @@ impl quickcheck::Arbitrary for Integer {
 ///
 /// We can migrate back to that dependency when we update our ecosystem to latest `rand_core`.
 mod glass_pumpkin {
-    use crypto_bigint::{nlimbs, BoxedUint, Odd, Uint};
-    use crypto_primes::hazmat::{lucas_test, LucasCheck, SelfridgeBase};
-    use num_bigint::BigUint;
-    use num_integer::Integer as _;
-    use num_traits::{One as _, ToPrimitive as _};
-
     /// Checks if a number is probably prime using the deterministic-base
     /// Baillie-PSW test.
     ///
     /// The RNG parameter is retained for API compatibility and is not consumed.
-    pub fn is_prime_baillie_psw(candidate: &BigUint) -> bool {
-        baillie_psw(candidate, false)
-    }
-
-    /// Run the conventional Baillie-PSW probable-prime test.
-    fn baillie_psw(candidate: &BigUint, q_check: bool) -> bool {
-        if candidate == &BigUint::from(2_u8) {
-            return true;
-        }
-        if candidate < &BigUint::from(2_u8) || candidate.is_even() {
-            return false;
-        }
-        if !passes_small_prime_sieve(candidate, q_check) {
-            return false;
-        }
-        if candidate
-            .to_u32()
-            .is_some_and(|value| value <= MAX_SMALL_PRIME)
-        {
-            return true;
-        }
-
-        baillie_psw_presieved(candidate)
-    }
-
-    /// Run the two conventional BPSW components after small-factor screening:
-    /// a strong base-2 Miller-Rabin test and a strong Lucas-Selfridge test.
-    fn baillie_psw_presieved(candidate: &BigUint) -> bool {
-        MillerRabin::new(candidate).passes_bpsw()
-    }
-
-    /// Candidate-specific values shared by every Miller-Rabin base.
-    struct MillerRabin<'a> {
-        candidate: &'a BigUint,
-        candidate_minus_one: BigUint,
-        odd_part: BigUint,
-        trials: u64,
+    pub fn is_prime(candidate: &num_bigint::BigUint) -> bool {
+        crypto_primes::is_prime(crypto_primes::Flavor::Any, &boxed_uint(candidate))
     }
 
-    impl<'a> MillerRabin<'a> {
-        fn new(candidate: &'a BigUint) -> Self {
-            let candidate_minus_one = candidate - 1_u8;
-            let trials = candidate_minus_one.trailing_zeros().unwrap_or_default();
-            let odd_part = &candidate_minus_one >> trials;
-            Self {
-                candidate,
-                candidate_minus_one,
-                odd_part,
-                trials,
-            }
-        }
-
-        fn check_base(&self, basis: &BigUint) -> bool {
-            let mut test = basis.modpow(&self.odd_part, self.candidate);
-
-            if test.is_one() || test == self.candidate_minus_one {
-                return true;
-            }
-
-            for _ in 1..self.trials {
-                test = (&test * &test) % self.candidate;
-                if test == self.candidate_minus_one {
-                    return true;
-                }
-                if test.is_one() {
-                    return false;
-                }
-            }
-
-            false
-        }
-
-        fn passes_bpsw(&self) -> bool {
-            self.check_base_two() && strong_lucas_selfridge(self.candidate)
-        }
-
-        fn check_base_two(&self) -> bool {
-            self.check_base(&BigUint::from(2_u8))
-        }
-    }
-
-    /// Strong Lucas probable-prime test with Selfridge's method-A parameters.
-    ///
-    /// This is the Lucas half of the conventional Baillie-PSW test. It chooses
-    /// `D = 5, -7, 9, -11, ...`, `P = 1`, and `Q = (1-D)/4`, then checks the
-    /// strong Lucas conditions for the odd part of `n + 1`.
-    fn strong_lucas_selfridge(n: &BigUint) -> bool {
-        if !cfg!(debug_assertions) {
-            match n.bits().div_ceil(8) {
-                128 => return strong_lucas_fixed::<{ nlimbs(1024) }>(n),
-                256 => return strong_lucas_fixed::<{ nlimbs(2048) }>(n),
-                512 => return strong_lucas_fixed::<{ nlimbs(4096) }>(n),
-                _ => {}
-            }
-        }
-
-        Odd::new(boxed_uint(n))
-            .into_option()
-            .is_some_and(|candidate| {
-                lucas_test(candidate, SelfridgeBase, LucasCheck::Strong).is_probably_prime()
-            })
-    }
-
-    fn strong_lucas_fixed<const LIMBS: usize>(n: &BigUint) -> bool {
-        Odd::new(Uint::<LIMBS>::from_be_slice(&n.to_bytes_be()))
-            .into_option()
-            .is_some_and(|candidate| {
-                lucas_test(candidate, SelfridgeBase, LucasCheck::Strong).is_probably_prime()
-            })
-    }
-
-    fn boxed_uint(n: &BigUint) -> BoxedUint {
+    fn boxed_uint(n: &num_bigint::BigUint) -> crypto_bigint::BoxedUint {
         crypto_bigint::cpubits! {
-            16 | 32 => { BoxedUint::from_words(n.iter_u32_digits()) }
-            64 => { BoxedUint::from_words(n.iter_u64_digits()) }
+            16 | 32 => { crypto_bigint::BoxedUint::from_words(n.iter_u32_digits()) }
+            64 => { crypto_bigint::BoxedUint::from_words(n.iter_u64_digits()) }
         }
     }
-
-    fn passes_small_prime_sieve(candidate: &BigUint, q_check: bool) -> bool {
-        if let Some(small) = candidate.to_u32() {
-            if small <= MAX_SMALL_PRIME {
-                return small == 2 || PRIMES.binary_search(&small).is_ok();
-            }
-        }
-
-        // Batch adjacent primes into the largest product that fits in a `u32`.
-        // This roughly halves the number of big-integer remainder operations while
-        // retaining the scalar fast path in `num-bigint`.
-        let use_native_remainder = cfg!(debug_assertions) || candidate.bits() > 6144;
-        let mut start = 0;
-        while start < PRIMES.len() {
-            let mut product = 1_u32;
-            let mut end = start;
-            while end < PRIMES.len() {
-                let Some(next) = product.checked_mul(PRIMES[end]) else {
-                    break;
-                };
-                product = next;
-                end += 1;
-            }
-
-            let batch_remainder = if use_native_remainder {
-                (candidate % product)
-                    .iter_u32_digits()
-                    .next()
-                    .unwrap_or_default()
-            } else {
-                rem_u32(candidate, product)
-            };
-            for &prime in &PRIMES[start..end] {
-                let remainder = batch_remainder % prime;
-                if remainder == 0 || q_check && remainder == (prime - 1) / 2 {
-                    return false;
-                }
-            }
-            start = end;
-        }
-
-        true
-    }
-
-    /// Compute a small remainder through `num-bigint`'s public arithmetic traits.
-    #[inline]
-    fn rem_u32(n: &BigUint, modulus: u32) -> u32 {
-        let modulus = u64::from(modulus);
-        let remainder = n.iter_u32_digits().rev().fold(0_u64, |remainder, digit| {
-            ((remainder << 32) | u64::from(digit)) % modulus
-        });
-        remainder as u32
-    }
-
-    static PRIMES: &[u32] = &[
-        3_u32, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83,
-        89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179,
-        181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277,
-        281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389,
-        397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499,
-        503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617,
-        619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739,
-        743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859,
-        863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991,
-        997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091,
-        1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201,
-        1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301,
-        1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433,
-        1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531,
-        1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621,
-        1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747,
-        1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873,
-        1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997,
-        1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099,
-        2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237,
-        2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341,
-        2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441,
-        2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591,
-        2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693,
-        2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797,
-        2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917,
-        2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049,
-        3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191,
-        3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319,
-        3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449,
-        3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547,
-        3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671,
-        3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793,
-        3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917,
-        3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027,
-        4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157,
-        4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273,
-        4283, 4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423,
-        4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549,
-        4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673,
-        4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801,
-        4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951,
-        4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, 5039, 5051, 5059,
-        5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189, 5197,
-        5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347,
-        5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471,
-        5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581,
-        5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711,
-        5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843,
-        5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981,
-        5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113,
-        6121, 6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247,
-        6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353,
-        6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491,
-        6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, 6607, 6619, 6637, 6653,
-        6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779,
-        6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, 6857, 6863, 6869, 6871, 6883, 6899,
-        6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013,
-        7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121, 7127, 7129, 7151, 7159, 7177,
-        7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309,
-        7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481,
-        7487, 7489, 7499, 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577,
-        7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 7699,
-        7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853,
-        7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951, 7963, 7993,
-        8009, 8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123,
-        8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221, 8231, 8233, 8237, 8243, 8263, 8269,
-        8273, 8287, 8291, 8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, 8389, 8419,
-        8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, 8513, 8521, 8527, 8537, 8539, 8543, 8563,
-        8573, 8581, 8597, 8599, 8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, 8681, 8689,
-        8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, 8747, 8753, 8761, 8779, 8783, 8803, 8807,
-        8819, 8821, 8831, 8837, 8839, 8849, 8861, 8863, 8867, 8887, 8893, 8923, 8929, 8933, 8941,
-        8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, 9013, 9029, 9041, 9043, 9049, 9059, 9067,
-        9091, 9103, 9109, 9127, 9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, 9203, 9209,
-        9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, 9293, 9311, 9319, 9323, 9337, 9341, 9343,
-        9349, 9371, 9377, 9391, 9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, 9461, 9463,
-        9467, 9473, 9479, 9491, 9497, 9511, 9521, 9533, 9539, 9547, 9551, 9587, 9601, 9613, 9619,
-        9623, 9629, 9631, 9643, 9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739, 9743,
-        9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, 9817, 9829, 9833, 9839, 9851, 9857, 9859,
-        9871, 9883, 9887, 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973, 10007, 10009,
-        10037, 10039, 10061, 10067, 10069, 10079, 10091, 10093, 10099, 10103, 10111, 10133, 10139,
-        10141, 10151, 10159, 10163, 10169, 10177, 10181, 10193, 10211, 10223, 10243, 10247, 10253,
-        10259, 10267, 10271, 10273, 10289, 10301, 10303, 10313, 10321, 10331, 10333, 10337, 10343,
-        10357, 10369, 10391, 10399, 10427, 10429, 10433, 10453, 10457, 10459, 10463, 10477, 10487,
-        10499, 10501, 10513, 10529, 10531, 10559, 10567, 10589, 10597, 10601, 10607, 10613, 10627,
-        10631, 10639, 10651, 10657, 10663, 10667, 10687, 10691, 10709, 10711, 10723, 10729, 10733,
-        10739, 10753, 10771, 10781, 10789, 10799, 10831, 10837, 10847, 10853, 10859, 10861, 10867,
-        10883, 10889, 10891, 10903, 10909, 10937, 10939, 10949, 10957, 10973, 10979, 10987, 10993,
-        11003, 11027, 11047, 11057, 11059, 11069, 11071, 11083, 11087, 11093, 11113, 11117, 11119,
-        11131, 11149, 11159, 11161, 11171, 11173, 11177, 11197, 11213, 11239, 11243, 11251, 11257,
-        11261, 11273, 11279, 11287, 11299, 11311, 11317, 11321, 11329, 11351, 11353, 11369, 11383,
-        11393, 11399, 11411, 11423, 11437, 11443, 11447, 11467, 11471, 11483, 11489, 11491, 11497,
-        11503, 11519, 11527, 11549, 11551, 11579, 11587, 11593, 11597, 11617, 11621, 11633, 11657,
-        11677, 11681, 11689, 11699, 11701, 11717, 11719, 11731, 11743, 11777, 11779, 11783, 11789,
-        11801, 11807, 11813, 11821, 11827, 11831, 11833, 11839, 11863, 11867, 11887, 11897, 11903,
-        11909, 11923, 11927, 11933, 11939, 11941, 11953, 11959, 11969, 11971, 11981, 11987, 12007,
-        12011, 12037, 12041, 12043, 12049, 12071, 12073, 12097, 12101, 12107, 12109, 12113, 12119,
-        12143, 12149, 12157, 12161, 12163, 12197, 12203, 12211, 12227, 12239, 12241, 12251, 12253,
-        12263, 12269, 12277, 12281, 12289, 12301, 12323, 12329, 12343, 12347, 12373, 12377, 12379,
-        12391, 12401, 12409, 12413, 12421, 12433, 12437, 12451, 12457, 12473, 12479, 12487, 12491,
-        12497, 12503, 12511, 12517, 12527, 12539, 12541, 12547, 12553, 12569, 12577, 12583, 12589,
-        12601, 12611, 12613, 12619, 12637, 12641, 12647, 12653, 12659, 12671, 12689, 12697, 12703,
-        12713, 12721, 12739, 12743, 12757, 12763, 12781, 12791, 12799, 12809, 12821, 12823, 12829,
-        12841, 12853, 12889, 12893, 12899, 12907, 12911, 12917, 12919, 12923, 12941, 12953, 12959,
-        12967, 12973, 12979, 12983, 13001, 13003, 13007, 13009, 13033, 13037, 13043, 13049, 13063,
-        13093, 13099, 13103, 13109, 13121, 13127, 13147, 13151, 13159, 13163, 13171, 13177, 13183,
-        13187, 13217, 13219, 13229, 13241, 13249, 13259, 13267, 13291, 13297, 13309, 13313, 13327,
-        13331, 13337, 13339, 13367, 13381, 13397, 13399, 13411, 13417, 13421, 13441, 13451, 13457,
-        13463, 13469, 13477, 13487, 13499, 13513, 13523, 13537, 13553, 13567, 13577, 13591, 13597,
-        13613, 13619, 13627, 13633, 13649, 13669, 13679, 13681, 13687, 13691, 13693, 13697, 13709,
-        13711, 13721, 13723, 13729, 13751, 13757, 13759, 13763, 13781, 13789, 13799, 13807, 13829,
-        13831, 13841, 13859, 13873, 13877, 13879, 13883, 13901, 13903, 13907, 13913, 13921, 13931,
-        13933, 13963, 13967, 13997, 13999, 14009, 14011, 14029, 14033, 14051, 14057, 14071, 14081,
-        14083, 14087, 14107, 14143, 14149, 14153, 14159, 14173, 14177, 14197, 14207, 14221, 14243,
-        14249, 14251, 14281, 14293, 14303, 14321, 14323, 14327, 14341, 14347, 14369, 14387, 14389,
-        14401, 14407, 14411, 14419, 14423, 14431, 14437, 14447, 14449, 14461, 14479, 14489, 14503,
-        14519, 14533, 14537, 14543, 14549, 14551, 14557, 14561, 14563, 14591, 14593, 14621, 14627,
-        14629, 14633, 14639, 14653, 14657, 14669, 14683, 14699, 14713, 14717, 14723, 14731, 14737,
-        14741, 14747, 14753, 14759, 14767, 14771, 14779, 14783, 14797, 14813, 14821, 14827, 14831,
-        14843, 14851, 14867, 14869, 14879, 14887, 14891, 14897, 14923, 14929, 14939, 14947, 14951,
-        14957, 14969, 14983, 15013, 15017, 15031, 15053, 15061, 15073, 15077, 15083, 15091, 15101,
-        15107, 15121, 15131, 15137, 15139, 15149, 15161, 15173, 15187, 15193, 15199, 15217, 15227,
-        15233, 15241, 15259, 15263, 15269, 15271, 15277, 15287, 15289, 15299, 15307, 15313, 15319,
-        15329, 15331, 15349, 15359, 15361, 15373, 15377, 15383, 15391, 15401, 15413, 15427, 15439,
-        15443, 15451, 15461, 15467, 15473, 15493, 15497, 15511, 15527, 15541, 15551, 15559, 15569,
-        15581, 15583, 15601, 15607, 15619, 15629, 15641, 15643, 15647, 15649, 15661, 15667, 15671,
-        15679, 15683, 15727, 15731, 15733, 15737, 15739, 15749, 15761, 15767, 15773, 15787, 15791,
-        15797, 15803, 15809, 15817, 15823, 15859, 15877, 15881, 15887, 15889, 15901, 15907, 15913,
-        15919, 15923, 15937, 15959, 15971, 15973, 15991, 16001, 16007, 16033, 16057, 16061, 16063,
-        16067, 16069, 16073, 16087, 16091, 16097, 16103, 16111, 16127, 16139, 16141, 16183, 16187,
-        16189, 16193, 16217, 16223, 16229, 16231, 16249, 16253, 16267, 16273, 16301, 16319, 16333,
-        16339, 16349, 16361, 16363, 16369, 16381, 16411, 16417, 16421, 16427, 16433, 16447, 16451,
-        16453, 16477, 16481, 16487, 16493, 16519, 16529, 16547, 16553, 16561, 16567, 16573, 16603,
-        16607, 16619, 16631, 16633, 16649, 16651, 16657, 16661, 16673, 16691, 16693, 16699, 16703,
-        16729, 16741, 16747, 16759, 16763, 16787, 16811, 16823, 16829, 16831, 16843, 16871, 16879,
-        16883, 16889, 16901, 16903, 16921, 16927, 16931, 16937, 16943, 16963, 16979, 16981, 16987,
-        16993, 17011, 17021, 17027, 17029, 17033, 17041, 17047, 17053, 17077, 17093, 17099, 17107,
-        17117, 17123, 17137, 17159, 17167, 17183, 17189, 17191, 17203, 17207, 17209, 17231, 17239,
-        17257, 17291, 17293, 17299, 17317, 17321, 17327, 17333, 17341, 17351, 17359, 17377, 17383,
-        17387, 17389, 17393, 17401, 17417, 17419, 17431, 17443, 17449, 17467, 17471, 17477, 17483,
-        17489, 17491, 17497, 17509, 17519, 17539, 17551, 17569, 17573, 17579, 17581, 17597, 17599,
-        17609, 17623, 17627, 17657, 17659, 17669, 17681, 17683, 17707, 17713, 17729, 17737, 17747,
-        17749, 17761, 17783, 17789, 17791, 17807, 17827, 17837, 17839, 17851, 17863,
-    ];
-    const MAX_SMALL_PRIME: u32 = PRIMES[PRIMES.len() - 1];
 }
 
 #[cfg(test)]

From 5c3252012e8b1aa62bc783bf9800e6b9de23a1b6 Mon Sep 17 00:00:00 2001
From: Denis Varlakov <cordial.egg6523@fastmail.com>
Date: Thu, 15 Oct 2026 17:29:11 +0200
Subject: [PATCH 6/7] Remove accidentaly committed file

Signed-off-by: Denis Varlakov <cordial.egg6523@fastmail.com>
---
 wtf | 5804 -----------------------------------------------------------
 1 file changed, 5804 deletions(-)
 delete mode 100644 wtf

diff --git a/wtf b/wtf
deleted file mode 100644
index fc83cad..0000000
--- a/wtf
+++ /dev/null
@@ -1,5804 +0,0 @@
-    Finished `test` profile [unoptimized + debuginfo] target(s) in 0.02s
-     Running tests/integration/main.rs (target/debug/deps/integration-c561df37baeccefc)
-int: Integer(3159069600019554194022657100715805333242276989416388470653064737629674007777869470792440373876027175134226671041423790281306823148413784356151067460389343712245685356745591710491123)
-arg: Positive(Integer(206081497958678073734815386575575894310383909958715941603467233632150792249101063257532561260528649453960182261739345586155393754341139162240158086606795555731000617981788811718182766856748787203544429733690))
-Some(Integer(93423507563504960316312295000134630188420469667006050911235435093325344616288319452319732751876381485317042107056208056905718863983417986493382792222504508897601941459690883934762582963752356808340771660927)) != Some(Integer(93423507563504960316312295000134630188420469667006050911235435093325344616288319452319732751876381485317042107056208056905718863983417986493382792222504508897601941459690883934762582963752356808340771660927))
-int: Integer(10221746329734546230375257378613832009634233133827215326514562301849953766765895526382284162531535643462121345853344869955959235569398951674216051680484863957087639343087086158941681488393119036189161527421393086399920712651891443)
-arg: Positive(Integer(3399413517900442150942910184795291920732192829452316031624077661009835529710753268449382498245359398))
-Some(Integer(2120960707543514393151060137493651294564627763082492955137191133491796069584493621525678091646893019)) != Some(Integer(2120960707543514393151060137493651294564627763082492955137191133491796069584493621525678091646893019))
-int: Integer(5460397076671608011562212465762501128800092082962227678070857038481917371705723886929866888220889559221723257185751988801873542355248125841254348593761285125331014851185480967555193609744933978496129446)
-arg: Positive(Integer(138906882941471930519049748903594527326338637153097351039980513842293741995211464345523385963660277788876762164281896652926648169663798045857760697600055130493076596997586782136225026))
-None != None
-int: Integer(-33184543787759964141547192377931243097362104517357286649559382613900547816003212155135597275614492205666248473715533007533464107221524615798759049223496669817112)
-arg: Positive(Integer(14080037710595326216833738711196290441991021928920959849913370318739129565261759028555883936778127159558791161157100355018188314146967994667399610757426651955268462728915356007897847780606183))
-Some(Integer(4483997182335513636935299446440704861864627515741900927991939254119061688110748029565584482931649288917284424610634481411751927901750227391213230719510961518391381712444738457002159909774529)) != Some(Integer(4483997182335513636935299446440704861864627515741900927991939254119061688110748029565584482931649288917284424610634481411751927901750227391213230719510961518391381712444738457002159909774529))
-int: Integer(-41845305487048242527472428629543477420453859494995448407044001186156951172997678259170503536502483185201203701298336797244242933170814843531606310796794787582600063961700396827079869104048750305648406228742914208)
-arg: Positive(Integer(13800726014106030846965541426567511455133520865804520836975278792796123037292843772154272654688098743059182840166368300121129499820678666168187870584632121016474384822789069313))
-Some(Integer(12806495751683088886823359772221011999738517286490327309448804196458105010653964344548538555476649074669712142836867896442315161995972142753628165986836792775047042926540196765)) != Some(Integer(12806495751683088886823359772221011999738517286490327309448804196458105010653964344548538555476649074669712142836867896442315161995972142753628165986836792775047042926540196765))
-int: Integer(27271795799987201592887497301064882545106761343013158304999353025767535193474775)
-arg: Positive(Integer(463835802035234651236131736115665619359125963631503708316689035169587009387237968656176023842331282576053638146183015777772705961733373089789208751))
-None != None
-int: Integer(26906551112530404168575405641154124020054492547790053336413104209664)
-arg: Positive(Integer(542328860758127283680220841093200146620184807709594962569542194957830637463903798449520956424744804411530804278961481419943892221034677))
-Some(Integer(149677360758815156746182881403671076543546978646938783435696288708484548968328354650018374112139320667287751760796135183929254416164720)) != Some(Integer(149677360758815156746182881403671076543546978646938783435696288708484548968328354650018374112139320667287751760796135183929254416164720))
-int: Integer(34461165762466966326023278807801936726653841324784171063672902892888033859385086058340903647831870670808160912180501847996923605648455071406721897581853148552001)
-arg: Positive(Integer(128175429627505419221965019167495042393906168511422518105630076507626443295176531538404495498448672768839633829314913155508295205968057679077859991665622168414882))
-Some(Integer(36646266214596208185896324170969704647743748141612282699604292038249478142419290064629075531242468086264038041369833580616690308260722374224167203357424094639343)) != Some(Integer(36646266214596208185896324170969704647743748141612282699604292038249478142419290064629075531242468086264038041369833580616690308260722374224167203357424094639343))
-int: Integer(38700440973167803)
-arg: Positive(Integer(39572705467840112616964131164982426787582095074740603291948682354251866662578651934504137625257163649785093206879371959296715342494534474381187779326436757193514920461153759121))
-Some(Integer(5158318408371568203666235294380078053244212483065513813821264766353963640277893032149503247852203055868376228902623458558814066610709377560034359865435065332747120685999670766)) != Some(Integer(5158318408371568203666235294380078053244212483065513813821264766353963640277893032149503247852203055868376228902623458558814066610709377560034359865435065332747120685999670766))
-int: Integer(2950474297419306914934138189265726706823126913588455670372115625284525590770210273595491841427122193956277114711346270647011539904119296679)
-arg: Positive(Integer(21054894604691820250450794060858377225079617737973140776051244353348206315344661866347367439812411056667462172199428909981680989))
-None != None
-int: Integer(-66062269358461534899196825950973840834406150134114534429885110164711268363578015390945837577926321197204037193874013827635381)
-arg: Positive(Integer(576363513558967636058445759018579240601956155043470077708679554402739322373039314034082324934340216204383851284564368791091547783157296337099968239719188273986804133715993))
-Some(Integer(512607522209711735796967562740788469290605515335467144627471572395800868952493213308377863414894060025500418437276867778399431733007048565967921493048931106323327811178549)) != Some(Integer(512607522209711735796967562740788469290605515335467144627471572395800868952493213308377863414894060025500418437276867778399431733007048565967921493048931106323327811178549))
-int: Integer(-3602243072329606578919234752580778505164609341939343118657261779748800819803815966507018215033)
-arg: Positive(Integer(7703565))
-Some(Integer(1194763)) != Some(Integer(1194763))
-int: Integer(20497377663362627077957629168109826564817633471860361171)
-arg: Positive(Integer(1348664239803045160159622297797768341010581045705862225048410039495691005902994068768893826973485733708949269981693243656405003815633633745198668))
-Some(Integer(572685861681683429289116496648527905261890256253462639647542470960671187797156440944717345147905323478122076278968933395382935024513711178175327)) != Some(Integer(572685861681683429289116496648527905261890256253462639647542470960671187797156440944717345147905323478122076278968933395382935024513711178175327))
-int: Integer(5571382794149580783830577677990556798799078278490130423896390438397454601859485496634273570058264274576707018936906083)
-arg: Positive(Integer(38713016916520294180234606312236980692477604782631299500710970459397481151856895737232673349289190074316095488341))
-None != None
-int: Integer(1082137576163352027699917090319317812538581120566911456250491874000727427885388226391345340853661689936443221015955098275541565344507594557318559109977559530740079820138250863511757941721826171)
-arg: Positive(Integer(35042717255746189560596465682981754546848242444708157058341663351007999830443320156321524945781244368240998643398435491351545969648808702330026330148521030158074869830654654867984450702582413033388))
-None != None
-int: Integer(-2082239090)
-arg: Positive(Integer(118765853491520759494558410130255931822701572091525322631962846587714544159277657209730617389373412650569387657307))
-Some(Integer(38631317333663705118702918201790723894783666589614438612410788214522336885526048878532604995832193773883290434311)) != Some(Integer(38631317333663705118702918201790723894783666589614438612410788214522336885526048878532604995832193773883290434311))
-int: Integer(-10067551596193683895864369517226664416318542590571562320632756698129094765090018166793705515923565420663650915958935581547267311586158127277)
-arg: Positive(Integer(1240168922535564757068481482172291574164105353319268669118692))
-Some(Integer(80914326105274387982619031804221556660076417520523852069607)) != Some(Integer(80914326105274387982619031804221556660076417520523852069607))
-int: Integer(-31670424761379338213086506692723231222948612498481315)
-arg: Positive(Integer(7106274445397153718867332249000004966289930132732251298851526039412597955636503944960286246690231662161892227592069580067461149146699169933405240295745133))
-Some(Integer(884955677979684858483628002872376991810485396462567682123951573868544816927327457843814851190611855462094586698955643910405487099212717415723885393200400)) != Some(Integer(884955677979684858483628002872376991810485396462567682123951573868544816927327457843814851190611855462094586698955643910405487099212717415723885393200400))
-int: Integer(6419235254774732345513740641731385124747023185859798403)
-arg: Positive(Integer(240742183242732361771931716531123208533609222117700613978157932778351331359))
-Some(Integer(38492961043130419821654155711607236467235762433736084548087702012431108219)) != Some(Integer(38492961043130419821654155711607236467235762433736084548087702012431108219))
-int: Integer(-246713932740788889936563735368734547735090064071916849285375244228931543868823719769319041789962713100196872457386160065958412025678445409517135063952756612965101922823382906120302825088650902895959014941167103)
-arg: Positive(Integer(277072196625728))
-Some(Integer(167125734289793)) != Some(Integer(167125734289793))
-int: Integer(948814452951848394277342618377664301334919765662075976492810878349995858957574923018553356173917365493287376746172963544864956946934800632272806380017683818200761532821575402724960065169496653081276363381608)
-arg: Positive(Integer(2034))
-None != None
-int: Integer(-16168394608437904117924073514094334223923957745626389324510034981338574924390093922429888666096736520299904214617404279855363564291263726958526232631227920224261605033619225398896)
-arg: Positive(Integer(3347340325276334559007644929593987306810470207751023195205558136572230))
-None != None
-int: Integer(849907565503714923979626663871490381584604791891727078579767137516077892225265989385255812708041173297743955464647847526964313485068753470826315532975015377017)
-arg: Positive(Integer(1195132094896773060594118429808457016217587796178858275226162781873326431234945011873031693910223025548739874356322552633317587550777023148531813))
-Some(Integer(598616922528068633999600187547208226765804537707494243674237091778872609437533047640256271433421137669291897375062618960986623105625432954691494)) != Some(Integer(598616922528068633999600187547208226765804537707494243674237091778872609437533047640256271433421137669291897375062618960986623105625432954691494))
-int: Integer(-186)
-arg: Positive(Integer(114726413728427911834441))
-Some(Integer(11719364843226507122873)) != Some(Integer(11719364843226507122873))
-int: Integer(-390390869688902702176657554058378944771722268032838764912084454210764721773919081458107923955155872364890588875683107108986962625842749392523820320208058903628956392008842305371818737540071744058445861535165033618960912519274817316)
-arg: Positive(Integer(15360328573537092650100332669426833233476950167815017621629298825086574246424600263526429297164507674138350648746786765029824367046093091572868661780552717258097820595563355566099840606245456))
-None != None
-int: Integer(10174341165738932342387363679570036508429775439071809223720863944576451056115222819803682748930829171854836284937773021100778556581)
-arg: Positive(Integer(129265709558294514425459647752255033389575722259725960158493617674079370289440024301002259375307235080241292240696))
-Some(Integer(8105462231193088830528263192161098914557990480593133710371816456217023963978498348463399777596241315073174770085)) != Some(Integer(8105462231193088830528263192161098914557990480593133710371816456217023963978498348463399777596241315073174770085))
-int: Integer(30398756336183572)
-arg: Positive(Integer(14535850803766979963696456633744742114414306488304396488712824365943173247427))
-Some(Integer(12121822423061820432740745065509456963494140032265739437232031636006592329018)) != Some(Integer(12121822423061820432740745065509456963494140032265739437232031636006592329018))
-int: Integer(2770268300122623958844669338478999746346835753606256532123541008993738881457634415494505448057684904025654203938061768302465874148555461079412810828850685)
-arg: Positive(Integer(10209907653059288723416799384211166491985792911056197015112741562597792589550631414997547921592840885266765929485322683156970218509979226096624885586811125511273182122604016100223880762555871147117731))
-Some(Integer(6573723871986790912042561761495906841510882400663590740185024165477230209658294212479997266344462153346303874794575714904699211461370996589103752513352560629433357162272316483819202396507851868468791)) != Some(Integer(6573723871986790912042561761495906841510882400663590740185024165477230209658294212479997266344462153346303874794575714904699211461370996589103752513352560629433357162272316483819202396507851868468791))
-int: Integer(-3341767896999213630105660438464793802363970368051299565778950301018993769411244946681815888937629457091863564195134610152260238650692583912807593387655231590)
-arg: Positive(Integer(41764792852333410613574057691314017919685))
-None != None
-int: Integer(-1114980562394482451793290722800104352459394864827146975363501905158787262104367173173702236328705014823989842999081060311047379538147863315260457274737999450395426560898811821358366403242984514054174654893926783048028289)
-arg: Positive(Integer(92454014208295604012257077639200854384470285576963206368091818051099095359131728963007429))
-Some(Integer(60764927440221551848018324605630580928185191576353686313120306568607082814675681902323724)) != Some(Integer(60764927440221551848018324605630580928185191576353686313120306568607082814675681902323724))
-int: Integer(-4796)
-arg: Positive(Integer(501865570767534837787609078394589614759996744443))
-Some(Integer(169416255019315867885350103820025143097671961896)) != Some(Integer(169416255019315867885350103820025143097671961896))
-int: Integer(-5870818593143744454376804707063447104071516078576702456474309983843020981483384611)
-arg: Positive(Integer(87721041152673869540287225086369263172326266784032316094739615440526157576615855054770658))
-Some(Integer(44637766433422062746469262499585559067595108316018581528779660922477864420411882289835139)) != Some(Integer(44637766433422062746469262499585559067595108316018581528779660922477864420411882289835139))
-int: Integer(-8645950250668392342139710370195996604997133356279154995790606110025001403913568349429804391285983563617167606274216975227835027307)
-arg: Positive(Integer(384540926406690398126308887563696068983060261397243304150047787544284088485376639988699711945401314371474843154668485431005749360339666322077885964417814608447475728203301335))
-Some(Integer(235967098619580031997317623628085655181726099440804850677407437125486105447382881635794389301106424883995402160478548797864141341311017004099791284144218426616183450448312622)) != Some(Integer(235967098619580031997317623628085655181726099440804850677407437125486105447382881635794389301106424883995402160478548797864141341311017004099791284144218426616183450448312622))
-int: Integer(1364874660907080121974129992371799337612453216916918930212933558109242696057708391675823950242458405289224359968507480026920560051966186653720119568991513854986276899085992980872802472221909916413456022080)
-arg: Positive(Integer(28329))
-Some(Integer(10190)) != Some(Integer(10190))
-int: Integer(-240305332163314943181965740995915040048568713451930817440419950695131891564696061142676948754901911330418575843615499209772583335443144122133599524834567961494019096716964990748128869651011988383787723044760845)
-arg: Positive(Integer(4422715720747481363411982175104340274945623840457652234093178029327))
-Some(Integer(1939208606340475414041419049171086708767148933497508159286612301618)) != Some(Integer(1939208606340475414041419049171086708767148933497508159286612301618))
-int: Integer(3203720193)
-arg: Positive(Integer(13571144027725908176055114266155464712540155817579840213624684513698500343435193642507573002828360888342686448614495619155732179026198005757394896667930512333513701285845688057977320083433834558958785795159025258))
-Some(Integer(12201666119562127723527684374231026524691511516349101852486470104417452329374626038093526886399264659419823059811203307854627368714124464316629017186507998429579672360910265822948358012356780627147585509490734591)) != Some(Integer(12201666119562127723527684374231026524691511516349101852486470104417452329374626038093526886399264659419823059811203307854627368714124464316629017186507998429579672360910265822948358012356780627147585509490734591))
-int: Integer(-3858712345482550262411596779496159435534961958615997789472829281416094967515277125633583939995106348829119483497456369743609081328892523788875952765810843809437851247440369560025746916516599739251193661348)
-arg: Positive(Integer(2358530444869944859624237040958114797788819662))
-None != None
-int: Integer(-1539824474755942853972315343432935729353453981124323470350429900355411699234972190337673746569824096137184704785947570536074458820778351975220871223036680733464485775886250657514876937166101225007815975977302577097045518539624848385)
-arg: Positive(Integer(84911590590585868905827084684512333701154451747246484049868771973544677668507540401355303102113353043924533979394546684482495542543904466076399641320628373182535407213260398789360723788435223674960718408105229488778877581590567565))
-None != None
-int: Integer(2463647562996069975557609917346160742740875851883)
-arg: Positive(Integer(11051336058744460015404700188550566995989931121856061341589997612766988324874943781412932528864231645015596727823679896605583580566582167855000968311083105065803291))
-Some(Integer(6183293502570041664365767574228984615676691119054456940149843035898195077269817500479716592692323154292234890577021027066128504404842104927844063915277745136740630)) != Some(Integer(6183293502570041664365767574228984615676691119054456940149843035898195077269817500479716592692323154292234890577021027066128504404842104927844063915277745136740630))
-int: Integer(7143754863084967822610043518099229895532294247863381553314707183747030424133013082727977992812939653915295)
-arg: Positive(Integer(208089849253932409075428087697322672321))
-Some(Integer(47210419647845304730637299871214452773)) != Some(Integer(47210419647845304730637299871214452773))
-int: Integer(28593)
-arg: Positive(Integer(391002586936467005327517266301459957376714080112798832375277122995336249147))
-Some(Integer(347133937305711710217151953452333124121564261310929191055377531816759720372)) != Some(Integer(347133937305711710217151953452333124121564261310929191055377531816759720372))
-int: Integer(25270079899826701722072362511296634357940911355081500142589320447073)
-arg: Positive(Integer(24317614292755115116441621217452904224323780761714252716902643733782555223337455003339638423))
-Some(Integer(20311811466080159125069044588138414849377687371471854139516369579863644100699940766404825494)) != Some(Integer(20311811466080159125069044588138414849377687371471854139516369579863644100699940766404825494))
-int: Integer(394279319633404754616398114092771510525215657615080889280797160723170698732584132176915852379507242464498818058887953344110977618903163483967143738)
-arg: Positive(Integer(7146781421251534484433336993432755805247824106888285254862002895071688998402953723249018252653925066192639324996247194441413901269432967708906749688117972636329961265141231189063557653966026954984086922336920076423))
-Some(Integer(4037334062613706924808288353204029125154237377742058401692265951221664301109194721423277248888437586085384017376579407199970018845210534989206461737372178995732337909136119202041031875935386512420355414502730416254)) != Some(Integer(4037334062613706924808288353204029125154237377742058401692265951221664301109194721423277248888437586085384017376579407199970018845210534989206461737372178995732337909136119202041031875935386512420355414502730416254))
-int: Integer(114026187583626693619621340381869516474146588025102349870522686955022751684382673551134627390291947797634530154832158100314212864204405706497639386598)
-arg: Positive(Integer(92309301655988213590065644357096531476631359029576727737682461164411520701986100975208372513786260202271519928626719403575906900644929007987741227642847390476044852154410022228231196577279778713244381536292156065717251650486))
-None != None
-int: Integer(245210765531991452411101527979744164481254541098483498652209339580532527788200786884221823757684473351913281323167819976116326183569948495578665037569165826505187784756393774825216753542032615137862595418300757832694828800)
-arg: Positive(Integer(1599766612000048246717469574076693455348347928507311222156978108748025566303608379558592654145972797343654063979459177606744021992235))
-None != None
-int: Integer(-165343642150967075443842761513472182874424147146559288926014200301720139323764337140895298913484048961363697660579524526678468129767898595)
-arg: Positive(Integer(127544029195856473224883723271588829338650847531242728138562437831803386449861423124548096301143291463342141946397852867293022183160746085006564843173718344887543))
-Some(Integer(125187475714951339812407485478599277580212899858900509084494788210907941838327899473801667877826324501612930892817928503405071386880368126391668613098037175268152)) != Some(Integer(125187475714951339812407485478599277580212899858900509084494788210907941838327899473801667877826324501612930892817928503405071386880368126391668613098037175268152))
-int: Integer(89666965096574798428361427616112493133921355383040118620906726608648057246971619603900928)
-arg: Positive(Integer(32524152053946078886863739600040665443396704194726032407302485769057647997751106938526571923701935612050198965524571825479214624578750222228274054448581))
-Some(Integer(17432900293427674777018959312392680064961614303331734165663056677228254327545030974985164168177960088200421449589038576951027601433703780051223314630615)) != Some(Integer(17432900293427674777018959312392680064961614303331734165663056677228254327545030974985164168177960088200421449589038576951027601433703780051223314630615))
-int: Integer(-12274440753993629404668076066759262423337001728061613443224467082021986082685237268883501110776319030415786548335652410875876754702230632347124548018009404455822397159348005053497549231914344)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-6137220376996814702334038033379631211668500864030806721612233541010993041342618634441750555388159515207893274167826205437938377351115316173562274009004702227911198579674002526748774615957172)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3068610188498407351167019016689815605834250432015403360806116770505496520671309317220875277694079757603946637083913102718969188675557658086781137004502351113955599289837001263374387307978586)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1534305094249203675583509508344907802917125216007701680403058385252748260335654658610437638847039878801973318541956551359484594337778829043390568502251175556977799644918500631687193653989293)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-767152547124601837791754754172453901458562608003850840201529192626374130167827329305218819423519939400986659270978275679742297168889414521695284251125587778488899822459250315843596826994647)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-383576273562300918895877377086226950729281304001925420100764596313187065083913664652609409711759969700493329635489137839871148584444707260847642125562793889244449911229625157921798413497324)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-191788136781150459447938688543113475364640652000962710050382298156593532541956832326304704855879984850246664817744568919935574292222353630423821062781396944622224955614812578960899206748662)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-95894068390575229723969344271556737682320326000481355025191149078296766270978416163152352427939992425123332408872284459967787146111176815211910531390698472311112477807406289480449603374331)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-47947034195287614861984672135778368841160163000240677512595574539148383135489208081576176213969996212561666204436142229983893573055588407605955265695349236155556238903703144740224801687166)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-23973517097643807430992336067889184420580081500120338756297787269574191567744604040788088106984998106280833102218071114991946786527794203802977632847674618077778119451851572370112400843583)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-11986758548821903715496168033944592210290040750060169378148893634787095783872302020394044053492499053140416551109035557495973393263897101901488816423837309038889059725925786185056200421792)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5993379274410951857748084016972296105145020375030084689074446817393547891936151010197022026746249526570208275554517778747986696631948550950744408211918654519444529862962893092528100210896)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2996689637205475928874042008486148052572510187515042344537223408696773945968075505098511013373124763285104137777258889373993348315974275475372204105959327259722264931481446546264050105448)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1498344818602737964437021004243074026286255093757521172268611704348386972984037752549255506686562381642552068888629444686996674157987137737686102052979663629861132465740723273132025052724)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-749172409301368982218510502121537013143127546878760586134305852174193486492018876274627753343281190821276034444314722343498337078993568868843051026489831814930566232870361636566012526362)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-374586204650684491109255251060768506571563773439380293067152926087096743246009438137313876671640595410638017222157361171749168539496784434421525513244915907465283116435180818283006263181)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-187293102325342245554627625530384253285781886719690146533576463043548371623004719068656938335820297705319008611078680585874584269748392217210762756622457953732641558217590409141503131591)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-93646551162671122777313812765192126642890943359845073266788231521774185811502359534328469167910148852659504305539340292937292134874196108605381378311228976866320779108795204570751565796)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-46823275581335561388656906382596063321445471679922536633394115760887092905751179767164234583955074426329752152769670146468646067437098054302690689155614488433160389554397602285375782898)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-23411637790667780694328453191298031660722735839961268316697057880443546452875589883582117291977537213164876076384835073234323033718549027151345344577807244216580194777198801142687891449)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-11705818895333890347164226595649015830361367919980634158348528940221773226437794941791058645988768606582438038192417536617161516859274513575672672288903622108290097388599400571343945725)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5852909447666945173582113297824507915180683959990317079174264470110886613218897470895529322994384303291219019096208768308580758429637256787836336144451811054145048694299700285671972863)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2926454723833472586791056648912253957590341979995158539587132235055443306609448735447764661497192151645609509548104384154290379214818628393918168072225905527072524347149850142835986432)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1463227361916736293395528324456126978795170989997579269793566117527721653304724367723882330748596075822804754774052192077145189607409314196959084036112952763536262173574925071417993216)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-731613680958368146697764162228063489397585494998789634896783058763860826652362183861941165374298037911402377387026096038572594803704657098479542018056476381768131086787462535708996608)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-365806840479184073348882081114031744698792747499394817448391529381930413326181091930970582687149018955701188693513048019286297401852328549239771009028238190884065543393731267854498304)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-182903420239592036674441040557015872349396373749697408724195764690965206663090545965485291343574509477850594346756524009643148700926164274619885504514119095442032771696865633927249152)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-91451710119796018337220520278507936174698186874848704362097882345482603331545272982742645671787254738925297173378262004821574350463082137309942752257059547721016385848432816963624576)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-45725855059898009168610260139253968087349093437424352181048941172741301665772636491371322835893627369462648586689131002410787175231541068654971376128529773860508192924216408481812288)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-22862927529949004584305130069626984043674546718712176090524470586370650832886318245685661417946813684731324293344565501205393587615770534327485688064264886930254096462108204240906144)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-11431463764974502292152565034813492021837273359356088045262235293185325416443159122842830708973406842365662146672282750602696793807885267163742844032132443465127048231054102120453072)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5715731882487251146076282517406746010918636679678044022631117646592662708221579561421415354486703421182831073336141375301348396903942633581871422016066221732563524115527051060226536)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2857865941243625573038141258703373005459318339839022011315558823296331354110789780710707677243351710591415536668070687650674198451971316790935711008033110866281762057763525530113268)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1428932970621812786519070629351686502729659169919511005657779411648165677055394890355353838621675855295707768334035343825337099225985658395467855504016555433140881028881762765056634)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-714466485310906393259535314675843251364829584959755502828889705824082838527697445177676919310837927647853884167017671912668549612992829197733927752008277716570440514440881382528317)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-357233242655453196629767657337921625682414792479877751414444852912041419263848722588838459655418963823926942083508835956334274806496414598866963876004138858285220257220440691264159)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-178616621327726598314883828668960812841207396239938875707222426456020709631924361294419229827709481911963471041754417978167137403248207299433481938002069429142610128610220345632080)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-89308310663863299157441914334480406420603698119969437853611213228010354815962180647209614913854740955981735520877208989083568701624103649716740969001034714571305064305110172816040)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-44654155331931649578720957167240203210301849059984718926805606614005177407981090323604807456927370477990867760438604494541784350812051824858370484500517357285652532152555086408020)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-22327077665965824789360478583620101605150924529992359463402803307002588703990545161802403728463685238995433880219302247270892175406025912429185242250258678642826266076277543204010)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-11163538832982912394680239291810050802575462264996179731701401653501294351995272580901201864231842619497716940109651123635446087703012956214592621125129339321413133038138771602005)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5581769416491456197340119645905025401287731132498089865850700826750647175997636290450600932115921309748858470054825561817723043851506478107296310562564669660706566519069385801003)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2790884708245728098670059822952512700643865566249044932925350413375323587998818145225300466057960654874429235027412780908861521925753239053648155281282334830353283259534692900502)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1395442354122864049335029911476256350321932783124522466462675206687661793999409072612650233028980327437214617513706390454430760962876619526824077640641167415176641629767346450251)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-697721177061432024667514955738128175160966391562261233231337603343830896999704536306325116514490163718607308756853195227215380481438309763412038820320583707588320814883673225126)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-348860588530716012333757477869064087580483195781130616615668801671915448499852268153162558257245081859303654378426597613607690240719154881706019410160291853794160407441836612563)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-174430294265358006166878738934532043790241597890565308307834400835957724249926134076581279128622540929651827189213298806803845120359577440853009705080145926897080203720918306282)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-87215147132679003083439369467266021895120798945282654153917200417978862124963067038290639564311270464825913594606649403401922560179788720426504852540072963448540101860459153141)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-43607573566339501541719684733633010947560399472641327076958600208989431062481533519145319782155635232412956797303324701700961280089894360213252426270036481724270050930229576571)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-21803786783169750770859842366816505473780199736320663538479300104494715531240766759572659891077817616206478398651662350850480640044947180106626213135018240862135025465114788286)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-10901893391584875385429921183408252736890099868160331769239650052247357765620383379786329945538908808103239199325831175425240320022473590053313106567509120431067512732557394143)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5450946695792437692714960591704126368445049934080165884619825026123678882810191689893164972769454404051619599662915587712620160011236795026656553283754560215533756366278697072)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2725473347896218846357480295852063184222524967040082942309912513061839441405095844946582486384727202025809799831457793856310080005618397513328276641877280107766878183139348536)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1362736673948109423178740147926031592111262483520041471154956256530919720702547922473291243192363601012904899915728896928155040002809198756664138320938640053883439091569674268)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-681368336974054711589370073963015796055631241760020735577478128265459860351273961236645621596181800506452449957864448464077520001404599378332069160469320026941719545784837134)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-340684168487027355794685036981507898027815620880010367788739064132729930175636980618322810798090900253226224978932224232038760000702299689166034580234660013470859772892418567)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-170342084243513677897342518490753949013907810440005183894369532066364965087818490309161405399045450126613112489466112116019380000351149844583017290117330006735429886446209284)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-85171042121756838948671259245376974506953905220002591947184766033182482543909245154580702699522725063306556244733056058009690000175574922291508645058665003367714943223104642)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-42585521060878419474335629622688487253476952610001295973592383016591241271954622577290351349761362531653278122366528029004845000087787461145754322529332501683857471611552321)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-21292760530439209737167814811344243626738476305000647986796191508295620635977311288645175674880681265826639061183264014502422500043893730572877161264666250841928735805776161)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-10646380265219604868583907405672121813369238152500323993398095754147810317988655644322587837440340632913319530591632007251211250021946865286438580632333125420964367902888081)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5323190132609802434291953702836060906684619076250161996699047877073905158994327822161293918720170316456659765295816003625605625010973432643219290316166562710482183951444041)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2661595066304901217145976851418030453342309538125080998349523938536952579497163911080646959360085158228329882647908001812802812505486716321609645158083281355241091975722021)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1330797533152450608572988425709015226671154769062540499174761969268476289748581955540323479680042579114164941323954000906401406252743358160804822579041640677620545987861011)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-665398766576225304286494212854507613335577384531270249587380984634238144874290977770161739840021289557082470661977000453200703126371679080402411289520820338810272993930506)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-332699383288112652143247106427253806667788692265635124793690492317119072437145488885080869920010644778541235330988500226600351563185839540201205644760410169405136496965253)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-166349691644056326071623553213626903333894346132817562396845246158559536218572744442540434960005322389270617665494250113300175781592919770100602822380205084702568248482627)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-83174845822028163035811776606813451666947173066408781198422623079279768109286372221270217480002661194635308832747125056650087890796459885050301411190102542351284124241314)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-41587422911014081517905888303406725833473586533204390599211311539639884054643186110635108740001330597317654416373562528325043945398229942525150705595051271175642062120657)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-20793711455507040758952944151703362916736793266602195299605655769819942027321593055317554370000665298658827208186781264162521972699114971262575352797525635587821031060329)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-10396855727753520379476472075851681458368396633301097649802827884909971013660796527658777185000332649329413604093390632081260986349557485631287676398762817793910515530165)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5198427863876760189738236037925840729184198316650548824901413942454985506830398263829388592500166324664706802046695316040630493174778742815643838199381408896955257765083)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2599213931938380094869118018962920364592099158325274412450706971227492753415199131914694296250083162332353401023347658020315246587389371407821919099690704448477628882542)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1299606965969190047434559009481460182296049579162637206225353485613746376707599565957347148125041581166176700511673829010157623293694685703910959549845352224238814441271)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-649803482984595023717279504740730091148024789581318603112676742806873188353799782978673574062520790583088350255836914505078811646847342851955479774922676112119407220636)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-324901741492297511858639752370365045574012394790659301556338371403436594176899891489336787031260395291544175127918457252539405823423671425977739887461338056059703610318)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-162450870746148755929319876185182522787006197395329650778169185701718297088449945744668393515630197645772087563959228626269702911711835712988869943730669028029851805159)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-81225435373074377964659938092591261393503098697664825389084592850859148544224972872334196757815098822886043781979614313134851455855917856494434971865334514014925902580)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-40612717686537188982329969046295630696751549348832412694542296425429574272112486436167098378907549411443021890989807156567425727927958928247217485932667257007462951290)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-20306358843268594491164984523147815348375774674416206347271148212714787136056243218083549189453774705721510945494903578283712863963979464123608742966333628503731475645)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-10153179421634297245582492261573907674187887337208103173635574106357393568028121609041774594726887352860755472747451789141856431981989732061804371483166814251865737823)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5076589710817148622791246130786953837093943668604051586817787053178696784014060804520887297363443676430377736373725894570928215990994866030902185741583407125932868912)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2538294855408574311395623065393476918546971834302025793408893526589348392007030402260443648681721838215188868186862947285464107995497433015451092870791703562966434456)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1269147427704287155697811532696738459273485917151012896704446763294674196003515201130221824340860919107594434093431473642732053997748716507725546435395851781483217228)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-634573713852143577848905766348369229636742958575506448352223381647337098001757600565110912170430459553797217046715736821366026998874358253862773217697925890741608614)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-317286856926071788924452883174184614818371479287753224176111690823668549000878800282555456085215229776898608523357868410683013499437179126931386608848962945370804307)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-158643428463035894462226441587092307409185739643876612088055845411834274500439400141277728042607614888449304261678934205341506749718589563465693304424481472685402154)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-79321714231517947231113220793546153704592869821938306044027922705917137250219700070638864021303807444224652130839467102670753374859294781732846652212240736342701077)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-39660857115758973615556610396773076852296434910969153022013961352958568625109850035319432010651903722112326065419733551335376687429647390866423326106120368171350539)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-19830428557879486807778305198386538426148217455484576511006980676479284312554925017659716005325951861056163032709866775667688343714823695433211663053060184085675270)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-9915214278939743403889152599193269213074108727742288255503490338239642156277462508829858002662975930528081516354933387833844171857411847716605831526530092042837635)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4957607139469871701944576299596634606537054363871144127751745169119821078138731254414929001331487965264040758177466693916922085928705923858302915763265046021418818)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2478803569734935850972288149798317303268527181935572063875872584559910539069365627207464500665743982632020379088733346958461042964352961929151457881632523010709409)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1239401784867467925486144074899158651634263590967786031937936292279955269534682813603732250332871991316010189544366673479230521482176480964575728940816261505354705)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-619700892433733962743072037449579325817131795483893015968968146139977634767341406801866125166435995658005094772183336739615260741088240482287864470408130752677353)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-309850446216866981371536018724789662908565897741946507984484073069988817383670703400933062583217997829002547386091668369807630370544120241143932235204065376338677)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-154925223108433490685768009362394831454282948870973253992242036534994408691835351700466531291608998914501273693045834184903815185272060120571966117602032688169339)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-77462611554216745342884004681197415727141474435486626996121018267497204345917675850233265645804499457250636846522917092451907592636030060285983058801016344084670)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-38731305777108372671442002340598707863570737217743313498060509133748602172958837925116632822902249728625318423261458546225953796318015030142991529400508172042335)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-19365652888554186335721001170299353931785368608871656749030254566874301086479418962558316411451124864312659211630729273112976898159007515071495764700254086021168)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-9682826444277093167860500585149676965892684304435828374515127283437150543239709481279158205725562432156329605815364636556488449079503757535747882350127043010584)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4841413222138546583930250292574838482946342152217914187257563641718575271619854740639579102862781216078164802907682318278244224539751878767873941175063521505292)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2420706611069273291965125146287419241473171076108957093628781820859287635809927370319789551431390608039082401453841159139122112269875939383936970587531760752646)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1210353305534636645982562573143709620736585538054478546814390910429643817904963685159894775715695304019541200726920579569561056134937969691968485293765880376323)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-605176652767318322991281286571854810368292769027239273407195455214821908952481842579947387857847652009770600363460289784780528067468984845984242646882940188162)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-302588326383659161495640643285927405184146384513619636703597727607410954476240921289973693928923826004885300181730144892390264033734492422992121323441470094081)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-151294163191829580747820321642963702592073192256809818351798863803705477238120460644986846964461913002442650090865072446195132016867246211496060661720735047041)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-75647081595914790373910160821481851296036596128404909175899431901852738619060230322493423482230956501221325045432536223097566008433623105748030330860367523521)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-37823540797957395186955080410740925648018298064202454587949715950926369309530115161246711741115478250610662522716268111548783004216811552874015165430183761761)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-18911770398978697593477540205370462824009149032101227293974857975463184654765057580623355870557739125305331261358134055774391502108405776437007582715091880881)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-9455885199489348796738770102685231412004574516050613646987428987731592327382528790311677935278869562652665630679067027887195751054202888218503791357545940441)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4727942599744674398369385051342615706002287258025306823493714493865796163691264395155838967639434781326332815339533513943597875527101444109251895678772970221)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2363971299872337199184692525671307853001143629012653411746857246932898081845632197577919483819717390663166407669766756971798937763550722054625947839386485111)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1181985649936168599592346262835653926500571814506326705873428623466449040922816098788959741909858695331583203834883378485899468881775361027312973919693242556)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-590992824968084299796173131417826963250285907253163352936714311733224520461408049394479870954929347665791601917441689242949734440887680513656486959846621278)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-295496412484042149898086565708913481625142953626581676468357155866612260230704024697239935477464673832895800958720844621474867220443840256828243479923310639)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-147748206242021074949043282854456740812571476813290838234178577933306130115352012348619967738732336916447900479360422310737433610221920128414121739961655320)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-73874103121010537474521641427228370406285738406645419117089288966653065057676006174309983869366168458223950239680211155368716805110960064207060869980827660)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-36937051560505268737260820713614185203142869203322709558544644483326532528838003087154991934683084229111975119840105577684358402555480032103530434990413830)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-18468525780252634368630410356807092601571434601661354779272322241663266264419001543577495967341542114555987559920052788842179201277740016051765217495206915)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-9234262890126317184315205178403546300785717300830677389636161120831633132209500771788747983670771057277993779960026394421089600638870008025882608747603458)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4617131445063158592157602589201773150392858650415338694818080560415816566104750385894373991835385528638996889980013197210544800319435004012941304373801729)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2308565722531579296078801294600886575196429325207669347409040280207908283052375192947186995917692764319498444990006598605272400159717502006470652186900865)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1154282861265789648039400647300443287598214662603834673704520140103954141526187596473593497958846382159749222495003299302636200079858751003235326093450433)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-577141430632894824019700323650221643799107331301917336852260070051977070763093798236796748979423191079874611247501649651318100039929375501617663046725217)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-288570715316447412009850161825110821899553665650958668426130035025988535381546899118398374489711595539937305623750824825659050019964687750808831523362609)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-144285357658223706004925080912555410949776832825479334213065017512994267690773449559199187244855797769968652811875412412829525009982343875404415761681305)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-72142678829111853002462540456277705474888416412739667106532508756497133845386724779599593622427898884984326405937706206414762504991171937702207880840653)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-36071339414555926501231270228138852737444208206369833553266254378248566922693362389799796811213949442492163202968853103207381252495585968851103940420327)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-18035669707277963250615635114069426368722104103184916776633127189124283461346681194899898405606974721246081601484426551603690626247792984425551970210164)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-9017834853638981625307817557034713184361052051592458388316563594562141730673340597449949202803487360623040800742213275801845313123896492212775985105082)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4508917426819490812653908778517356592180526025796229194158281797281070865336670298724974601401743680311520400371106637900922656561948246106387992552541)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2254458713409745406326954389258678296090263012898114597079140898640535432668335149362487300700871840155760200185553318950461328280974123053193996276271)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1127229356704872703163477194629339148045131506449057298539570449320267716334167574681243650350435920077880100092776659475230664140487061526596998138136)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-563614678352436351581738597314669574022565753224528649269785224660133858167083787340621825175217960038940050046388329737615332070243530763298499069068)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-281807339176218175790869298657334787011282876612264324634892612330066929083541893670310912587608980019470025023194164868807666035121765381649249534534)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-140903669588109087895434649328667393505641438306132162317446306165033464541770946835155456293804490009735012511597082434403833017560882690824624767267)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-70451834794054543947717324664333696752820719153066081158723153082516732270885473417577728146902245004867506255798541217201916508780441345412312383634)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-35225917397027271973858662332166848376410359576533040579361576541258366135442736708788864073451122502433753127899270608600958254390220672706156191817)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-17612958698513635986929331166083424188205179788266520289680788270629183067721368354394432036725561251216876563949635304300479127195110336353078095909)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-8806479349256817993464665583041712094102589894133260144840394135314591533860684177197216018362780625608438281974817652150239563597555168176539047955)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4403239674628408996732332791520856047051294947066630072420197067657295766930342088598608009181390312804219140987408826075119781798777584088269523978)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2201619837314204498366166395760428023525647473533315036210098533828647883465171044299304004590695156402109570493704413037559890899388792044134761989)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1100809918657102249183083197880214011762823736766657518105049266914323941732585522149652002295347578201054785246852206518779945449694396022067380995)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-550404959328551124591541598940107005881411868383328759052524633457161970866292761074826001147673789100527392623426103259389972724847198011033690498)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-275202479664275562295770799470053502940705934191664379526262316728580985433146380537413000573836894550263696311713051629694986362423599005516845249)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-137601239832137781147885399735026751470352967095832189763131158364290492716573190268706500286918447275131848155856525814847493181211799502758422625)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-68800619916068890573942699867513375735176483547916094881565579182145246358286595134353250143459223637565924077928262907423746590605899751379211313)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-34400309958034445286971349933756687867588241773958047440782789591072623179143297567176625071729611818782962038964131453711873295302949875689605657)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-17200154979017222643485674966878343933794120886979023720391394795536311589571648783588312535864805909391481019482065726855936647651474937844802829)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-8600077489508611321742837483439171966897060443489511860195697397768155794785824391794156267932402954695740509741032863427968323825737468922401415)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4300038744754305660871418741719585983448530221744755930097848698884077897392912195897078133966201477347870254870516431713984161912868734461200708)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2150019372377152830435709370859792991724265110872377965048924349442038948696456097948539066983100738673935127435258215856992080956434367230600354)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1075009686188576415217854685429896495862132555436188982524462174721019474348228048974269533491550369336967563717629107928496040478217183615300177)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-537504843094288207608927342714948247931066277718094491262231087360509737174114024487134766745775184668483781858814553964248020239108591807650089)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-268752421547144103804463671357474123965533138859047245631115543680254868587057012243567383372887592334241890929407276982124010119554295903825045)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-134376210773572051902231835678737061982766569429523622815557771840127434293528506121783691686443796167120945464703638491062005059777147951912523)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-67188105386786025951115917839368530991383284714761811407778885920063717146764253060891845843221898083560472732351819245531002529888573975956262)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-33594052693393012975557958919684265495691642357380905703889442960031858573382126530445922921610949041780236366175909622765501264944286987978131)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-16797026346696506487778979459842132747845821178690452851944721480015929286691063265222961460805474520890118183087954811382750632472143493989066)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-8398513173348253243889489729921066373922910589345226425972360740007964643345531632611480730402737260445059091543977405691375316236071746994533)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4199256586674126621944744864960533186961455294672613212986180370003982321672765816305740365201368630222529545771988702845687658118035873497267)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2099628293337063310972372432480266593480727647336306606493090185001991160836382908152870182600684315111264772885994351422843829059017936748634)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1049814146668531655486186216240133296740363823668153303246545092500995580418191454076435091300342157555632386442997175711421914529508968374317)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-524907073334265827743093108120066648370181911834076651623272546250497790209095727038217545650171078777816193221498587855710957264754484187159)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-262453536667132913871546554060033324185090955917038325811636273125248895104547863519108772825085539388908096610749293927855478632377242093580)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-131226768333566456935773277030016662092545477958519162905818136562624447552273931759554386412542769694454048305374646963927739316188621046790)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-65613384166783228467886638515008331046272738979259581452909068281312223776136965879777193206271384847227024152687323481963869658094310523395)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-32806692083391614233943319257504165523136369489629790726454534140656111888068482939888596603135692423613512076343661740981934829047155261698)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-16403346041695807116971659628752082761568184744814895363227267070328055944034241469944298301567846211806756038171830870490967414523577630849)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-8201673020847903558485829814376041380784092372407447681613633535164027972017120734972149150783923105903378019085915435245483707261788815425)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4100836510423951779242914907188020690392046186203723840806816767582013986008560367486074575391961552951689009542957717622741853630894407713)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2050418255211975889621457453594010345196023093101861920403408383791006993004280183743037287695980776475844504771478858811370926815447203857)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1025209127605987944810728726797005172598011546550930960201704191895503496502140091871518643847990388237922252385739429405685463407723601929)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-512604563802993972405364363398502586299005773275465480100852095947751748251070045935759321923995194118961126192869714702842731703861800965)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-256302281901496986202682181699251293149502886637732740050426047973875874125535022967879660961997597059480563096434857351421365851930900483)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-128151140950748493101341090849625646574751443318866370025213023986937937062767511483939830480998798529740281548217428675710682925965450242)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-64075570475374246550670545424812823287375721659433185012606511993468968531383755741969915240499399264870140774108714337855341462982725121)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-32037785237687123275335272712406411643687860829716592506303255996734484265691877870984957620249699632435070387054357168927670731491362561)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-16018892618843561637667636356203205821843930414858296253151627998367242132845938935492478810124849816217535193527178584463835365745681281)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-8009446309421780818833818178101602910921965207429148126575813999183621066422969467746239405062424908108767596763589292231917682872840641)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4004723154710890409416909089050801455460982603714574063287906999591810533211484733873119702531212454054383798381794646115958841436420321)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2002361577355445204708454544525400727730491301857287031643953499795905266605742366936559851265606227027191899190897323057979420718210161)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1001180788677722602354227272262700363865245650928643515821976749897952633302871183468279925632803113513595949595448661528989710359105081)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-500590394338861301177113636131350181932622825464321757910988374948976316651435591734139962816401556756797974797724330764494855179552541)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-250295197169430650588556818065675090966311412732160878955494187474488158325717795867069981408200778378398987398862165382247427589776271)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-125147598584715325294278409032837545483155706366080439477747093737244079162858897933534990704100389189199493699431082691123713794888136)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-62573799292357662647139204516418772741577853183040219738873546868622039581429448966767495352050194594599746849715541345561856897444068)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-31286899646178831323569602258209386370788926591520109869436773434311019790714724483383747676025097297299873424857770672780928448722034)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-15643449823089415661784801129104693185394463295760054934718386717155509895357362241691873838012548648649936712428885336390464224361017)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-7821724911544707830892400564552346592697231647880027467359193358577754947678681120845936919006274324324968356214442668195232112180509)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3910862455772353915446200282276173296348615823940013733679596679288877473839340560422968459503137162162484178107221334097616056090255)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1955431227886176957723100141138086648174307911970006866839798339644438736919670280211484229751568581081242089053610667048808028045128)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-977715613943088478861550070569043324087153955985003433419899169822219368459835140105742114875784290540621044526805333524404014022564)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-488857806971544239430775035284521662043576977992501716709949584911109684229917570052871057437892145270310522263402666762202007011282)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-244428903485772119715387517642260831021788488996250858354974792455554842114958785026435528718946072635155261131701333381101003505641)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-122214451742886059857693758821130415510894244498125429177487396227777421057479392513217764359473036317577630565850666690550501752821)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-61107225871443029928846879410565207755447122249062714588743698113888710528739696256608882179736518158788815282925333345275250876411)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-30553612935721514964423439705282603877723561124531357294371849056944355264369848128304441089868259079394407641462666672637625438206)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-15276806467860757482211719852641301938861780562265678647185924528472177632184924064152220544934129539697203820731333336318812719103)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-7638403233930378741105859926320650969430890281132839323592962264236088816092462032076110272467064769848601910365666668159406359552)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3819201616965189370552929963160325484715445140566419661796481132118044408046231016038055136233532384924300955182833334079703179776)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1909600808482594685276464981580162742357722570283209830898240566059022204023115508019027568116766192462150477591416667039851589888)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-954800404241297342638232490790081371178861285141604915449120283029511102011557754009513784058383096231075238795708333519925794944)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-477400202120648671319116245395040685589430642570802457724560141514755551005778877004756892029191548115537619397854166759962897472)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-238700101060324335659558122697520342794715321285401228862280070757377775502889438502378446014595774057768809698927083379981448736)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-119350050530162167829779061348760171397357660642700614431140035378688887751444719251189223007297887028884404849463541689990724368)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-59675025265081083914889530674380085698678830321350307215570017689344443875722359625594611503648943514442202424731770844995362184)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-29837512632540541957444765337190042849339415160675153607785008844672221937861179812797305751824471757221101212365885422497681092)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-14918756316270270978722382668595021424669707580337576803892504422336110968930589906398652875912235878610550606182942711248840546)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-7459378158135135489361191334297510712334853790168788401946252211168055484465294953199326437956117939305275303091471355624420273)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3729689079067567744680595667148755356167426895084394200973126105584027742232647476599663218978058969652637651545735677812210137)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1864844539533783872340297833574377678083713447542197100486563052792013871116323738299831609489029484826318825772867838906105069)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-932422269766891936170148916787188839041856723771098550243281526396006935558161869149915804744514742413159412886433919453052535)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-466211134883445968085074458393594419520928361885549275121640763198003467779080934574957902372257371206579706443216959726526268)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-233105567441722984042537229196797209760464180942774637560820381599001733889540467287478951186128685603289853221608479863263134)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-116552783720861492021268614598398604880232090471387318780410190799500866944770233643739475593064342801644926610804239931631567)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-58276391860430746010634307299199302440116045235693659390205095399750433472385116821869737796532171400822463305402119965815784)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-29138195930215373005317153649599651220058022617846829695102547699875216736192558410934868898266085700411231652701059982907892)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-14569097965107686502658576824799825610029011308923414847551273849937608368096279205467434449133042850205615826350529991453946)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-7284548982553843251329288412399912805014505654461707423775636924968804184048139602733717224566521425102807913175264995726973)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3642274491276921625664644206199956402507252827230853711887818462484402092024069801366858612283260712551403956587632497863487)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1821137245638460812832322103099978201253626413615426855943909231242201046012034900683429306141630356275701978293816248931744)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-910568622819230406416161051549989100626813206807713427971954615621100523006017450341714653070815178137850989146908124465872)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-455284311409615203208080525774994550313406603403856713985977307810550261503008725170857326535407589068925494573454062232936)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-227642155704807601604040262887497275156703301701928356992988653905275130751504362585428663267703794534462747286727031116468)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-113821077852403800802020131443748637578351650850964178496494326952637565375752181292714331633851897267231373643363515558234)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-56910538926201900401010065721874318789175825425482089248247163476318782687876090646357165816925948633615686821681757779117)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-28455269463100950200505032860937159394587912712741044624123581738159391343938045323178582908462974316807843410840878889559)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-14227634731550475100252516430468579697293956356370522312061790869079695671969022661589291454231487158403921705420439444780)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-7113817365775237550126258215234289848646978178185261156030895434539847835984511330794645727115743579201960852710219722390)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3556908682887618775063129107617144924323489089092630578015447717269923917992255665397322863557871789600980426355109861195)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1778454341443809387531564553808572462161744544546315289007723858634961958996127832698661431778935894800490213177554930598)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-889227170721904693765782276904286231080872272273157644503861929317480979498063916349330715889467947400245106588777465299)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-444613585360952346882891138452143115540436136136578822251930964658740489749031958174665357944733973700122553294388732650)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-222306792680476173441445569226071557770218068068289411125965482329370244874515979087332678972366986850061276647194366325)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-111153396340238086720722784613035778885109034034144705562982741164685122437257989543666339486183493425030638323597183163)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-55576698170119043360361392306517889442554517017072352781491370582342561218628994771833169743091746712515319161798591582)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-27788349085059521680180696153258944721277258508536176390745685291171280609314497385916584871545873356257659580899295791)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-13894174542529760840090348076629472360638629254268088195372842645585640304657248692958292435772936678128829790449647896)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-6947087271264880420045174038314736180319314627134044097686421322792820152328624346479146217886468339064414895224823948)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3473543635632440210022587019157368090159657313567022048843210661396410076164312173239573108943234169532207447612411974)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1736771817816220105011293509578684045079828656783511024421605330698205038082156086619786554471617084766103723806205987)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-868385908908110052505646754789342022539914328391755512210802665349102519041078043309893277235808542383051861903102994)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-434192954454055026252823377394671011269957164195877756105401332674551259520539021654946638617904271191525930951551497)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-217096477227027513126411688697335505634978582097938878052700666337275629760269510827473319308952135595762965475775749)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-108548238613513756563205844348667752817489291048969439026350333168637814880134755413736659654476067797881482737887875)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-54274119306756878281602922174333876408744645524484719513175166584318907440067377706868329827238033898940741368943938)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-27137059653378439140801461087166938204372322762242359756587583292159453720033688853434164913619016949470370684471969)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-13568529826689219570400730543583469102186161381121179878293791646079726860016844426717082456809508474735185342235985)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-6784264913344609785200365271791734551093080690560589939146895823039863430008422213358541228404754237367592671117993)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3392132456672304892600182635895867275546540345280294969573447911519931715004211106679270614202377118683796335558997)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1696066228336152446300091317947933637773270172640147484786723955759965857502105553339635307101188559341898167779499)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-848033114168076223150045658973966818886635086320073742393361977879982928751052776669817653550594279670949083889750)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-424016557084038111575022829486983409443317543160036871196680988939991464375526388334908826775297139835474541944875)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-212008278542019055787511414743491704721658771580018435598340494469995732187763194167454413387648569917737270972438)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-106004139271009527893755707371745852360829385790009217799170247234997866093881597083727206693824284958868635486219)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-53002069635504763946877853685872926180414692895004608899585123617498933046940798541863603346912142479434317743110)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-26501034817752381973438926842936463090207346447502304449792561808749466523470399270931801673456071239717158871555)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-13250517408876190986719463421468231545103673223751152224896280904374733261735199635465900836728035619858579435778)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-6625258704438095493359731710734115772551836611875576112448140452187366630867599817732950418364017809929289717889)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3312629352219047746679865855367057886275918305937788056224070226093683315433799908866475209182008904964644858945)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1656314676109523873339932927683528943137959152968894028112035113046841657716899954433237604591004452482322429473)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-828157338054761936669966463841764471568979576484447014056017556523420828858449977216618802295502226241161214737)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-414078669027380968334983231920882235784489788242223507028008778261710414429224988608309401147751113120580607369)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-207039334513690484167491615960441117892244894121111753514004389130855207214612494304154700573875556560290303685)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-103519667256845242083745807980220558946122447060555876757002194565427603607306247152077350286937778280145151843)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-51759833628422621041872903990110279473061223530277938378501097282713801803653123576038675143468889140072575922)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-25879916814211310520936451995055139736530611765138969189250548641356900901826561788019337571734444570036287961)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-12939958407105655260468225997527569868265305882569484594625274320678450450913280894009668785867222285018143981)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-6469979203552827630234112998763784934132652941284742297312637160339225225456640447004834392933611142509071991)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3234989601776413815117056499381892467066326470642371148656318580169612612728320223502417196466805571254535996)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1617494800888206907558528249690946233533163235321185574328159290084806306364160111751208598233402785627267998)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-808747400444103453779264124845473116766581617660592787164079645042403153182080055875604299116701392813633999)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-404373700222051726889632062422736558383290808830296393582039822521201576591040027937802149558350696406817000)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-202186850111025863444816031211368279191645404415148196791019911260600788295520013968901074779175348203408500)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-101093425055512931722408015605684139595822702207574098395509955630300394147760006984450537389587674101704250)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-50546712527756465861204007802842069797911351103787049197754977815150197073880003492225268694793837050852125)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-25273356263878232930602003901421034898955675551893524598877488907575098536940001746112634347396918525426063)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-12636678131939116465301001950710517449477837775946762299438744453787549268470000873056317173698459262713032)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-6318339065969558232650500975355258724738918887973381149719372226893774634235000436528158586849229631356516)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3159169532984779116325250487677629362369459443986690574859686113446887317117500218264079293424614815678258)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1579584766492389558162625243838814681184729721993345287429843056723443658558750109132039646712307407839129)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-789792383246194779081312621919407340592364860996672643714921528361721829279375054566019823356153703919565)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-394896191623097389540656310959703670296182430498336321857460764180860914639687527283009911678076851959783)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-197448095811548694770328155479851835148091215249168160928730382090430457319843763641504955839038425979892)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-98724047905774347385164077739925917574045607624584080464365191045215228659921881820752477919519212989946)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-49362023952887173692582038869962958787022803812292040232182595522607614329960940910376238959759606494973)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-24681011976443586846291019434981479393511401906146020116091297761303807164980470455188119479879803247487)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-12340505988221793423145509717490739696755700953073010058045648880651903582490235227594059739939901623744)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-6170252994110896711572754858745369848377850476536505029022824440325951791245117613797029869969950811872)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3085126497055448355786377429372684924188925238268252514511412220162975895622558806898514934984975405936)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1542563248527724177893188714686342462094462619134126257255706110081487947811279403449257467492487702968)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-771281624263862088946594357343171231047231309567063128627853055040743973905639701724628733746243851484)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-385640812131931044473297178671585615523615654783531564313926527520371986952819850862314366873121925742)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-192820406065965522236648589335792807761807827391765782156963263760185993476409925431157183436560962871)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-96410203032982761118324294667896403880903913695882891078481631880092996738204962715578591718280481436)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-48205101516491380559162147333948201940451956847941445539240815940046498369102481357789295859140240718)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-24102550758245690279581073666974100970225978423970722769620407970023249184551240678894647929570120359)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-12051275379122845139790536833487050485112989211985361384810203985011624592275620339447323964785060180)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-6025637689561422569895268416743525242556494605992680692405101992505812296137810169723661982392530090)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3012818844780711284947634208371762621278247302996340346202550996252906148068905084861830991196265045)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1506409422390355642473817104185881310639123651498170173101275498126453074034452542430915495598132523)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-753204711195177821236908552092940655319561825749085086550637749063226537017226271215457747799066262)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-376602355597588910618454276046470327659780912874542543275318874531613268508613135607728873899533131)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-188301177798794455309227138023235163829890456437271271637659437265806634254306567803864436949766566)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-94150588899397227654613569011617581914945228218635635818829718632903317127153283901932218474883283)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-47075294449698613827306784505808790957472614109317817909414859316451658563576641950966109237441642)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-23537647224849306913653392252904395478736307054658908954707429658225829281788320975483054618720821)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-11768823612424653456826696126452197739368153527329454477353714829112914640894160487741527309360411)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5884411806212326728413348063226098869684076763664727238676857414556457320447080243870763654680206)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2942205903106163364206674031613049434842038381832363619338428707278228660223540121935381827340103)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1471102951553081682103337015806524717421019190916181809669214353639114330111770060967690913670052)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-735551475776540841051668507903262358710509595458090904834607176819557165055885030483845456835026)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-367775737888270420525834253951631179355254797729045452417303588409778582527942515241922728417513)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-183887868944135210262917126975815589677627398864522726208651794204889291263971257620961364208757)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-91943934472067605131458563487907794838813699432261363104325897102444645631985628810480682104379)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-45971967236033802565729281743953897419406849716130681552162948551222322815992814405240341052190)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-22985983618016901282864640871976948709703424858065340776081474275611161407996407202620170526095)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-11492991809008450641432320435988474354851712429032670388040737137805580703998203601310085263048)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5746495904504225320716160217994237177425856214516335194020368568902790351999101800655042631524)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2873247952252112660358080108997118588712928107258167597010184284451395175999550900327521315762)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1436623976126056330179040054498559294356464053629083798505092142225697587999775450163760657881)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-718311988063028165089520027249279647178232026814541899252546071112848793999887725081880328941)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-359155994031514082544760013624639823589116013407270949626273035556424396999943862540940164471)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-179577997015757041272380006812319911794558006703635474813136517778212198499971931270470082236)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-89788998507878520636190003406159955897279003351817737406568258889106099249985965635235041118)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-44894499253939260318095001703079977948639501675908868703284129444553049624992982817617520559)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-22447249626969630159047500851539988974319750837954434351642064722276524812496491408808760280)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-11223624813484815079523750425769994487159875418977217175821032361138262406248245704404380140)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5611812406742407539761875212884997243579937709488608587910516180569131203124122852202190070)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2805906203371203769880937606442498621789968854744304293955258090284565601562061426101095035)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1402953101685601884940468803221249310894984427372152146977629045142282800781030713050547518)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-701476550842800942470234401610624655447492213686076073488814522571141400390515356525273759)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-350738275421400471235117200805312327723746106843038036744407261285570700195257678262636880)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-175369137710700235617558600402656163861873053421519018372203630642785350097628839131318440)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-87684568855350117808779300201328081930936526710759509186101815321392675048814419565659220)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-43842284427675058904389650100664040965468263355379754593050907660696337524407209782829610)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-21921142213837529452194825050332020482734131677689877296525453830348168762203604891414805)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-10960571106918764726097412525166010241367065838844938648262726915174084381101802445707403)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5480285553459382363048706262583005120683532919422469324131363457587042190550901222853702)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2740142776729691181524353131291502560341766459711234662065681728793521095275450611426851)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1370071388364845590762176565645751280170883229855617331032840864396760547637725305713426)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-685035694182422795381088282822875640085441614927808665516420432198380273818862652856713)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-342517847091211397690544141411437820042720807463904332758210216099190136909431326428357)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-171258923545605698845272070705718910021360403731952166379105108049595068454715663214179)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-85629461772802849422636035352859455010680201865976083189552554024797534227357831607090)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-42814730886401424711318017676429727505340100932988041594776277012398767113678915803545)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-21407365443200712355659008838214863752670050466494020797388138506199383556839457901773)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-10703682721600356177829504419107431876335025233247010398694069253099691778419728950887)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5351841360800178088914752209553715938167512616623505199347034626549845889209864475444)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2675920680400089044457376104776857969083756308311752599673517313274922944604932237722)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1337960340200044522228688052388428984541878154155876299836758656637461472302466118861)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-668980170100022261114344026194214492270939077077938149918379328318730736151233059431)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-334490085050011130557172013097107246135469538538969074959189664159365368075616529716)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-167245042525005565278586006548553623067734769269484537479594832079682684037808264858)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-83622521262502782639293003274276811533867384634742268739797416039841342018904132429)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-41811260631251391319646501637138405766933692317371134369898708019920671009452066215)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-20905630315625695659823250818569202883466846158685567184949354009960335504726033108)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-10452815157812847829911625409284601441733423079342783592474677004980167752363016554)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5226407578906423914955812704642300720866711539671391796237338502490083876181508277)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2613203789453211957477906352321150360433355769835695898118669251245041938090754139)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1306601894726605978738953176160575180216677884917847949059334625622520969045377070)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-653300947363302989369476588080287590108338942458923974529667312811260484522688535)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-326650473681651494684738294040143795054169471229461987264833656405630242261344268)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-163325236840825747342369147020071897527084735614730993632416828202815121130672134)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-81662618420412873671184573510035948763542367807365496816208414101407560565336067)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-40831309210206436835592286755017974381771183903682748408104207050703780282668034)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-20415654605103218417796143377508987190885591951841374204052103525351890141334017)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-10207827302551609208898071688754493595442795975920687102026051762675945070667009)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5103913651275804604449035844377246797721397987960343551013025881337972535333505)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2551956825637902302224517922188623398860698993980171775506512940668986267666753)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1275978412818951151112258961094311699430349496990085887753256470334493133833377)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-637989206409475575556129480547155849715174748495042943876628235167246566916689)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-318994603204737787778064740273577924857587374247521471938314117583623283458345)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-159497301602368893889032370136788962428793687123760735969157058791811641729173)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-79748650801184446944516185068394481214396843561880367984578529395905820864587)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-39874325400592223472258092534197240607198421780940183992289264697952910432294)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-19937162700296111736129046267098620303599210890470091996144632348976455216147)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-9968581350148055868064523133549310151799605445235045998072316174488227608074)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4984290675074027934032261566774655075899802722617522999036158087244113804037)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2492145337537013967016130783387327537949901361308761499518079043622056902019)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1246072668768506983508065391693663768974950680654380749759039521811028451010)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-623036334384253491754032695846831884487475340327190374879519760905514225505)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-311518167192126745877016347923415942243737670163595187439759880452757112753)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-155759083596063372938508173961707971121868835081797593719879940226378556377)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-77879541798031686469254086980853985560934417540898796859939970113189278189)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-38939770899015843234627043490426992780467208770449398429969985056594639095)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-19469885449507921617313521745213496390233604385224699214984992528297319548)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-9734942724753960808656760872606748195116802192612349607492496264148659774)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4867471362376980404328380436303374097558401096306174803746248132074329887)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2433735681188490202164190218151687048779200548153087401873124066037164944)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1216867840594245101082095109075843524389600274076543700936562033018582472)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-608433920297122550541047554537921762194800137038271850468281016509291236)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-304216960148561275270523777268960881097400068519135925234140508254645618)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-152108480074280637635261888634480440548700034259567962617070254127322809)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-76054240037140318817630944317240220274350017129783981308535127063661405)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-38027120018570159408815472158620110137175008564891990654267563531830703)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-19013560009285079704407736079310055068587504282445995327133781765915352)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-9506780004642539852203868039655027534293752141222997663566890882957676)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4753390002321269926101934019827513767146876070611498831783445441478838)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2376695001160634963050967009913756883573438035305749415891722720739419)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1188347500580317481525483504956878441786719017652874707945861360369710)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-594173750290158740762741752478439220893359508826437353972930680184855)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-297086875145079370381370876239219610446679754413218676986465340092428)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-148543437572539685190685438119609805223339877206609338493232670046214)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-74271718786269842595342719059804902611669938603304669246616335023107)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-37135859393134921297671359529902451305834969301652334623308167511554)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-18567929696567460648835679764951225652917484650826167311654083755777)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-9283964848283730324417839882475612826458742325413083655827041877889)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4641982424141865162208919941237806413229371162706541827913520938945)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2320991212070932581104459970618903206614685581353270913956760469473)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1160495606035466290552229985309451603307342790676635456978380234737)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-580247803017733145276114992654725801653671395338317728489190117369)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-290123901508866572638057496327362900826835697669158864244595058685)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-145061950754433286319028748163681450413417848834579432122297529343)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-72530975377216643159514374081840725206708924417289716061148764672)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-36265487688608321579757187040920362603354462208644858030574382336)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-18132743844304160789878593520460181301677231104322429015287191168)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-9066371922152080394939296760230090650838615552161214507643595584)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4533185961076040197469648380115045325419307776080607253821797792)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2266592980538020098734824190057522662709653888040303626910898896)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1133296490269010049367412095028761331354826944020151813455449448)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-566648245134505024683706047514380665677413472010075906727724724)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-283324122567252512341853023757190332838706736005037953363862362)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-141662061283626256170926511878595166419353368002518976681931181)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-70831030641813128085463255939297583209676684001259488340965591)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-35415515320906564042731627969648791604838342000629744170482796)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-17707757660453282021365813984824395802419171000314872085241398)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-8853878830226641010682906992412197901209585500157436042620699)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4426939415113320505341453496206098950604792750078718021310350)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2213469707556660252670726748103049475302396375039359010655175)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1106734853778330126335363374051524737651198187519679505327588)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-553367426889165063167681687025762368825599093759839752663794)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-276683713444582531583840843512881184412799546879919876331897)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-138341856722291265791920421756440592206399773439959938165949)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-69170928361145632895960210878220296103199886719979969082975)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-34585464180572816447980105439110148051599943359989984541488)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-17292732090286408223990052719555074025799971679994992270744)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-8646366045143204111995026359777537012899985839997496135372)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4323183022571602055997513179888768506449992919998748067686)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2161591511285801027998756589944384253224996459999374033843)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1080795755642900513999378294972192126612498229999687016922)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-540397877821450256999689147486096063306249114999843508461)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-270198938910725128499844573743048031653124557499921754231)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-135099469455362564249922286871524015826562278749960877116)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-67549734727681282124961143435762007913281139374980438558)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-33774867363840641062480571717881003956640569687490219279)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-16887433681920320531240285858940501978320284843745109640)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-8443716840960160265620142929470250989160142421872554820)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4221858420480080132810071464735125494580071210936277410)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2110929210240040066405035732367562747290035605468138705)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1055464605120020033202517866183781373645017802734069353)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-527732302560010016601258933091890686822508901367034677)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-263866151280005008300629466545945343411254450683517339)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-131933075640002504150314733272972671705627225341758670)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-65966537820001252075157366636486335852813612670879335)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-32983268910000626037578683318243167926406806335439668)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-16491634455000313018789341659121583963203403167719834)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-8245817227500156509394670829560791981601701583859917)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4122908613750078254697335414780395990800850791929959)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2061454306875039127348667707390197995400425395964980)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1030727153437519563674333853695098997700212697982490)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-515363576718759781837166926847549498850106348991245)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-257681788359379890918583463423774749425053174495623)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-128840894179689945459291731711887374712526587247812)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-64420447089844972729645865855943687356263293623906)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-32210223544922486364822932927971843678131646811953)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-16105111772461243182411466463985921839065823405977)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-8052555886230621591205733231992960919532911702989)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-4026277943115310795602866615996480459766455851495)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2013138971557655397801433307998240229883227925748)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1006569485778827698900716653999120114941613962874)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-503284742889413849450358326999560057470806981437)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-251642371444706924725179163499780028735403490719)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-125821185722353462362589581749890014367701745360)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-62910592861176731181294790874945007183850872680)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-31455296430588365590647395437472503591925436340)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-15727648215294182795323697718736251795962718170)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-7863824107647091397661848859368125897981359085)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3931912053823545698830924429684062948990679543)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1965956026911772849415462214842031474495339772)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-982978013455886424707731107421015737247669886)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-491489006727943212353865553710507868623834943)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-245744503363971606176932776855253934311917472)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-122872251681985803088466388427626967155958736)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-61436125840992901544233194213813483577979368)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-30718062920496450772116597106906741788989684)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-15359031460248225386058298553453370894494842)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-7679515730124112693029149276726685447247421)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3839757865062056346514574638363342723623711)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1919878932531028173257287319181671361811856)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-959939466265514086628643659590835680905928)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-479969733132757043314321829795417840452964)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-239984866566378521657160914897708920226482)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-119992433283189260828580457448854460113241)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-59996216641594630414290228724427230056621)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-29998108320797315207145114362213615028311)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-14999054160398657603572557181106807514156)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-7499527080199328801786278590553403757078)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3749763540099664400893139295276701878539)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1874881770049832200446569647638350939270)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-937440885024916100223284823819175469635)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-468720442512458050111642411909587734818)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-234360221256229025055821205954793867409)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-117180110628114512527910602977396933705)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-58590055314057256263955301488698466853)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-29295027657028628131977650744349233427)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-14647513828514314065988825372174616714)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-7323756914257157032994412686087308357)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3661878457128578516497206343043654179)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1830939228564289258248603171521827090)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-915469614282144629124301585760913545)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-457734807141072314562150792880456773)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-228867403570536157281075396440228387)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-114433701785268078640537698220114194)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-57216850892634039320268849110057097)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-28608425446317019660134424555028549)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-14304212723158509830067212277514275)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-7152106361579254915033606138757138)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3576053180789627457516803069378569)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1788026590394813728758401534689285)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-894013295197406864379200767344643)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-447006647598703432189600383672322)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-223503323799351716094800191836161)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-111751661899675858047400095918081)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-55875830949837929023700047959041)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-27937915474918964511850023979521)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-13968957737459482255925011989761)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-6984478868729741127962505994881)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3492239434364870563981252997441)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1746119717182435281990626498721)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-873059858591217640995313249361)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-436529929295608820497656624681)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-218264964647804410248828312341)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-109132482323902205124414156171)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-54566241161951102562207078086)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-27283120580975551281103539043)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-13641560290487775640551769522)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-6820780145243887820275884761)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3410390072621943910137942381)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1705195036310971955068971191)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-852597518155485977534485596)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-426298759077742988767242798)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-213149379538871494383621399)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-106574689769435747191810700)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-53287344884717873595905350)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-26643672442358936797952675)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-13321836221179468398976338)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-6660918110589734199488169)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3330459055294867099744085)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1665229527647433549872043)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-832614763823716774936022)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-416307381911858387468011)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-208153690955929193734006)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-104076845477964596867003)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-52038422738982298433502)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-26019211369491149216751)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-13009605684745574608376)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-6504802842372787304188)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3252401421186393652094)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1626200710593196826047)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-813100355296598413024)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-406550177648299206512)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-203275088824149603256)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-101637544412074801628)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-50818772206037400814)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-25409386103018700407)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-12704693051509350204)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-6352346525754675102)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3176173262877337551)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1588086631438668776)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-794043315719334388)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-397021657859667194)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-198510828929833597)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-99255414464916799)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-49627707232458400)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-24813853616229200)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-12406926808114600)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-6203463404057300)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3101731702028650)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1550865851014325)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-775432925507163)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-387716462753582)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-193858231376791)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-96929115688396)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-48464557844198)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-24232278922099)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-12116139461050)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-6058069730525)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3029034865263)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1514517432632)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-757258716316)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-378629358158)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-189314679079)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-94657339540)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-47328669770)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-23664334885)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-11832167443)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5916083722)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2958041861)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1479020931)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-739510466)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-369755233)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-184877617)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-92438809)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-46219405)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-23109703)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-11554852)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5777426)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2888713)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1444357)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-722179)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-361090)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-180545)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-90273)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-45137)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-22569)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-11285)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-5643)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2822)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1411)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-706)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-353)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-177)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-89)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-45)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-23)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-12)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-6)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-3)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-2)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(1)) != Some(Integer(0))
-int: Integer(-1)
-arg: Positive(Integer(1))
-Some(Integer(
-thread 'backend::invert' (165017) has overflowed its stack
-fatal runtime error: stack overflow, aborting
-error: test failed, to rerun pass `--test integration`
-
-Caused by:
-  process didn't exit successfully: `/home/user/fast-paillier/target/debug/deps/integration-c561df37baeccefc 'backend::invert' --exact --nocapture` (signal: 6, SIGABRT: process abort signal)

From 9da5b17df029788b8cc2d4029b1a70f4d596adcd Mon Sep 17 00:00:00 2001
From: Denis Varlakov <cordial.egg6523@fastmail.com>
Date: Thu, 15 Oct 2026 17:35:52 +0200
Subject: [PATCH 7/7] Fully migrate to `crypto-primes` for primality test

Signed-off-by: Denis Varlakov <cordial.egg6523@fastmail.com>
---
 CHANGELOG.md              |  2 +-
 src/backend/num_bigint.rs | 45 ++++++++++++++-------------------------
 2 files changed, 17 insertions(+), 30 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c8a96cf..ff9095a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,7 @@
 ## v0.3.3
 * Unify encoding of integer=0 across backends [#45]
 * Deserialize returns an error on invalid radix, instead of panicking [#45]
-* Fix primality test on num-bigint backend [#46]
+* Use `crypto-primes` for primality test instead of `glass_pumpkin` on num-bigint backend [#46]
 
 [#45]: https://github.com/LFDT-Lockness/fast-paillier/pull/45
 [#46]: https://github.com/LFDT-Lockness/fast-paillier/pull/46
diff --git a/src/backend/num_bigint.rs b/src/backend/num_bigint.rs
index 14d12dd..07ce86b 100644
--- a/src/backend/num_bigint.rs
+++ b/src/backend/num_bigint.rs
@@ -298,11 +298,21 @@ impl Integer {
         self
     }
 
-    // TODO reps is unused here, need to unify with rug
+    // TODO neither reps nor rng are used here, maybe we should get rid of them
     pub fn is_probably_prime(&self, _reps: u32, _rng: &mut impl rand_core::RngCore) -> IsPrime {
+        fn boxed_uint(n: &num_bigint::BigUint) -> crypto_bigint::BoxedUint {
+            crypto_bigint::cpubits! {
+                16 | 32 => { crypto_bigint::BoxedUint::from_words(n.iter_u32_digits()) }
+                64 => { crypto_bigint::BoxedUint::from_words(n.iter_u64_digits()) }
+            }
+        }
+
         if self.cmp0().is_le() {
             IsPrime::No
-        } else if glass_pumpkin::is_prime(self.0.magnitude()) {
+        } else if crypto_primes::is_prime(
+            crypto_primes::Flavor::Any,
+            &boxed_uint(self.0.magnitude()),
+        ) {
             IsPrime::Probably
         } else {
             IsPrime::No
@@ -315,7 +325,10 @@ impl Integer {
             x.assign_random_bits(bit_size, rng);
             x.set_bit(bit_size - 1, true);
             x |= 1u32;
-            if glass_pumpkin::is_prime(x.0.magnitude()) {
+            if matches!(
+                x.is_probably_prime(0, rng),
+                IsPrime::Probably | IsPrime::Yes
+            ) {
                 break x;
             }
         }
@@ -429,32 +442,6 @@ impl quickcheck::Arbitrary for Integer {
     }
 }
 
-/// This module was taken from <https://docs.rs/glass_pumpkin/2.0.0/src/glass_pumpkin/common.rs.html>
-/// preserving only function that performs primality test. The code was modified to work with
-/// older version of the `rand_core` crate.
-///
-/// We cannot use the latest version of the library as it requires introducing breaking changes
-/// in the code. We cannot use older version of the library, which has compatible `rand_core`
-/// dependency, as it is buggy.
-///
-/// We can migrate back to that dependency when we update our ecosystem to latest `rand_core`.
-mod glass_pumpkin {
-    /// Checks if a number is probably prime using the deterministic-base
-    /// Baillie-PSW test.
-    ///
-    /// The RNG parameter is retained for API compatibility and is not consumed.
-    pub fn is_prime(candidate: &num_bigint::BigUint) -> bool {
-        crypto_primes::is_prime(crypto_primes::Flavor::Any, &boxed_uint(candidate))
-    }
-
-    fn boxed_uint(n: &num_bigint::BigUint) -> crypto_bigint::BoxedUint {
-        crypto_bigint::cpubits! {
-            16 | 32 => { crypto_bigint::BoxedUint::from_words(n.iter_u32_digits()) }
-            64 => { crypto_bigint::BoxedUint::from_words(n.iter_u64_digits()) }
-        }
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::Integer;