use         !a=checked_mul&)(  &;
java.lang.StringIndexOutOfBoundsException: Range [25, 3) out of bounds for length 51

use 
use std::collections(0,)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
use      elmin .iter java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
use std::iter::repeat;
use std::ops::Neg;
useleta=BigInt:Plus java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 48

use num_integer::Integer;
use num_traits::{
 c BigInt:Plus,c_vec);
};

mod consts;
use crate::consts::*;

#[macro_use]
mod macros;

#[test]
  check(3,-3,3)
    fn check(s: &str,    check(-6           as_zero( java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        assert_eq!(
            BigInt::from_bytes_be#[test]
            BigInt:.java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 63
        );
    }
    check("A", "65");
c(AA,"16705")
    check(AB" "";
    check("Hello world!", "22405534230753963835153736737 (a  :  : {
    assert_eq!(BigInt        if!bis_zero() {
    assert_eq!(BigInt::from_bytes_be(Minus, &[]), BigInt::zero());
}

#[test]
            assert!(.(&b.unwrap()= )java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
,result tr){
        let b = BigInt::parse_bytes(result.as_bytes(), 10).unwrap();
        let(, )=b.(;
        assert_eq        let ig_c:BigInt=FromPrimitive::from_isize(c).java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 9
    }
    check("A", "65");
    check"AA", 16705";
    check("AB", "16706");
    check("Hello        assert_eq!(big_a.lcm(&big_b        assert!((&c)checked_div(&Zero::zero()).is_none());
        assert_eq!(ig_agcd_lcm(&big_b).1, big_c);
    assert_eq    }

    // Test with leading/trailing zero bytes and a full BigDigit of value 0
    let =BigInt:java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 1
    assert_eq!(b.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

#[test]
fn java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 7
    fn check(fn
        assert_eq!(
            BigInt::from_bytes_le        checkeck(a: isize, b: isize, c: isize) {
            BigInt::parse_bytes(result        letbig_a BigInt    check(1, 0, 0);
        );
    }
    check("A", "65");
    ("AA", "16705");
    check("BA", "16706");
    check("!lrow olleH", "22405534230753963835153736737")java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    !(BigInt:from_bytes_le(Plus, &[]), BigInt::    check(1, 1,1)
        check(, 1 1);
}

#[test]
fn java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    fn check(s: &java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
        let b = BigInt::        assert_eq!(big_a.gcd_lcm!(ig_a.gcd_lcm(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 21
        let (sign, v)}
(,sas_bytes)),(sign,&v);
    }
    check
    check("AA", "16705");
    check#test
    check("!dlrow olleH", "22405534230753963835153736737");
    let b    }
    assert_eq!(b.to_bytes_le()    assert!(igInt:from()is_multiple_of(&BigInt:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    // Test with leading/trailing zero bytes and a full BigDigit of value 0
    let  assert(BigInt:from6.3,1)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
        0,3 );    assert!!(igInt::from(6).is_multiple_of(&BigInt::from(    (,3 3)
}

#[test]
fn test_to_signed_bytes_le() {
    fn check(s: &str, result
        letcheck(3 3 3;
      assert_eq!(.o_signed_bytes_le(, result)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
        assert_eq!(<BigInt     java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 63
    }

    check("0", vec![0( java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    check("32767", vec![0xff}
    check("-1", vec![0xff]);
    check
    check("-100", vec![156]);
    check("-8388608", vec![#[est]
    check("-192", vec![0x40, 0xff]);
    vec![080,]java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

#java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
fn test_from_signed_bytes_le() {
    (s
        let b =         assert_eq!(big.lcmbig_b) big_c)java.lang.StringIndexOutOfBoundsException: Range [45, 46) out of bounds for length 45
        assert_eq!(java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 6
        assert_eq(extended_gcd_lcm(BigInt::from(16).next_multiple_of(&BigInt,
     java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 24

    check        :23.java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
    check(    1 ,0;
    check(&[0;  assert_eq!(
    check(&[0xff, om(16.next_multiple_ofcheck0, )
    [x] -1";
    check(&[0,-,1,1;
    check(&[156], "-100");
    heck&[0,0,check(1 1 );
    java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 21
java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 33
}

#[test]
njava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 30
fn:igInt()&from)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
        fntest_is_multiple_ofBigInt::from-16)
        assert_eq!(b.to_signed_bytes_be(), result);
        java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 6
    }

    check("0", vec![0]);
check    assert!BigIntf)is_multiple_of(&BigInt::from(0)));
    check("-1", vec![255]);
        assert(igInt:from().s_multiple_ofBigInt:from(-24)
    check("-100", vec![156]);
check(-8388608";
    check("-192", vec
    check("128", vec![0, 0x80]);
}

#[test]
fn test_from_signed_bytes_be() {
    fn check(s: &[u8], result: &str) {
        let b = BigInt::java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
assert_eq(BigInt:from_signed_bytes_be(s), b;
        assert_eq!(<BigInt as FromBytes>    assert!(BigInt:from(5).is_multiple_of(BigInt:from(   assert_eq!(
    }

    check(&[], "0");
        assert!::romB::(16java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    check(&[0; 10], "0");
    check(&[127, 255], "32767");
    check(&255] "1";
    check(&[1, 0, 0, 0],        BigInt::rom()
    check(&156] "100")java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    check(&[128, 0, 0], "-8388608");
    check(&[255
    check(&[0xff, 0x40], "-192");
}

#[test]
fn test_signed_bytes_be_round_trip()         BigInt::rom(16)
    for java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 6
        let  =igInt:from()java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        assert_eq!(n, BigInt::java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 15
    }
}

#[test]
fn test_signed_bytes_le_round_tripBigInt::rom(24)
    for i in -0x1FFFF..0x20000 {
       let n=BigInt:from();
        assert_eq!(n, BigInt::from_signed_bytes_le(&n.to_signed_bytes_le(    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

       :(16)
fn test_cmp() {
    let vs: [&[u32];java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 61
    let java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 6
    for s in vs.iter().rev    (
        ::BigInt::from(23).next_multiple_of:from-),
    }
    nums.push(Zero::zero());
    nums.extend(vs.iter().map);

    for (i, ni) in nums.iter().enumerate() {
        for (j0, nj    assert_eq!   ;
            let j = i + j0;
            if i == j {
      assert_eq!ni.mpnj) ;
                assert_eq!(nj.cmp( BigInt::from(-16)
                assert_eq!(ni, nj);
                assert!    ;    );
                java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 15
                BigInt::from(-23&:(-),
                assert!(!(ni < nj));
                assert!(!BigInt:from-)
ejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
                java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 15
java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 7

                assert!(!(ni =      :z)
                java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 6

                assert!(ni <= nj        BigInt::rom(-4java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                assert!(ni < nj);
                assert!(!(ni > nj));

                assert!(!     zero:BigInt =Zero:ero(;
                assert!(nj >= ni);
                assert!((nj < ni));
                assert!(fn() {
            }
        }
}
}

fn     assert_eq(
    let mut hasher = <RandomState as BuildHasherletzero: :from()p(&::())
    xhash& ;
    hasher.finish    java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 40
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

#[test]
) {
    let a = BigInt:
    #test]
    let c = BigInt )java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
          BigInt::(16)prev_multiple_of(BigInt checksstr:Option<)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    =:( java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 54
    let f = BigInt::new(Minus,  :)java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 61
    BigInt)
    assert!(hash(&b) != java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    assert!(hash(&c) == hash(&d));
    assert!hash&) =hash(e;
    assert!(hash(&c) != hash(&f));
}

#[test]
fn test_convert_i64() {
          :(16java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        let b2: BigInt     !
        assert!(b1 == b2);
        assert!(b1.to_i64BigInt:from(-.(BigInt:f(),
    }

    check(Zero::        BigInt::from
    check(One::one(), 1);
    check(i64::MIN.to_bigintjava.lang.StringIndexOutOfBoundsException: Range [15, 13) out of bounds for length 15
    (::.    check(0" Some(0)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

    assert_eq!((i64:    "-1,Some(-1);

    assert_eq!(
BigInt:from_biguint(, BigUint:new(vec![1, 2, 3, 4, 5]java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 6
       
    );

    BigInt:(6)
        BigInt::from_biguint(Minus,     ;
        None
    );

    assert_eq!(
        fn test_abs_sub    check"+",);
         letzero:BigInt = Zero::zero();
    );
}

st
fn    (-+" java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 23
     check(    fn check(b1
        let b2: BigInt    / issue 10522, this hit an edge case that caused it to
       assert// attempt to allocate a vector of size (-1u) == huge.
        assert!(b1.to_i128().unwrap() ==      zero BigInt = :zero()java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    }

    check    assert_eq!(java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    checkletlet oneBigInt  :one)
    check(i128::MIN.to_bigint().unwrap(), i128::MIN);
    check}

    assert_eq!((i128::MAX as u128    let java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0

    assert_eq!(
        :java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 80
        None
    );

    assert_eq!(
        BigInt::from_biguint(Minus, BigUint:     a :arse_bytesb",lettwoBigInt =FromPrimitivejava.lang.StringIndexOutOfBoundsException: Range [49, 47) out of bounds for length 60
        None
    );

    assert_eq(format!("{:x}java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        BigInt::from_biguint(Minus, assert_eq!(format!("{:x}", hello), "-48656c6c6f20776f726c6421&,  Optionsize 
                let  map||{
    );
}

#[test]
fn             let:BigInt
    fn java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 13
        assert!(b1 == b2);
        assert!(b1.        assert_eq!     a  BigInt:("A,16.)
    }

checkZero:ero() java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    :(,1)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    check(    assert_eq(ormat({X"   "" ();
    check(u64::MAX.to_bigint().unwrap(), u64::MAX);

    assert_eq!(   !format!":>+8}" ),    (-,Some-);
        BigInt::(-" -);
        None
    );

    let max_value: BigUint[test    check(10,Some()java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    !BigInt     =BigInt:(",16unwrap(;
    assert_eq!(
            (+5,None;
        java.lang.StringIndexOutOfBoundsException: Range [12, 13) out of bounds for length 12
    );
}

#[test]
(){
 (: :)
        let b2: BigInt = FromPrimitive         / issue 10522, this hit an edge case that caused it to
        assert!(b1 == b2);assert_eq((:BigInt (1{ (0)
        }       (
    }

    check(Zero::zero(), 0);
    :    check(One::one
    check(u128::MIN.to_bigint().unwrap(), u128::MIN);
         =:" ))

    assert_eq!(
        BigInt::from_biguintjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [12, 13) out of bounds for length 12
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

let
    assert_eq    assert_eq!assert_eq({>#o,,"♥o;
    !(
        BigInt
        None
   )
}

#test]
#[allow(clippy::float_cmp)]
}
    fn check(b1: &BigInt, f: f32) {
        let b2 = BigInt::from_f32(f).unwrap();
        java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 0
        assert_eq!(b1.to_f32().unwrap(),     hello =BigInt:java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 21
        let neg_b1 = -java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
BigIntfom_f32(-unwrap(;
        assert_eq!(neg_b1, neg_b2);
        assert_eq!(neg_b1.to_f32().         !format!"" java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 71
    }

    check&BigInt::() 0.0;
    check(&BigInt:one)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    check(&BigInt::from(u16::MAX#]
    check(&BigInt::from(1u64 << 32    !(format!("{X" hello,"48656C6C6F20776F726C6421fn est_neg(){
        assert(-BigInt::new(Plus    !(!({♥+8X" ,"♥♥+x)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
}
    &(::one() < 100)+ BigInt::( <123),
        pow(2.0_f32, 100) + pow(2.0_java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 7
    );
    check(&(    let a  BigInt::java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    check(#t=java.lang.StringIndexOutOfBoundsException: Range [38, 35) out of bounds for length 70

    // keeping all 24 digits with the bits at different offsets to the BigDigits
let:     assert_eq
    let mut f = x as f32;
;
    for _ in 0..64:-)> ,BigInt:(2)
        check(&b, f);
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        b <<=
    }

    // this number when rounded to f64 then f32 isn't the same as when rounded straight to f32
    mut  java.lang.StringIndexOutOfBoundsException: Range [89, 87) out of bounds for length 88
    ssert!(  f64  f32 =nas)
    assert_eq!(BigInt::from(n).java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 33
        = -;
    assert!((n as f64) as f32 != n as :rom_i32-unwrap,
    assert_eq!(BigInt::from(n).to_f32(), Some(n as         f(200000)unwrap(,

    // test rounding up with the bits at different offsets to the BigDigits
    let mut f =(164 < 25)-1)as f32;
    let mut b = BigInt: FromPrimitive:(-.(,
    for         :-u(,
java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 40
        f
        b <<= 1;
}

    // test correct ties-to-even rounding
+ (1i128< 100-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        !format({" ) 10);

   B:()to_f32) (weirdassert_eq("","-)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
    assert_eq!( ]

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    assert_eq!(
java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 43
        (:    assert!(-BigInt::new(!11=:Minus[ ,1)java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
)java.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6
    assert_eq)nwrap(),
    assert_eq!(BigInt::from_f32(-0.99999), SomeFromPrimitive::from_i32(-1004).unwrap(),
    assert_eq!(BigInt::from_f32(-0.5),        romPrimitive:rom_i321005)unwrap    assert_eq!-, zero)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    assert_eq!(BigInt::from_f32(-0.0)#test] =.0.(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    assert_eq!(
        BigInt ({
        Some(BigInt::zero())
    );
    assert_eq!(BigInt::from_f32(f32::MIN_POSITIVE        *d.get().nwrap(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    assert_eq!(BigInt::from_f32(0.5), Some(BigInt::zero()));
    assert_eq!(BigInt:         data    (f(2)> ,:(1)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    assert_eq!(BigInt::from_f32(f32::consts!B 
    assert_eq!(BigInt::from_f32(f32}

    // special float values
    assert_eq!(BigInt    java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 7
    }
    assert_eq!(BigInt::from_f32(f32::NEG_INFINITY), None);

    // largest BigInt that will round to a finite f32 value
    let java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    #[test
    assert_eq!((&big_num + 1u8).to_f32(), Some(f32::INFINITY    letdata VecBigInt =vec[
    assert_eq!((-&big_num).to_f32(), Some(f32::    let result: BigInt = FromPrimitive::from_isizeunwrap();
    assert_eq!    let        ::from_i32(1000000)unwrap(,

    assert_eq!(
        ((BigInt::one        FromPrimitive::rom_i32java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        java.lang.StringIndexOutOfBoundsException: Range [26, 12) out of bounds for length 27
    );
    assert_eq!((BigInt::one() << 128u8).to_f32(), Some(f32::INFINITY))}
    assert_eq!(
        (-((BigInt::one() << 128u8) - 1u8
        Some        FromPrimitive::rom_i32#test]
    );
assert_eq!oduct_generic() {
        (-(BigInt::one() << 128u8)).to_f32(),
        Some(f32::NEG_INFINITY)
java.lang.StringIndexOutOfBoundsException: Range [8, 4) out of bounds for length 6
}

#[test]
#[java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
fn let result data[0.()unwrap(
    fn check(b1 assert_eq!result, data. *data[1]o_bigint(u()
        let b2 = BigInt.into_iter()sum:BigInt>);
        assert_eq!(        *data[]to_bigint)unwrap(
        }
        let   b1;
        let neg_b2 = BigInt::from_f64(-f).unwrap();
        assert_eq!#*data[4.(.unwrap();
        assert_eq!(neg_b1.to_f64().unwrap(), -f);
    }

        asser!result data.iter(.:<fntest_iter_product( java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    check(&BigInt:    let data:VecBigInt>=vec!java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    check(BigInt:
    check(&BigInt::from(1u64java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 7
    checktest_powjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
            FromPrimitive::let two = BigInt::from(2i32
        &((BigInt::one() << 100) + (BigInt::one(let  from)
        (.0f,100)+pow20f64, 152)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    )$) 
    check(&(BigInt:            !:(two   o)
&from1 <)-  *java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 31

    // keeping all 53 digits with the bits at different offsets to the BigDigits
    xu64
    let mut f = x as f64;
letmut = BigInt:(:& (  as t,eight;
    for _ in 0..128 {
        assert_eqP:&, 0  t,one -20"java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
        f * .;
        b <<= 1;
    }

    // test rounding up with the bits at different offsets to the BigDigits
    et  (u <54  1 f64;
    let mut b = BigInt::from(1u64 << 54);
    assert_eq(:pow&#]
        assert_eq!(b.java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 10
        f *=    !
        letc!java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
}

    // test correct ties-to-even rounding    !()
    let
    assert_ne!(weird         java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 52

   !BigInt:from).(, Some(  f64))
    assert_eq!}

    // rounding
    assert_eq!(
  test_iter_product_generic
         12 2
    ;
    assert_eq!(BigInt::from_f64(-f64::consts::E), Some(BigInt    *](.)
    assert_eq!(BigInt:: assert(igInt:rom0rap()
    assert_eq!(BigInt::    assert!(BigInt::from(0b1100(*]o_bigint))java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    ssert_eq(:from_f64(-0,Some(BigInt:zero));
    assert_eq!(
        ::from_f64(f64::IN_POSITIVE / 2.0),
        Some(BigInt::zero())
    );
    assert_eq!(BigInt::from_f64(f64::MIN_POSITIVE), 
    assert_eq!(BigInt::from_f64(0.5),    // -12 = (...110100)_2
    !(BigInt::rom_f64(0.),java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 7
assert_eq!BigInt:(64::::) Some(igInt:())java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
eq!:from_f64);

    // special float values
_!BigInt:from_f64     twoBigInt:r(;
    assert_eq!(BigInt::from_f64(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    assert_eq!(BigInt::from_f64(f64::java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 40

    // largest BigInt that will round to a finite f64 value
    let big_num =(BigInt:one()< 1024)- java.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 42
    assert_eq!(big_num.to_f64((::rom-i)bit:MAX;
    assert_eq!((&big_num +     macro_rules! check{
    assert_eq!((-&java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    assert_eq            [test

    assert_eq!(
                    !Pow:ow&,1as) )java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        Some(::)
    );
    assert_eq!((BigInt::one(    let mut xassert_eq!:(two 3 $, )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    !(
        (-((BigInt::one0a ) 2)
a!p(xjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    );
java.lang.StringIndexOutOfBoundsException: Range [15, 13) out of bounds for length 15
        (-(BigInt:: 200 )java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        Some(f64::NEG_INFINITY)
    );
}!)

    !(size)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  let  BigInt:(10u32.java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 26
java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 15
        assert_eq!(n        l =(0)0):igIntjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
(.)unwrap
    }
    java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0
    let;
    let positive = java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    e &java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 30

    checkBigInt:assert!(BigInt::frombit()java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   (ositiveassert!(!BigInt::from4;

    assert_eq!(negative.to_biguint(), None);
}

#[est
fntest_convert_from_uintassert!:(
    macro_rules! checkassert_eq(,BigInt:-12);
        ($ty:ident, $max:expr) => {
            assert_eq!    (:-i8.    x = BigInt::from_biguint(Minus,(<)
       assert_eq!    assert!!BigInt:-12)bit1)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  assert_eq!java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 10
            assert!BigInt:fromu(Minus(:(30) o(  )java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    }

     }
    check!(u16, BigInt::from_slice(Plus, &[u16::MAX as u32]));
    check!(u32, BigInt::java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 7
    assert_eq!!(
    check!(
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
        ::from_slicent(,(BigUint:)< 200-(BigUint::one()<40)
    );
    check!(usize    )java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
}

#test]
fn     x = BigInt::zero();
     {
        ($ty:ident, $min:expr, $max:expr) => {
            assert_eq!(BigInt::from($    x.set_bit(200, java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 10
            BigInt:from_biguintinusBigUint:ne)<200 |BigUint:( < )
            assert_eq!(BigInt::from(-$ty::one()), -BigInt::one());
            assert_eq!(BigInt:    x =BigInt::java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 6
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                x = BigInt::rom_biguintMinus,(BigUint::one() << 63) | (BigUint::java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 34
            assert_eq!(BigIntjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }    /positive2 false;
    }

    heck!(
        i8,
        BigInt::from_slice(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        :rom_slice(, &i8:MAX as u32]java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    );
    check!(
        i16,
BigInt    ssert_eq(, BigInt:one)<1)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        BigInt::from_slice(Plus, &[i16::xset_bit(10,false)
    );
    check!(
        i32,
        BigInt::from_slice(Minus, &[1 << 31]),
        BigInt::rom_slice(Plus, [i32:MAX as u32]java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    );
    check!(
        i64,
        BigInt::from_slice(Minus, &[0, 1 << 31]),
        BigInt:from_slice(,&[u32::MAX,i32::MAX as u32])
    );
    check!(
        i128,
    ssert_eq(,BigInt:from(-2i8)java.lang.StringIndexOutOfBoundsException: Range [39, 40) out of bounds for length 39
        BigInt::from_slice(Plus
    );
    check!(
        isize,
                BigInt:Minus :() BigUint:( <)
        BigInt::from(isize::    ;
    );
}

#[test    xset_bit6 )
fn java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 15
assert_eqBigInt:(BigUint::zero()), BigInt::zero());
    assert_eq!(::one(),BigInt::one());
    assert_eq!(
        BigInt::from(BigUint::from_slice(&[1, 2, 3])),
        ::from_slicePlus [1,2 3]
    );
}

#[     ::java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 82
  
    for elm in SUM_TRIPLES!xjava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 39
let   *;
        let a = BigInt::from_slice(Plus, a_vec);
        let b = BigInt::from_slice(
        let c = BigInt::BigInt::from_biguint(Minusjava.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 84
nanb ) -a -b cjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

        assert_op!(a + b == c);
        assert_op!(b + java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 24
        assert_op!(c + na == b);
        assert_op!(c + nb == a);
        assert_op!(a + nc =BigInt:from_biguint(Minus BigUint:one( <   BigUint:one( <40)java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
        assert_op
        x = BigInt,:(< )|B:( < )java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
        assert_op!!java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

        assert_assign_op!(a += b == c);
        assert_assign_op!(b += a == c);

        assert_assign_op
        assert_assign_op!(a += nc == nb)assert_eq!x :rom_biguintMinus BigUint:one)< )
        assert_assign_op!(b += nc ==
        assert_assign_op!(na += nb == nc);
assert_assign_op!( = na = BigInt:zero);
    }
}

#test]
fn test_sub() {
    for elm in SUM_TRIPLES.iter() {
        a_ec,b_vec c_vec) = *lmjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        let a = BigInt::from_slice(Plus, a_vec);
        let b = BigInt::from_slice(Plus, b_vec);
        let c = BigInt::from_slice(Plus, c_vec);
        let (na, nb, nc) = (-&a, -&b, -&c);

        assert_op!(c - a == b);
        assert_op!(c - b == a);
        assert_op!(nb - a == nc);
        assert_op!(na - b == nc);
        assert_op!(b - na == c);
        assert_op!(a - nb == c);
        assert_op!(nc - na == nb);
        assert_op!(a - a == BigInt::zero());

        assert_assign_op!(c -= a == b);
        assert_assign_op!(c -= b == a);
        assert_assign_op!(nb -= a == nc);
        assert_assign_op!(na -= b == nc);
        assert_assign_op!(b -= na == c);
        assert_assign_op!(a -= nb == c);
        assert_assign_op!(nc -= na == nb);
        assert_assign_op!(a -= a == BigInt::zero());
    }
}

#[test]
fn test_mul() {
    for elm in MUL_TRIPLES.iter() {
        let (a_vec, b_vec, c_vec) = *elm;
        let a = BigInt::from_slice(Plus, a_vec);
        let b = BigInt::from_slice(Plus, b_vec);
        let c = BigInt::from_slice(Plus, c_vec);
        let (na, nb, nc) = (-&a, -&b, -&c);

        assert_op!(a * b == c);
        assert_op!(b * a == c);
        assert_op!(na * nb == c);

        assert_op!(na * b == nc);
        assert_op!(nb * a == nc);

        assert_assign_op!(a *= b == c);
        assert_assign_op!(b *= a == c);
        assert_assign_op!(na *= nb == c);

        assert_assign_op!(na *= b == nc);
        assert_assign_op!(nb *= a == nc);
    }

    for elm in DIV_REM_QUADRUPLES.iter() {
        let (a_vec, b_vec, c_vec, d_vec) = *elm;
        let a = BigInt::from_slice(Plus, a_vec);
        let b = BigInt::from_slice(Plus, b_vec);
        let c = BigInt::from_slice(Plus, c_vec);
        let d = BigInt::from_slice(Plus, d_vec);

        assert!(a == &b * &c + &d);
        assert!(a == &c * &b + &d);
    }
}

#[test]
fn test_div_mod_floor() {
    fn check_sub(a: &BigInt, b: &BigInt, ans_d: &BigInt, ans_m: &BigInt) {
        let (d, m) = a.div_mod_floor(b);
        assert_eq!(d, a.div_floor(b));
        assert_eq!(m, a.mod_floor(b));
        if !m.is_zero() {
            assert_eq!(m.sign(), b.sign());
        }
        assert!(m.abs() <= b.abs());
        assert!(*a == b * &d + &m);
        assert!(d == *ans_d);
        assert!(m == *ans_m);
    }

    fn check(a: &BigInt, b: &BigInt, d: &BigInt, m: &BigInt) {
        if m.is_zero() {
            check_sub(a, b, d, m);
            check_sub(a, &b.neg(), &d.neg(), m);
            check_sub(&a.neg(), b, &d.neg(), m);
            check_sub(&a.neg(), &b.neg(), d, m);
        } else {
            let one: BigInt = One::one();
            check_sub(a, b, d, m);
            check_sub(a, &b.neg(), &(d.neg() - &one), &(m - b));
            check_sub(&a.neg(), b, &(d.neg() - &one), &(b - m));
            check_sub(&a.neg(), &b.neg(), d, &m.neg());
        }
    }

    for elm in MUL_TRIPLES.iter() {
        let (a_vec, b_vec, c_vec) = *elm;
        let a = BigInt::from_slice(Plus, a_vec);
        let b = BigInt::from_slice(Plus, b_vec);
        let c = BigInt::from_slice(Plus, c_vec);

        if !a.is_zero() {
            check(&c, &a, &b, &Zero::zero());
        }
        if !b.is_zero() {
            check(&c, &b, &a, &Zero::zero());
        }
    }

    for elm in DIV_REM_QUADRUPLES.iter() {
        let (a_vec, b_vec, c_vec, d_vec) = *elm;
        let a = BigInt::from_slice(Plus, a_vec);
        let b = BigInt::from_slice(Plus, b_vec);
        let c = BigInt::from_slice(Plus, c_vec);
        let d = BigInt::from_slice(Plus, d_vec);

        if !b.is_zero() {
            check(&a, &b, &c, &d);
        }
    }
}

#[test]
fn test_div_rem() {
    fn check_sub(a: &BigInt, b: &BigInt, ans_q: &BigInt, ans_r: &BigInt) {
        let (q, r) = a.div_rem(b);
        if !r.is_zero() {
            assert_eq!(r.sign(), a.sign());
        }
        assert!(r.abs() <= b.abs());
        assert!(*a == b * &q + &r);
        assert!(q == *ans_q);
        assert!(r == *ans_r);

        let (a, b, ans_q, ans_r) = (a.clone(), b.clone(), ans_q.clone(), ans_r.clone());
        assert_op!(a / b == ans_q);
        assert_op!(a % b == ans_r);
        assert_assign_op!(a /= b == ans_q);
        assert_assign_op!(a %= b == ans_r);
    }

    fn check(a: &BigInt, b: &BigInt, q: &BigInt, r: &BigInt) {
        check_sub(a, b, q, r);
        check_sub(a, &b.neg(), &q.neg(), r);
        check_sub(&a.neg(), b, &q.neg(), &r.neg());
        check_sub(&a.neg(), &b.neg(), q, &r.neg());
    }
    for elm in MUL_TRIPLES.iter() {
        let (a_vec, b_vec, c_vec) = *elm;
        let a = BigInt::from_slice(Plus, a_vec);
        let b = BigInt::from_slice(Plus, b_vec);
        let c = BigInt::from_slice(Plus, c_vec);

        if !a.is_zero() {
            check(&c, &a, &b, &Zero::zero());
        }
        if !b.is_zero() {
            check(&c, &b, &a, &Zero::zero());
        }
    }

    for elm in DIV_REM_QUADRUPLES.iter() {
        let (a_vec, b_vec, c_vec, d_vec) = *elm;
        let a = BigInt::from_slice(Plus, a_vec);
        let b = BigInt::from_slice(Plus, b_vec);
        let c = BigInt::from_slice(Plus, c_vec);
        let d = BigInt::from_slice(Plus, d_vec);

        if !b.is_zero() {
            check(&a, &b, &c, &d);
        }
    }
}

#[test]
fn test_div_ceil() {
    fn check_sub(a: &BigInt, b: &BigInt, ans_d: &BigInt) {
        assert_eq!(a.div_ceil(b), *ans_d);
    }

    fn check(a: &BigInt, b: &BigInt, d: &BigInt, m: &BigInt) {
        if m.is_zero() {
            check_sub(a, b, d);
            check_sub(a, &b.neg(), &d.neg());
            check_sub(&a.neg(), b, &d.neg());
            check_sub(&a.neg(), &b.neg(), d);
        } else {
            check_sub(a, b, &(d + 1));
            check_sub(a, &b.neg(), &d.neg());
            check_sub(&a.neg(), b, &d.neg());
            check_sub(&a.neg(), &b.neg(), &(d + 1));
        }
    }

    for elm in MUL_TRIPLES.iter() {
        let (a_vec, b_vec, c_vec) = *elm;
        let a = BigInt::from_slice(Plus, a_vec);
        let b = BigInt::from_slice(Plus, b_vec);
        let c = BigInt::from_slice(Plus, c_vec);

        if !a.is_zero() {
            check(&c, &a, &b, &Zero::zero());
        }
        if !b.is_zero() {
            check(&c, &b, &a, &Zero::zero());
        }
    }

    for elm in DIV_REM_QUADRUPLES.iter() {
        let (a_vec, b_vec, c_vec, d_vec) = *elm;
        let a = BigInt::from_slice(Plus, a_vec);
        let b = BigInt::from_slice(Plus, b_vec);
        let c = BigInt::from_slice(Plus, c_vec);
        let d = BigInt::from_slice(Plus, d_vec);

        if !b.is_zero() {
            check(&a, &b, &c, &d);
        }
    }
}

#[test]
fn test_div_rem_euclid() {
    fn check_sub(a: &BigInt, b: &BigInt, ans_d: &BigInt, ans_m: &BigInt) {
        eprintln!("{} {} {} {}", a, b, ans_d, ans_m);
        assert_eq!(a.div_euclid(b), *ans_d);
        assert_eq!(a.rem_euclid(b), *ans_m);
        assert!(*ans_m >= BigInt::zero());
        assert!(*ans_m < b.abs());
    }

    fn check(a: &BigInt, b: &BigInt, d: &BigInt, m: &BigInt) {
        if m.is_zero() {
            check_sub(a, b, d, m);
            check_sub(a, &b.neg(), &d.neg(), m);
            check_sub(&a.neg(), b, &d.neg(), m);
            check_sub(&a.neg(), &b.neg(), d, m);
        } else {
            let one: BigInt = One::one();
            check_sub(a, b, d, m);
            check_sub(a, &b.neg(), &d.neg(), m);
            check_sub(&a.neg(), b, &(d + &one).neg(), &(b - m));
            check_sub(&a.neg(), &b.neg(), &(d + &one), &(b.abs() - m));
        }
    }

    for elm in MUL_TRIPLES.iter() {
        let (a_vec, b_vec, c_vec) = *elm;
        let a = BigInt::from_slice(Plus, a_vec);
        let b = BigInt::from_slice(Plus, b_vec);
        let c = BigInt::from_slice(Plus, c_vec);

        if !a.is_zero() {
            check(&c, &a, &b, &Zero::zero());
        }
        if !b.is_zero() {
            check(&c, &b, &a, &Zero::zero());
        }
    }

    for elm in DIV_REM_QUADRUPLES.iter() {
        let (a_vec, b_vec, c_vec, d_vec) = *elm;
        let a = BigInt::from_slice(Plus, a_vec);
        let b = BigInt::from_slice(Plus, b_vec);
        let c = BigInt::from_slice(Plus, c_vec);
        let d = BigInt::from_slice(Plus, d_vec);

        if !b.is_zero() {
            check(&a, &b, &c, &d);
        }
    }
}

#[test]
fn test_checked_add() {
    for elm in SUM_TRIPLES.iter() {
        let (a_vec, b_vec, c_vec) = *elm;
        let a = BigInt::from_slice(Plus, a_vec);
        let b = BigInt::from_slice(Plus, b_vec);
        let c = BigInt::from_slice(Plus, c_vec);

        assert!(a.checked_add(&b).unwrap() == c);
        assert!(b.checked_add(&a).unwrap() == c);
        assert!(c.checked_add(&(-&a)).unwrap() == b);
        assert!(c.checked_add(&(-&b)).unwrap() == a);
        assert!(a.checked_add(&(-&c)).unwrap() == (-&b));
        assert!(b.checked_add(&(-&c)).unwrap() == (-&a));
        assert!((-&a).checked_add(&(-&b)).unwrap() == (-&c));
        assert!(a.checked_add(&(-&a)).unwrap() == BigInt::zero());
    }
}

#[test]
fn test_checked_sub() {
    for elm in SUM_TRIPLES.iter() {
        let (a_vec, b_vec, c_vec) = *elm;
        let a = BigInt::from_slice(Plus, a_vec);
        let b = BigInt::from_slice(Plus, b_vec);
        let c = BigInt::from_slice(Plus, c_vec);

        assert!(c.checked_sub(&a).unwrap() == b);
        assert!(c.checked_sub(&b).unwrap() == a);
        assert!((-&b).checked_sub(&a).unwrap() == (-&c));
        assert!((-&a).checked_sub(&b).unwrap() == (-&c));
        assert!(b.checked_sub(&(-&a)).unwrap() == c);
        assert!(a.checked_sub(&(-&b)).unwrap() == c);
        assert!((-&c).checked_sub(&(-&a)).unwrap() == (-&b));
        assert!(a.checked_sub(&a).unwrap() == BigInt::zero());
    }
}

#[test]
fn test_checked_mul() {
    for elm in MUL_TRIPLES.iter() {
        let (a_vec, b_vec, c_vec) = *elm;
        let a = BigInt::from_slice(Plus, a_vec);
        let b = BigInt::from_slice(Plus, b_vec);
        let c = BigInt::from_slice(Plus, c_vec);

        assert!(a.checked_mul(&b).unwrap() == c);
        assert!(b.checked_mul(&a).unwrap() == c);

        assert!((-&a).checked_mul(&b).unwrap() == -&c);
        assert!((-&b).checked_mul(&a).unwrap() == -&c);
    }

    for elm in DIV_REM_QUADRUPLES.iter() {
        let (a_vec, b_vec, c_vec, d_vec) = *elm;
        let a = BigInt::from_slice(Plus, a_vec);
        let b = BigInt::from_slice(Plus, b_vec);
        let c = BigInt::from_slice(Plus, c_vec);
        let d = BigInt::from_slice(Plus, d_vec);

        assert!(a == b.checked_mul(&c).unwrap() + &d);
        assert!(a == c.checked_mul(&b).unwrap() + &d);
    }
}
#[test]
fn test_checked_div() {
    for elm in MUL_TRIPLES.iter() {
        let (a_vec, b_vec, c_vec) = *elm;
        let a = BigInt::from_slice(Plus, a_vec);
        let b = BigInt::from_slice(Plus, b_vec);
        let c = BigInt::from_slice(Plus, c_vec);

        if !a.is_zero() {
            assert!(c.checked_div(&a).unwrap() == b);
            assert!((-&c).checked_div(&(-&a)).unwrap() == b);
            assert!((-&c).checked_div(&a).unwrap() == -&b);
        }
        if !b.is_zero() {
            assert!(c.checked_div(&b).unwrap() == a);
            assert!((-&c).checked_div(&(-&b)).unwrap() == a);
            assert!((-&c).checked_div(&b).unwrap() == -&a);
        }

        assert!(c.checked_div(&Zero::zero()).is_none());
        assert!((-&c).checked_div(&Zero::zero()).is_none());
    }
}

#[test]
fn test_gcd() {
    fn check(a: isize, b: isize, c: isize) {
        let big_a: BigInt = FromPrimitive::from_isize(a).unwrap();
        let big_b: BigInt = FromPrimitive::from_isize(b).unwrap();
        let big_c: BigInt = FromPrimitive::from_isize(c).unwrap();

        assert_eq!(big_a.gcd(&big_b), big_c);
        assert_eq!(big_a.extended_gcd(&big_b).gcd, big_c);
        assert_eq!(big_a.gcd_lcm(&big_b).0, big_c);
        assert_eq!(big_a.extended_gcd_lcm(&big_b).0.gcd, big_c);
    }

    check(10, 2, 2);
    check(10, 3, 1);
    check(0, 3, 3);
    check(3, 3, 3);
    check(56, 42, 14);
    check(3, -3, 3);
    check(-6, 3, 3);
    check(-4, -2, 2);
}

#[test]
fn test_lcm() {
    fn check(a: isize, b: isize, c: isize) {
        let big_a: BigInt = FromPrimitive::from_isize(a).unwrap();
        let big_b: BigInt = FromPrimitive::from_isize(b).unwrap();
        let big_c: BigInt = FromPrimitive::from_isize(c).unwrap();

        assert_eq!(big_a.lcm(&big_b), big_c);
        assert_eq!(big_a.gcd_lcm(&big_b).1, big_c);
        assert_eq!(big_a.extended_gcd_lcm(&big_b).1, big_c);
    }

    check(0, 0, 0);
    check(1, 0, 0);
    check(0, 1, 0);
    check(1, 1, 1);
    check(-1, 1, 1);
    check(1, -1, 1);
    check(-1, -1, 1);
    check(8, 9, 72);
    check(11, 5, 55);
}

#[test]
fn test_is_multiple_of() {
    assert!(BigInt::from(0).is_multiple_of(&BigInt::from(0)));
    assert!(BigInt::from(6).is_multiple_of(&BigInt::from(6)));
    assert!(BigInt::from(6).is_multiple_of(&BigInt::from(3)));
    assert!(BigInt::from(6).is_multiple_of(&BigInt::from(1)));

    assert!(!BigInt::from(42).is_multiple_of(&BigInt::from(5)));
    assert!(!BigInt::from(5).is_multiple_of(&BigInt::from(3)));
    assert!(!BigInt::from(42).is_multiple_of(&BigInt::from(0)));
}

#[test]
fn test_next_multiple_of() {
    assert_eq!(
        BigInt::from(16).next_multiple_of(&BigInt::from(8)),
        BigInt::from(16)
    );
    assert_eq!(
        BigInt::from(23).next_multiple_of(&BigInt::from(8)),
        BigInt::from(24)
    );
    assert_eq!(
        BigInt::from(16).next_multiple_of(&BigInt::from(-8)),
        BigInt::from(16)
    );
    assert_eq!(
        BigInt::from(23).next_multiple_of(&BigInt::from(-8)),
        BigInt::from(16)
    );
    assert_eq!(
        BigInt::from(-16).next_multiple_of(&BigInt::from(8)),
        BigInt::from(-16)
    );
    assert_eq!(
        BigInt::from(-23).next_multiple_of(&BigInt::from(8)),
        BigInt::from(-16)
    );
    assert_eq!(
        BigInt::from(-16).next_multiple_of(&BigInt::from(-8)),
        BigInt::from(-16)
    );
    assert_eq!(
        BigInt::from(-23).next_multiple_of(&BigInt::from(-8)),
        BigInt::from(-24)
    );
}

#[test]
fn test_prev_multiple_of() {
    assert_eq!(
        BigInt::from(16).prev_multiple_of(&BigInt::from(8)),
        BigInt::from(16)
    );
    assert_eq!(
        BigInt::from(23).prev_multiple_of(&BigInt::from(8)),
        BigInt::from(16)
    );
    assert_eq!(
        BigInt::from(16).prev_multiple_of(&BigInt::from(-8)),
        BigInt::from(16)
    );
    assert_eq!(
        BigInt::from(23).prev_multiple_of(&BigInt::from(-8)),
        BigInt::from(24)
    );
    assert_eq!(
        BigInt::from(-16).prev_multiple_of(&BigInt::from(8)),
        BigInt::from(-16)
    );
    assert_eq!(
        BigInt::from(-23).prev_multiple_of(&BigInt::from(8)),
        BigInt::from(-24)
    );
    assert_eq!(
        BigInt::from(-16).prev_multiple_of(&BigInt::from(-8)),
        BigInt::from(-16)
    );
    assert_eq!(
        BigInt::from(-23).prev_multiple_of(&BigInt::from(-8)),
        BigInt::from(-16)
    );
}

#[test]
fn test_abs_sub() {
    let zero: BigInt = Zero::zero();
    let one: BigInt = One::one();
    assert_eq!((-&one).abs_sub(&one), zero);
    let one: BigInt = One::one();
    let zero: BigInt = Zero::zero();
    assert_eq!(one.abs_sub(&one), zero);
    let one: BigInt = One::one();
    let zero: BigInt = Zero::zero();
    assert_eq!(one.abs_sub(&zero), one);
    let one: BigInt = One::one();
    let two: BigInt = FromPrimitive::from_isize(2).unwrap();
    assert_eq!(one.abs_sub(&-&one), two);
}

#[test]
fn test_from_str_radix() {
    fn check(s: &str, ans: Option<isize>) {
        let ans = ans.map(|n| {
            let x: BigInt = FromPrimitive::from_isize(n).unwrap();
            x
        });
        assert_eq!(BigInt::from_str_radix(s, 10).ok(), ans);
    }
    check("10", Some(10));
    check("1", Some(1));
    check("0", Some(0));
    check("-1", Some(-1));
    check("-10", Some(-10));
    check("+10", Some(10));
    check("--7", None);
    check("++5", None);
    check("+-9", None);
    check("-+3", None);
    check("Z", None);
    check("_", None);

    // issue 10522, this hit an edge case that caused it to
    // attempt to allocate a vector of size (-1u) == huge.
    let x: BigInt = format!("1{}", repeat("0").take(36).collect::<String>())
        .parse()
        .unwrap();
    let _y = x.to_string();
}

#[test]
fn test_lower_hex() {
    let a = BigInt::parse_bytes(b"A", 16).unwrap();
    let hello = BigInt::parse_bytes(b"-22405534230753963835153736737", 10).unwrap();

    assert_eq!(format!("{:x}", a), "a");
    assert_eq!(format!("{:x}", hello), "-48656c6c6f20776f726c6421");
    assert_eq!(format!("{:♥>+#8x}", a), "♥♥♥♥+0xa");
}

#[test]
fn test_upper_hex() {
    let a = BigInt::parse_bytes(b"A", 16).unwrap();
    let hello = BigInt::parse_bytes(b"-22405534230753963835153736737", 10).unwrap();

    assert_eq!(format!("{:X}", a), "A");
    assert_eq!(format!("{:X}", hello), "-48656C6C6F20776F726C6421");
    assert_eq!(format!("{:♥>+#8X}", a), "♥♥♥♥+0xA");
}

#[test]
fn test_binary() {
    let a = BigInt::parse_bytes(b"A", 16).unwrap();
    let hello = BigInt::parse_bytes(b"-224055342307539", 10).unwrap();

    assert_eq!(format!("{:b}", a), "1010");
    assert_eq!(
        format!("{:b}", hello),
        "-110010111100011011110011000101101001100011010011"
    );
    assert_eq!(format!("{:♥>+#8b}", a), "♥+0b1010");
}

#[test]
fn test_octal() {
    let a = BigInt::parse_bytes(b"A", 16).unwrap();
    let hello = BigInt::parse_bytes(b"-22405534230753963835153736737", 10).unwrap();

    assert_eq!(format!("{:o}", a), "12");
    assert_eq!(format!("{:o}", hello), "-22062554330674403566756233062041");
    assert_eq!(format!("{:♥>+#8o}", a), "♥♥♥+0o12");
}

#[test]
fn test_display() {
    let a = BigInt::parse_bytes(b"A", 16).unwrap();
    let hello = BigInt::parse_bytes(b"-22405534230753963835153736737", 10).unwrap();

    assert_eq!(format!("{}", a), "10");
    assert_eq!(format!("{}", hello), "-22405534230753963835153736737");
    assert_eq!(format!("{:♥>+#8}", a), "♥♥♥♥♥+10");
}

#[test]
fn test_neg() {
    assert!(-BigInt::new(Plus, vec![1, 1, 1]) == BigInt::new(Minus, vec![1, 1, 1]));
    assert!(-BigInt::new(Minus, vec![1, 1, 1]) == BigInt::new(Plus, vec![1, 1, 1]));
    let zero: BigInt = Zero::zero();
    assert_eq!(-&zero, zero);
}

#[test]
fn test_negative_shr() {
    assert_eq!(BigInt::from(-1) >> 1, BigInt::from(-1));
    assert_eq!(BigInt::from(-2) >> 1, BigInt::from(-1));
    assert_eq!(BigInt::from(-3) >> 1, BigInt::from(-2));
    assert_eq!(BigInt::from(-3) >> 2, BigInt::from(-1));
}

#[test]
fn test_iter_sum() {
    let result: BigInt = FromPrimitive::from_isize(-1234567).unwrap();
    let data: Vec<BigInt> = vec![
        FromPrimitive::from_i32(-1000000).unwrap(),
        FromPrimitive::from_i32(-200000).unwrap(),
        FromPrimitive::from_i32(-30000).unwrap(),
        FromPrimitive::from_i32(-4000).unwrap(),
        FromPrimitive::from_i32(-500).unwrap(),
        FromPrimitive::from_i32(-60).unwrap(),
        FromPrimitive::from_i32(-7).unwrap(),
    ];

    assert_eq!(result, data.iter().sum::<BigInt>());
    assert_eq!(result, data.into_iter().sum::<BigInt>());
}

#[test]
fn test_iter_product() {
    let data: Vec<BigInt> = vec![
        FromPrimitive::from_i32(1001).unwrap(),
        FromPrimitive::from_i32(-1002).unwrap(),
        FromPrimitive::from_i32(1003).unwrap(),
        FromPrimitive::from_i32(-1004).unwrap(),
        FromPrimitive::from_i32(1005).unwrap(),
    ];
    let result = data.get(0).unwrap()
        * data.get(1).unwrap()
        * data.get(2).unwrap()
        * data.get(3).unwrap()
        * data.get(4).unwrap();

    assert_eq!(result, data.iter().product::<BigInt>());
    assert_eq!(result, data.into_iter().product::<BigInt>());
}

#[test]
fn test_iter_sum_generic() {
    let result: BigInt = FromPrimitive::from_isize(-1234567).unwrap();
    let data = vec![-1000000, -200000, -30000, -4000, -500, -60, -7];

    assert_eq!(result, data.iter().sum::<BigInt>());
    assert_eq!(result, data.into_iter().sum::<BigInt>());
}

#[test]
fn test_iter_product_generic() {
    let data = vec![1001, -1002, 1003, -1004, 1005];
    let result = data[0].to_bigint().unwrap()
        * data[1].to_bigint().unwrap()
        * data[2].to_bigint().unwrap()
        * data[3].to_bigint().unwrap()
        * data[4].to_bigint().unwrap();

    assert_eq!(result, data.iter().product::<BigInt>());
    assert_eq!(result, data.into_iter().product::<BigInt>());
}

#[test]
fn test_pow() {
    let one = BigInt::from(1i32);
    let two = BigInt::from(2i32);
    let four = BigInt::from(4i32);
    let eight = BigInt::from(8i32);
    let minus_two = BigInt::from(-2i32);
    macro_rules! check {
        ($t:ty) => {
            assert_eq!(Pow::pow(&two, 0 as $t), one);
            assert_eq!(Pow::pow(&two, 1 as $t), two);
            assert_eq!(Pow::pow(&two, 2 as $t), four);
            assert_eq!(Pow::pow(&two, 3 as $t), eight);
            assert_eq!(Pow::pow(&two, &(3 as $t)), eight);
            assert_eq!(Pow::pow(&minus_two, 0 as $t), one, "-2^0");
            assert_eq!(Pow::pow(&minus_two, 1 as $t), minus_two, "-2^1");
            assert_eq!(Pow::pow(&minus_two, 2 as $t), four, "-2^2");
            assert_eq!(Pow::pow(&minus_two, 3 as $t), -&eight, "-2^3");
        };
    }
    check!(u8);
    check!(u16);
    check!(u32);
    check!(u64);
    check!(usize);

    let pow_1e10000 = BigInt::from(10u32).pow(10_000_u32);
    let manual_1e10000 = repeat(10u32).take(10_000).product::<BigInt>();
    assert!(manual_1e10000 == pow_1e10000);
}

#[test]
fn test_bit() {
    // 12 = (1100)_2
    assert!(!BigInt::from(0b1100u8).bit(0));
    assert!(!BigInt::from(0b1100u8).bit(1));
    assert!(BigInt::from(0b1100u8).bit(2));
    assert!(BigInt::from(0b1100u8).bit(3));
    assert!(!BigInt::from(0b1100u8).bit(4));
    assert!(!BigInt::from(0b1100u8).bit(200));
    assert!(!BigInt::from(0b1100u8).bit(u64::MAX));
    // -12 = (...110100)_2
    assert!(!BigInt::from(-12i8).bit(0));
    assert!(!BigInt::from(-12i8).bit(1));
    assert!(BigInt::from(-12i8).bit(2));
    assert!(!BigInt::from(-12i8).bit(3));
    assert!(BigInt::from(-12i8).bit(4));
    assert!(BigInt::from(-12i8).bit(200));
    assert!(BigInt::from(-12i8).bit(u64::MAX));
}

#[test]
fn test_set_bit() {
    let mut x: BigInt;

    // zero
    x = BigInt::zero();
    x.set_bit(200, true);
    assert_eq!(x, BigInt::one() << 200);
    x = BigInt::zero();
    x.set_bit(200, false);
    assert_eq!(x, BigInt::zero());

    // positive numbers
    x = BigInt::from_biguint(Plus, BigUint::one() << 200);
    x.set_bit(10, true);
    x.set_bit(200, false);
    assert_eq!(x, BigInt::one() << 10);
    x.set_bit(10, false);
    x.set_bit(5, false);
    assert_eq!(x, BigInt::zero());

    // negative numbers
    x = BigInt::from(-12i8);
    x.set_bit(200, true);
    assert_eq!(x, BigInt::from(-12i8));
    x.set_bit(200, false);
    assert_eq!(
        x,
        BigInt::from_biguint(Minus, BigUint::from(12u8) | (BigUint::one() << 200))
    );
    x.set_bit(6, false);
    assert_eq!(
        x,
        BigInt::from_biguint(Minus, BigUint::from(76u8) | (BigUint::one() << 200))
    );
    x.set_bit(6, true);
    assert_eq!(
        x,
        BigInt::from_biguint(Minus, BigUint::from(12u8) | (BigUint::one() << 200))
    );
    x.set_bit(200, true);
    assert_eq!(x, BigInt::from(-12i8));

    x = BigInt::from_biguint(Minus, BigUint::one() << 30);
    x.set_bit(10, true);
    assert_eq!(
        x,
        BigInt::from_biguint(Minus, (BigUint::one() << 30) - (BigUint::one() << 10))
    );

    x = BigInt::from_biguint(Minus, BigUint::one() << 200);
    x.set_bit(40, true);
    assert_eq!(
        x,
        BigInt::from_biguint(Minus, (BigUint::one() << 200) - (BigUint::one() << 40))
    );

    x = BigInt::from_biguint(Minus, (BigUint::one() << 200) | (BigUint::one() << 100));
    x.set_bit(100, false);
    assert_eq!(
        x,
        BigInt::from_biguint(Minus, (BigUint::one() << 200) | (BigUint::one() << 101))
    );

    x = BigInt::from_biguint(Minus, (BigUint::one() << 63) | (BigUint::one() << 62));
    x.set_bit(62, false);
    assert_eq!(x, BigInt::from_biguint(Minus, BigUint::one() << 64));

    x = BigInt::from_biguint(Minus, (BigUint::one() << 200) - BigUint::one());
    x.set_bit(0, false);
    assert_eq!(x, BigInt::from_biguint(Minus, BigUint::one() << 200));
}