diff --git a/src/auto.rs b/src/auto.rs
index ef685e1..711fedf 100644
--- a/src/auto.rs
+++ b/src/auto.rs
@@ -82,33 +82,40 @@ impl BV {
 // BV - Integer Array traits
 // ------------------------------------------------------------------------------------------------
 
-impl<I: Integer> IArray<I> for BV
-where
-    u64: StaticCast<I>,
-{
-    fn int_len(&self) -> usize {
+impl IArray for BV {
+    type I = u64;
+
+    fn int_len<J: Integer>(&self) -> usize
+    where
+        u64: StaticCast<J>,
+    {
         match self {
-            BV::Fixed(bvf) => IArray::<I>::int_len(bvf),
-            BV::Dynamic(bvd) => IArray::<I>::int_len(bvd),
+            BV::Fixed(bvf) => IArray::int_len(bvf),
+            BV::Dynamic(bvd) => IArray::int_len(bvd),
         }
     }
 
-    fn get_int(&self, idx: usize) -> Option<I> {
+    fn get_int<J: Integer>(&self, idx: usize) -> Option<J>
+    where
+        u64: StaticCast<J>,
+    {
         match self {
-            BV::Fixed(bvf) => IArray::<I>::get_int(bvf, idx),
-            BV::Dynamic(bvd) => IArray::<I>::get_int(bvd, idx),
+            BV::Fixed(bvf) => IArray::get_int(bvf, idx),
+            BV::Dynamic(bvd) => IArray::get_int(bvd, idx),
         }
     }
 }
 
-impl<I: Integer> IArrayMut<I> for BV
-where
-    u64: StaticCast<I>,
-{
-    fn set_int(&mut self, idx: usize, v: I) -> Option<I> {
+impl IArrayMut for BV {
+    type I = u64;
+
+    fn set_int<J: Integer>(&mut self, idx: usize, v: J) -> Option<J>
+    where
+        u64: StaticCast<J>,
+    {
         match self {
-            BV::Fixed(bvf) => IArrayMut::<I>::set_int(bvf, idx, v),
-            BV::Dynamic(bvd) => IArrayMut::<I>::set_int(bvd, idx, v),
+            BV::Fixed(bvf) => IArrayMut::set_int(bvf, idx, v),
+            BV::Dynamic(bvd) => IArrayMut::set_int(bvd, idx, v),
         }
     }
 }
diff --git a/src/dynamic.rs b/src/dynamic.rs
index bfa22dc..2c26b2a 100644
--- a/src/dynamic.rs
+++ b/src/dynamic.rs
@@ -88,30 +88,37 @@ impl BVD {
 // BVD - Integer Array traits
 // ------------------------------------------------------------------------------------------------
 
-impl<I: Integer> IArray<I> for BVD
-where
-    u64: StaticCast<I>,
-{
-    fn int_len(&self) -> usize {
-        (self.len() + size_of::<I>() * 8 - 1) / (size_of::<I>() * 8)
+impl IArray for BVD {
+    type I = u64;
+
+    fn int_len<J: Integer>(&self) -> usize
+    where
+        u64: StaticCast<J>,
+    {
+        (self.len() + size_of::<J>() * 8 - 1) / (size_of::<J>() * 8)
     }
 
-    fn get_int(&self, idx: usize) -> Option<I> {
-        if idx < IArray::<I>::int_len(self) {
-            IArray::<I>::get_int(self.data.as_ref(), idx)
+    fn get_int<J: Integer>(&self, idx: usize) -> Option<J>
+    where
+        u64: StaticCast<J>,
+    {
+        if idx < IArray::int_len::<J>(self) {
+            IArray::get_int::<J>(self.data.as_ref(), idx)
         } else {
             None
         }
     }
 }
 
-impl<I: Integer> IArrayMut<I> for BVD
-where
-    u64: StaticCast<I>,
-{
-    fn set_int(&mut self, idx: usize, v: I) -> Option<I> {
-        if idx < IArray::<I>::int_len(self) {
-            IArrayMut::<I>::set_int(self.data.as_mut(), idx, v)
+impl IArrayMut for BVD {
+    type I = u64;
+
+    fn set_int<J: Integer>(&mut self, idx: usize, v: J) -> Option<J>
+    where
+        u64: StaticCast<J>,
+    {
+        if idx < IArray::int_len::<J>(self) {
+            IArrayMut::set_int::<J>(self.data.as_mut(), idx, v)
         } else {
             None
         }
@@ -748,8 +755,8 @@ impl PartialEq for BVD {
 
 impl<I: Integer, const N: usize> PartialEq<BVF<I, N>> for BVD {
     fn eq(&self, other: &BVF<I, N>) -> bool {
-        for i in 0..usize::max(self.len(), IArray::<u64>::int_len(other)) {
-            if *self.data.get(i).unwrap_or(&0) != IArray::<u64>::get_int(other, i).unwrap_or(0) {
+        for i in 0..usize::max(self.len(), IArray::int_len::<u64>(other)) {
+            if *self.data.get(i).unwrap_or(&0) != IArray::get_int(other, i).unwrap_or(0) {
                 return false;
             }
         }
@@ -773,12 +780,12 @@ impl PartialOrd for BVD {
 
 impl<I: Integer, const N: usize> PartialOrd<BVF<I, N>> for BVD {
     fn partial_cmp(&self, other: &BVF<I, N>) -> Option<Ordering> {
-        for i in (0..usize::max(self.len(), IArray::<u64>::int_len(other))).rev() {
+        for i in (0..usize::max(self.len(), IArray::int_len::<u64>(other))).rev() {
             match self
                 .data
                 .get(i)
                 .unwrap_or(&0)
-                .cmp(&IArray::<u64>::get_int(other, i).unwrap_or(0))
+                .cmp(&IArray::get_int(other, i).unwrap_or(0))
             {
                 Ordering::Equal => continue,
                 ord => return Some(ord),
@@ -831,7 +838,7 @@ macro_rules! impl_from_ints {($($st:ty),+) => {
                 let array = [st];
                 BVD {
                     length: <$st>::BITS as usize,
-                    data: (0..IArray::<u64>::int_len(array.as_ref())).map(|i| IArray::<u64>::get_int(array.as_ref(), i).unwrap()).collect(),
+                    data: (0..IArray::int_len::<u64>(array.as_ref())).map(|i| IArray::get_int(array.as_ref(), i).unwrap()).collect(),
                 }
             }
         }
@@ -867,8 +874,8 @@ impl<I: Integer, const N: usize> From<&BVF<I, N>> for BVD {
     fn from(rhs: &BVF<I, N>) -> BVD {
         BVD {
             length: rhs.len(),
-            data: (0..IArray::<u64>::int_len(rhs))
-                .map(|i| IArray::<u64>::get_int(rhs, i).unwrap())
+            data: (0..IArray::int_len::<u64>(rhs))
+                .map(|i| IArray::get_int(rhs, i).unwrap())
                 .collect(),
         }
     }
@@ -1111,10 +1118,10 @@ macro_rules! impl_binop_assign {
 
         impl<I: Integer, const N: usize> $trait<&BVF<I, N>> for BVD {
             fn $method(&mut self, rhs: &BVF<I, N>) {
-                for i in 0..usize::min(IArray::<u64>::int_len(rhs), self.data.len()) {
-                    self.data[i].$method(IArray::<u64>::get_int(rhs, i).unwrap());
+                for i in 0..usize::min(IArray::int_len::<u64>(rhs), self.data.len()) {
+                    self.data[i].$method(IArray::get_int::<u64>(rhs, i).unwrap());
                 }
-                for i in usize::min(IArray::<u64>::int_len(rhs), self.data.len())..self.data.len() {
+                for i in usize::min(IArray::int_len::<u64>(rhs), self.data.len())..self.data.len() {
                     self.data[i].$method(0);
                 }
             }
@@ -1180,13 +1187,13 @@ macro_rules! impl_addsub_assign {
         impl<I: Integer, const N: usize> $trait<&BVF<I, N>> for BVD {
             fn $method(&mut self, rhs: &BVF<I, N>) {
                 let mut carry = 0;
-                for i in 0..IArray::<u64>::int_len(rhs) {
+                for i in 0..IArray::int_len::<u64>(rhs) {
                     let (d1, c1) = self.data[i].$overflowing_method(carry);
-                    let (d2, c2) = d1.$overflowing_method(IArray::<u64>::get_int(rhs, i).unwrap());
+                    let (d2, c2) = d1.$overflowing_method(IArray::get_int(rhs, i).unwrap());
                     self.data[i] = d2;
                     carry = (c1 | c2) as u64;
                 }
-                for i in IArray::<u64>::int_len(rhs)..Self::capacity_from_bit_len(self.length) {
+                for i in IArray::int_len::<u64>(rhs)..Self::capacity_from_bit_len(self.length) {
                     let (d, c) = self.data[i].$overflowing_method(carry);
                     self.data[i] = d;
                     carry = c as u64;
@@ -1311,12 +1318,12 @@ impl<I: Integer, const N: usize> Mul<&BVF<I, N>> for &BVD {
     type Output = BVD;
     fn mul(self, rhs: &BVF<I, N>) -> BVD {
         let mut res = BVD::zeros(self.length);
-        let len = IArray::<u64>::int_len(&res);
+        let len = IArray::int_len::<u64>(&res);
 
         for i in 0..len {
             let mut carry = 0;
             for j in 0..(len - i) {
-                let product = self.data[i].wmul(IArray::<u64>::get_int(rhs, j).unwrap_or(0));
+                let product = self.data[i].wmul(IArray::get_int(rhs, j).unwrap_or(0));
                 carry = res.data[i + j].cadd(product.0, carry) + product.1;
             }
         }
diff --git a/src/fixed.rs b/src/fixed.rs
index 2223963..27893a9 100644
--- a/src/fixed.rs
+++ b/src/fixed.rs
@@ -71,30 +71,37 @@ impl<I: Integer, const N: usize> BVF<I, N> {
 // BVF - Integer Array traits
 // ------------------------------------------------------------------------------------------------
 
-impl<I: Integer, J: Integer, const N: usize> IArray<I> for BVF<J, N>
-where
-    J: StaticCast<I>,
-{
-    fn int_len(&self) -> usize {
-        (self.length + size_of::<I>() * 8 - 1) / (size_of::<I>() * 8)
+impl<I: Integer, const N: usize> IArray for BVF<I, N> {
+    type I = I;
+
+    fn int_len<J: Integer>(&self) -> usize
+    where
+        I: StaticCast<J>,
+    {
+        (self.length + size_of::<J>() * 8 - 1) / (size_of::<J>() * 8)
     }
 
-    fn get_int(&self, idx: usize) -> Option<I> {
-        if idx < IArray::<I>::int_len(self) {
-            IArray::<I>::get_int(self.data.as_ref(), idx)
+    fn get_int<J: Integer>(&self, idx: usize) -> Option<J>
+    where
+        I: StaticCast<J>,
+    {
+        if idx < IArray::int_len::<J>(self) {
+            IArray::get_int::<J>(self.data.as_ref(), idx)
         } else {
             None
         }
     }
 }
 
-impl<I: Integer, J: Integer, const N: usize> IArrayMut<I> for BVF<J, N>
-where
-    J: StaticCast<I>,
-{
-    fn set_int(&mut self, idx: usize, v: I) -> Option<I> {
-        if idx < IArray::<I>::int_len(self) {
-            IArrayMut::<I>::set_int(self.data.as_mut(), idx, v)
+impl<I: Integer, const N: usize> IArrayMut for BVF<I, N> {
+    type I = I;
+
+    fn set_int<J: Integer>(&mut self, idx: usize, v: J) -> Option<J>
+    where
+        I: StaticCast<J>,
+    {
+        if idx < IArray::int_len::<J>(self) {
+            IArrayMut::set_int::<J>(self.data.as_mut(), idx, v)
         } else {
             None
         }
@@ -732,9 +739,9 @@ where
     I2: StaticCast<I1>,
 {
     fn eq(&self, other: &BVF<I1, N1>) -> bool {
-        for i in 0..usize::max(IArray::<I1>::int_len(self), IArray::<I1>::int_len(other)) {
-            if IArray::<I1>::get_int(self, i).unwrap_or(I1::ZERO)
-                != IArray::<I1>::get_int(other, i).unwrap_or(I1::ZERO)
+        for i in 0..usize::max(IArray::int_len::<I1>(self), IArray::int_len::<I1>(other)) {
+            if IArray::get_int(self, i).unwrap_or(I1::ZERO)
+                != IArray::get_int(other, i).unwrap_or(I1::ZERO)
             {
                 return false;
             }
@@ -767,10 +774,10 @@ where
     I2: StaticCast<I1>,
 {
     fn partial_cmp(&self, other: &BVF<I1, N1>) -> Option<std::cmp::Ordering> {
-        for i in (0..usize::max(IArray::<I1>::int_len(self), IArray::<I1>::int_len(other))).rev() {
-            match IArray::<I1>::get_int(self, i)
+        for i in (0..usize::max(IArray::int_len::<I1>(self), IArray::int_len::<I1>(other))).rev() {
+            match IArray::get_int(self, i)
                 .unwrap_or(I1::ZERO)
-                .cmp(&IArray::<I1>::get_int(other, i).unwrap_or(I1::ZERO))
+                .cmp(&IArray::get_int(other, i).unwrap_or(I1::ZERO))
             {
                 Ordering::Equal => continue,
                 ord => return Some(ord),
@@ -853,7 +860,7 @@ macro_rules! impl_tryfrom { ($($type:ty),+) => {
                     Err(ConvertionError::NotEnoughCapacity)
                 }
                 else {
-                    Ok(IArray::<$type>::get_int(bv, 0).unwrap())
+                    Ok(IArray::get_int(bv, 0).unwrap())
                 }
             }
         }
@@ -883,8 +890,8 @@ where
             Err(ConvertionError::NotEnoughCapacity)
         } else {
             let mut data = [I2::ZERO; N2];
-            for i in 0..usize::min(N2, IArray::<I2>::int_len(bvf)) {
-                data[i] = IArray::<I2>::get_int(bvf, i).unwrap();
+            for i in 0..usize::min(N2, IArray::int_len::<I2>(bvf)) {
+                data[i] = IArray::get_int(bvf, i).unwrap();
             }
             Ok(BVF::<I2, N2> {
                 data,
@@ -935,8 +942,8 @@ where
             Err(ConvertionError::NotEnoughCapacity)
         } else {
             let mut data = [I::ZERO; N];
-            for i in 0..IArray::<I>::int_len(bv) {
-                data[i] = IArray::<I>::get_int(bv, i).unwrap();
+            for i in 0..IArray::int_len::<I>(bv) {
+                data[i] = IArray::get_int(bv, i).unwrap();
             }
             Ok(BVF::<I, N> {
                 data,
@@ -1128,7 +1135,7 @@ macro_rules! impl_binop_assign {
                     }
                 } else {
                     for i in 0..N1 {
-                        self.data[i].$method(IArray::<I1>::get_int(rhs, i).unwrap_or(I1::ZERO));
+                        self.data[i].$method(IArray::get_int(rhs, i).unwrap_or(I1::ZERO));
                     }
                 }
             }
@@ -1150,7 +1157,7 @@ macro_rules! impl_binop_assign {
         {
             fn $method(&mut self, rhs: &BVD) {
                 for i in 0..N {
-                    self.data[i].$method(IArray::<I>::get_int(rhs, i).unwrap_or(I::ZERO));
+                    self.data[i].$method(IArray::get_int(rhs, i).unwrap_or(I::ZERO));
                 }
             }
         }
@@ -1213,10 +1220,8 @@ macro_rules! impl_addsub_assign {
                 } else {
                     let mut carry = I1::ZERO;
                     for i in 0..N1 {
-                        carry = self.data[i].$carry_method(
-                            IArray::<I1>::get_int(rhs, i).unwrap_or(I1::ZERO),
-                            carry,
-                        );
+                        carry = self.data[i]
+                            .$carry_method(IArray::get_int(rhs, i).unwrap_or(I1::ZERO), carry);
                     }
                     self.mod2n(self.length);
                 }
@@ -1241,7 +1246,7 @@ macro_rules! impl_addsub_assign {
                 let mut carry = I::ZERO;
                 for i in 0..N {
                     carry = self.data[i]
-                        .$carry_method(IArray::<I>::get_int(rhs, i).unwrap_or(I::ZERO), carry);
+                        .$carry_method(IArray::get_int(rhs, i).unwrap_or(I::ZERO), carry);
                 }
                 self.mod2n(self.length);
             }
@@ -1330,11 +1335,11 @@ where
     type Output = BVF<I1, N1>;
     fn mul(self, rhs: &BVF<I2, N2>) -> BVF<I1, N1> {
         let mut res = BVF::<I1, N1>::zeros(self.length);
-        let len = IArray::<I1>::int_len(&res);
+        let len = IArray::int_len::<I1>(&res);
         for i in 0..len {
             let mut carry = I1::ZERO;
             for j in 0..(len - i) {
-                let product = self.data[i].wmul(IArray::<I1>::get_int(rhs, j).unwrap_or(I1::ZERO));
+                let product = self.data[i].wmul(IArray::get_int(rhs, j).unwrap_or(I1::ZERO));
                 carry = res.data[i + j].cadd(product.0, carry) + product.1;
             }
         }
@@ -1381,11 +1386,11 @@ where
     type Output = BVF<I, N>;
     fn mul(self, rhs: &BVD) -> BVF<I, N> {
         let mut res = BVF::<I, N>::zeros(self.length);
-        let len = IArray::<I>::int_len(&res);
+        let len = IArray::int_len::<I>(&res);
         for i in 0..len {
             let mut carry = I::ZERO;
             for j in 0..(len - i) {
-                let product = self.data[i].wmul(IArray::<I>::get_int(rhs, j).unwrap_or(I::ZERO));
+                let product = self.data[i].wmul(IArray::get_int(rhs, j).unwrap_or(I::ZERO));
                 carry = res.data[i + j].cadd(product.0, carry) + product.1;
             }
         }
diff --git a/src/tests/utils.rs b/src/tests/utils.rs
index 9f1408f..87bddc3 100644
--- a/src/tests/utils.rs
+++ b/src/tests/utils.rs
@@ -38,15 +38,15 @@ where
     let byte_len = size_of::<I1>() * N1;
     let n2 = (byte_len + size_of::<I2>() - 1) / size_of::<I2>();
 
-    assert_eq!(N1, IArray::<I1>::int_len(array.as_ref()));
-    assert_eq!(n2, IArray::<I2>::int_len(array.as_ref()));
-    assert_eq!(None, IArray::<I1>::get_int(array.as_ref(), N1));
-    assert_eq!(None, IArray::<I2>::get_int(array.as_ref(), n2));
+    assert_eq!(N1, IArray::int_len::<I1>(array.as_ref()));
+    assert_eq!(n2, IArray::int_len::<I2>(array.as_ref()));
+    assert_eq!(None, IArray::get_int::<I1>(array.as_ref(), N1));
+    assert_eq!(None, IArray::get_int::<I2>(array.as_ref(), n2));
     for i in 0..N1 {
-        assert_eq!(IArray::<I1>::get_int(array.as_ref(), i), Some(I1::ZERO));
+        assert_eq!(IArray::get_int::<I1>(array.as_ref(), i), Some(I1::ZERO));
     }
     for i in 0..n2 {
-        assert_eq!(IArray::<I2>::get_int(array.as_ref(), i), Some(I2::ZERO));
+        assert_eq!(IArray::get_int::<I2>(array.as_ref(), i), Some(I2::ZERO));
     }
 }
 
@@ -61,15 +61,15 @@ where
     I2: Integer + StaticCast<I1> + StaticCast<usize>,
 {
     let mut array = [I1::ZERO; N1];
-    for i in 0..IArray::<I2>::int_len(array.as_ref()) {
+    for i in 0..IArray::int_len::<I2>(array.as_ref()) {
         assert_eq!(
-            IArrayMut::<I2>::set_int(array.as_mut(), i, I2::cast_from(i)),
+            IArrayMut::set_int::<I2>(array.as_mut(), i, I2::cast_from(i)),
             Some(I2::ZERO)
         );
     }
-    for i in 0..IArray::<I2>::int_len(array.as_ref()) {
+    for i in 0..IArray::int_len::<I2>(array.as_ref()) {
         assert_eq!(
-            IArray::<I2>::get_int(array.as_ref(), i),
+            IArray::get_int::<I2>(array.as_ref(), i),
             Some(I2::cast_from(i))
         );
     }
diff --git a/src/utils.rs b/src/utils.rs
index 35e42ba..4e5b874 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -334,36 +334,49 @@ impl Integer for u128 {
     }
 }
 
-pub trait IArray<I: Integer> {
-    fn int_len(&self) -> usize;
-
-    fn get_int(&self, idx: usize) -> Option<I>;
+pub trait IArray {
+    type I: Integer;
+    fn int_len<J: Integer>(&self) -> usize
+    where
+        Self::I: StaticCast<J>;
+
+    fn get_int<J: Integer>(&self, idx: usize) -> Option<J>
+    where
+        Self::I: StaticCast<J>;
 }
 
-pub trait IArrayMut<I: Integer>: IArray<I> {
-    fn set_int(&mut self, idx: usize, v: I) -> Option<I>;
+pub trait IArrayMut {
+    type I: Integer;
+    fn set_int<J: Integer>(&mut self, idx: usize, v: J) -> Option<J>
+    where
+        Self::I: StaticCast<J>;
 }
 
 #[cfg(not(any(target_endian = "big", target_endian = "little")))]
 compile_error!("Unknown target endianness");
 
 #[cfg(target_endian = "little")]
-impl<I1: Integer, I2: Integer> IArray<I2> for [I1]
-where
-    I1: StaticCast<I2>,
-{
-    fn int_len(&self) -> usize {
-        (size_of_val(self) + size_of::<I2>() - 1) / size_of::<I2>()
+impl<I: Integer> IArray for [I] {
+    type I = I;
+
+    fn int_len<J: Integer>(&self) -> usize
+    where
+        I: StaticCast<J>,
+    {
+        (size_of_val(self) + size_of::<J>() - 1) / size_of::<J>()
     }
 
-    fn get_int(&self, idx: usize) -> Option<I2> {
+    fn get_int<J: Integer>(&self, idx: usize) -> Option<J>
+    where
+        I: StaticCast<J>,
+    {
         // The conditional check should be optimized during specialization.
         // These asserts should be validated by our tests.
-        if size_of::<I1>() >= size_of::<I2>() {
+        if size_of::<I>() >= size_of::<J>() {
             unsafe {
-                debug_assert!(size_of::<I1>() % size_of::<I2>() == 0);
-                debug_assert!(align_of::<I1>() % align_of::<I2>() == 0);
-                let (head, mid, tail) = self.align_to::<I2>();
+                debug_assert!(size_of::<I>() % size_of::<J>() == 0);
+                debug_assert!(align_of::<I>() % align_of::<J>() == 0);
+                let (head, mid, tail) = self.align_to::<J>();
                 debug_assert!(head.is_empty() && tail.is_empty());
                 if idx < mid.len() {
                     Some(mid[idx])
@@ -372,15 +385,15 @@ where
                 }
             }
         } else {
-            debug_assert!(size_of::<I2>() % size_of::<I1>() == 0);
-            let s = size_of::<I2>() / size_of::<I1>();
-            let mut v = I2::ZERO;
-            if idx >= IArray::<I2>::int_len(self) {
+            debug_assert!(size_of::<J>() % size_of::<I>() == 0);
+            let s = size_of::<J>() / size_of::<I>();
+            let mut v = J::ZERO;
+            if idx >= IArray::int_len::<J>(self) {
                 return None;
             }
             for i in 0..s {
-                v |= StaticCast::<I2>::cast_to(*self.get(idx * s + i).unwrap_or(&I1::ZERO))
-                    << (size_of::<I1>() * 8 * i);
+                v |= StaticCast::<J>::cast_to(*self.get(idx * s + i).unwrap_or(&I::ZERO))
+                    << (size_of::<I>() * 8 * i);
             }
             Some(v)
         }
@@ -388,18 +401,20 @@ where
 }
 
 #[cfg(target_endian = "little")]
-impl<I1: Integer, I2: Integer> IArrayMut<I2> for [I1]
-where
-    I1: StaticCast<I2>,
-{
-    fn set_int(&mut self, idx: usize, v: I2) -> Option<I2> {
+impl<I: Integer> IArrayMut for [I] {
+    type I = I;
+
+    fn set_int<J: Integer>(&mut self, idx: usize, v: J) -> Option<J>
+    where
+        I: StaticCast<J>,
+    {
         // The conditional check should be optimized during specialization.
         // These asserts should be validated by our tests.
-        if size_of::<I1>() >= size_of::<I2>() {
+        if size_of::<I>() >= size_of::<J>() {
             unsafe {
-                debug_assert!(size_of::<I1>() % size_of::<I2>() == 0);
-                debug_assert!(align_of::<I1>() % align_of::<I2>() == 0);
-                let (head, mid, tail) = self.align_to_mut::<I2>();
+                debug_assert!(size_of::<I>() % size_of::<J>() == 0);
+                debug_assert!(align_of::<I>() % align_of::<J>() == 0);
+                let (head, mid, tail) = self.align_to_mut::<J>();
                 debug_assert!(head.is_empty() && tail.is_empty());
                 if idx < mid.len() {
                     let old = mid[idx];
@@ -410,16 +425,16 @@ where
                 }
             }
         } else {
-            debug_assert!(size_of::<I2>() % size_of::<I1>() == 0);
-            let s = size_of::<I2>() / size_of::<I1>();
-            let mut old = I2::ZERO;
-            if idx >= IArray::<I2>::int_len(self) {
+            debug_assert!(size_of::<J>() % size_of::<I>() == 0);
+            let s = size_of::<J>() / size_of::<I>();
+            let mut old = J::ZERO;
+            if idx >= IArray::int_len::<J>(self) {
                 return None;
             }
             for i in 0..s {
                 if let Some(p) = self.get_mut(idx * s + i) {
-                    old |= StaticCast::<I2>::cast_to(*p) << (size_of::<I1>() * 8 * i);
-                    *p = StaticCast::<I2>::cast_from(v >> (size_of::<I1>() * 8 * i));
+                    old |= StaticCast::<J>::cast_to(*p) << (size_of::<I>() * 8 * i);
+                    *p = StaticCast::<J>::cast_from(v >> (size_of::<I>() * 8 * i));
                 }
             }
             Some(old)