spirix 0.0.12

use crate::Scalar;


impl From<Scalar<i8, i8>> for Scalar<i8, i16> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i8, i32> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i8, i64> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i8, i128> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i16, i8> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i16, i16> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i16, i32> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i16, i64> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i16, i128> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i32, i8> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i32, i16> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i32, i32> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i32, i64> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i32, i128> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i64, i8> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i64, i16> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i64, i32> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i64, i64> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i64, i128> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i128, i8> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i128, i16> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i128, i32> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i128, i64> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i8>> for Scalar<i128, i128> {
    fn from(source: Scalar<i8, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i8, i8> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i8, i32> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i8, i64> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i8, i128> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i16, i8> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i16, i16> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i16, i32> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i16, i64> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i16, i128> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i32, i8> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i32, i16> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i32, i32> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i32, i64> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i32, i128> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i64, i8> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i64, i16> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i64, i32> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i64, i64> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i64, i128> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i128, i8> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i128, i16> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i128, i32> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i128, i64> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i16>> for Scalar<i128, i128> {
    fn from(source: Scalar<i8, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i8, i8> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i8, i16> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i8, i64> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i8, i128> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i16, i8> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i16, i16> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i16, i32> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i16, i64> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i16, i128> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i32, i8> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i32, i16> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i32, i32> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i32, i64> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i32, i128> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i64, i8> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i64, i16> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i64, i32> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i64, i64> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i64, i128> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i128, i8> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i128, i16> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i128, i32> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i128, i64> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i32>> for Scalar<i128, i128> {
    fn from(source: Scalar<i8, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i8, i8> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i8, i16> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i8, i32> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i8, i128> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i16, i8> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i16, i16> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i16, i32> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i16, i64> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i16, i128> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i32, i8> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i32, i16> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i32, i32> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i32, i64> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i32, i128> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i64, i8> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i64, i16> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i64, i32> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i64, i64> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i64, i128> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i128, i8> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i128, i16> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i128, i32> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i128, i64> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i64>> for Scalar<i128, i128> {
    fn from(source: Scalar<i8, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i8, i8> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i8, i16> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i8, i32> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i8, i64> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i16, i8> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i16, i16> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i16, i32> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i16, i64> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i16, i128> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i32, i8> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i32, i16> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i32, i32> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i32, i64> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i32, i128> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i64, i8> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i64, i16> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i64, i32> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i64, i64> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i64, i128> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i128, i8> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i128, i16> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i128, i32> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i128, i64> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i8, i128>> for Scalar<i128, i128> {
    fn from(source: Scalar<i8, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i8, i8> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i8, i16> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i8, i32> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i8, i64> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i8, i128> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i16, i16> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i16, i32> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i16, i64> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i16, i128> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i32, i8> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i32, i16> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i32, i32> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i32, i64> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i32, i128> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i64, i8> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i64, i16> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i64, i32> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i64, i64> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i64, i128> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i128, i8> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i128, i16> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i128, i32> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i128, i64> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i8>> for Scalar<i128, i128> {
    fn from(source: Scalar<i16, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i8, i8> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i8, i16> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i8, i32> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i8, i64> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i8, i128> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i16, i8> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i16, i32> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i16, i64> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i16, i128> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i32, i8> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i32, i16> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i32, i32> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i32, i64> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i32, i128> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i64, i8> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i64, i16> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i64, i32> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i64, i64> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i64, i128> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i128, i8> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i128, i16> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i128, i32> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i128, i64> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i16>> for Scalar<i128, i128> {
    fn from(source: Scalar<i16, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i8, i8> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i8, i16> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i8, i32> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i8, i64> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i8, i128> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i16, i8> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i16, i16> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i16, i64> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i16, i128> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i32, i8> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i32, i16> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i32, i32> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i32, i64> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i32, i128> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i64, i8> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i64, i16> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i64, i32> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i64, i64> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i64, i128> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i128, i8> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i128, i16> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i128, i32> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i128, i64> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i32>> for Scalar<i128, i128> {
    fn from(source: Scalar<i16, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i8, i8> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i8, i16> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i8, i32> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i8, i64> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i8, i128> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i16, i8> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i16, i16> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i16, i32> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i16, i128> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i32, i8> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i32, i16> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i32, i32> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i32, i64> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i32, i128> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i64, i8> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i64, i16> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i64, i32> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i64, i64> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i64, i128> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i128, i8> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i128, i16> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i128, i32> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i128, i64> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i64>> for Scalar<i128, i128> {
    fn from(source: Scalar<i16, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i8, i8> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i8, i16> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i8, i32> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i8, i64> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i8, i128> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i16, i8> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i16, i16> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i16, i32> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i16, i64> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i32, i8> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i32, i16> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i32, i32> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i32, i64> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i32, i128> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i64, i8> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i64, i16> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i64, i32> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i64, i64> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i64, i128> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i128, i8> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i128, i16> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i128, i32> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i128, i64> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i16, i128>> for Scalar<i128, i128> {
    fn from(source: Scalar<i16, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i8, i8> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i8, i16> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i8, i32> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i8, i64> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i8, i128> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i16, i8> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i16, i16> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i16, i32> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i16, i64> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i16, i128> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i32, i16> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i32, i32> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i32, i64> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i32, i128> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i64, i8> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i64, i16> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i64, i32> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i64, i64> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i64, i128> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i128, i8> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i128, i16> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i128, i32> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i128, i64> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i8>> for Scalar<i128, i128> {
    fn from(source: Scalar<i32, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i8, i8> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i8, i16> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i8, i32> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i8, i64> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i8, i128> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i16, i8> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i16, i16> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i16, i32> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i16, i64> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i16, i128> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i32, i8> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i32, i32> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i32, i64> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i32, i128> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i64, i8> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i64, i16> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i64, i32> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i64, i64> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i64, i128> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i128, i8> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i128, i16> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i128, i32> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i128, i64> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i16>> for Scalar<i128, i128> {
    fn from(source: Scalar<i32, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i8, i8> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i8, i16> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i8, i32> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i8, i64> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i8, i128> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i16, i8> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i16, i16> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i16, i32> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i16, i64> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i16, i128> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i32, i8> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i32, i16> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i32, i64> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i32, i128> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i64, i8> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i64, i16> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i64, i32> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i64, i64> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i64, i128> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i128, i8> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i128, i16> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i128, i32> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i128, i64> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i32>> for Scalar<i128, i128> {
    fn from(source: Scalar<i32, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i8, i8> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i8, i16> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i8, i32> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i8, i64> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i8, i128> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i16, i8> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i16, i16> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i16, i32> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i16, i64> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i16, i128> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i32, i8> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i32, i16> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i32, i32> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i32, i128> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i64, i8> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i64, i16> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i64, i32> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i64, i64> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i64, i128> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i128, i8> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i128, i16> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i128, i32> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i128, i64> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i64>> for Scalar<i128, i128> {
    fn from(source: Scalar<i32, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i8, i8> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i8, i16> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i8, i32> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i8, i64> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i8, i128> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i16, i8> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i16, i16> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i16, i32> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i16, i64> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i16, i128> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i32, i8> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i32, i16> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i32, i32> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i32, i64> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i64, i8> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i64, i16> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i64, i32> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i64, i64> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i64, i128> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i128, i8> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i128, i16> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i128, i32> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i128, i64> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i32, i128>> for Scalar<i128, i128> {
    fn from(source: Scalar<i32, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i8, i8> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i8, i16> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i8, i32> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i8, i64> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i8, i128> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i16, i8> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i16, i16> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i16, i32> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i16, i64> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i16, i128> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i32, i8> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i32, i16> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i32, i32> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i32, i64> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i32, i128> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i64, i16> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i64, i32> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i64, i64> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i64, i128> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i128, i8> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i128, i16> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i128, i32> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i128, i64> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i8>> for Scalar<i128, i128> {
    fn from(source: Scalar<i64, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i8, i8> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i8, i16> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i8, i32> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i8, i64> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i8, i128> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i16, i8> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i16, i16> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i16, i32> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i16, i64> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i16, i128> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i32, i8> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i32, i16> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i32, i32> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i32, i64> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i32, i128> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i64, i8> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i64, i32> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i64, i64> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i64, i128> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i128, i8> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i128, i16> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i128, i32> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i128, i64> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i16>> for Scalar<i128, i128> {
    fn from(source: Scalar<i64, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i8, i8> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i8, i16> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i8, i32> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i8, i64> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i8, i128> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i16, i8> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i16, i16> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i16, i32> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i16, i64> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i16, i128> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i32, i8> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i32, i16> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i32, i32> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i32, i64> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i32, i128> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i64, i8> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i64, i16> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i64, i64> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i64, i128> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i128, i8> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i128, i16> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i128, i32> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i128, i64> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i32>> for Scalar<i128, i128> {
    fn from(source: Scalar<i64, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i8, i8> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i8, i16> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i8, i32> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i8, i64> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i8, i128> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i16, i8> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i16, i16> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i16, i32> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i16, i64> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i16, i128> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i32, i8> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i32, i16> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i32, i32> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i32, i64> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i32, i128> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i64, i8> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i64, i16> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i64, i32> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i64, i128> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i128, i8> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i128, i16> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i128, i32> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i128, i64> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i64>> for Scalar<i128, i128> {
    fn from(source: Scalar<i64, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i8, i8> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i8, i16> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i8, i32> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i8, i64> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i8, i128> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i16, i8> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i16, i16> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i16, i32> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i16, i64> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i16, i128> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i32, i8> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i32, i16> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i32, i32> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i32, i64> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i32, i128> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i64, i8> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i64, i16> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i64, i32> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i64, i64> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i128, i8> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i128, i16> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i128, i32> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i128, i64> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i64, i128>> for Scalar<i128, i128> {
    fn from(source: Scalar<i64, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i8, i8> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i8, i16> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i8, i32> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i8, i64> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i8, i128> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i16, i8> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i16, i16> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i16, i32> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i16, i64> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i16, i128> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i32, i8> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i32, i16> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i32, i32> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i32, i64> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i32, i128> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i64, i8> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i64, i16> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i64, i32> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i64, i64> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i64, i128> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i128, i16> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i128, i32> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i128, i64> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i8>> for Scalar<i128, i128> {
    fn from(source: Scalar<i128, i8>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i8, i8> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i8, i16> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i8, i32> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i8, i64> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i8, i128> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i16, i8> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i16, i16> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i16, i32> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i16, i64> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i16, i128> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i32, i8> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i32, i16> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i32, i32> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i32, i64> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i32, i128> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i64, i8> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i64, i16> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i64, i32> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i64, i64> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i64, i128> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i128, i8> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i128, i32> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i128, i64> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i16>> for Scalar<i128, i128> {
    fn from(source: Scalar<i128, i16>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i8, i8> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i8, i16> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i8, i32> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i8, i64> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i8, i128> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i16, i8> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i16, i16> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i16, i32> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i16, i64> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i16, i128> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i32, i8> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i32, i16> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i32, i32> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i32, i64> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i32, i128> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i64, i8> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i64, i16> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i64, i32> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i64, i64> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i64, i128> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i128, i8> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i128, i16> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i128, i64> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i32>> for Scalar<i128, i128> {
    fn from(source: Scalar<i128, i32>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i8, i8> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i8, i16> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i8, i32> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i8, i64> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i8, i128> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i16, i8> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i16, i16> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i16, i32> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i16, i64> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i16, i128> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i32, i8> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i32, i16> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i32, i32> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i32, i64> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i32, i128> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i64, i8> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i64, i16> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i64, i32> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i64, i64> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i64, i128> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i128, i8> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i128, i16> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i128, i32> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i64>> for Scalar<i128, i128> {
    fn from(source: Scalar<i128, i64>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i8, i8> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i8, i16> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i8, i32> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i8, i64> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i8, i128> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i16, i8> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i16, i16> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i16, i32> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i16, i64> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i16, i128> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i32, i8> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i32, i16> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i32, i32> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i32, i64> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i32, i128> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i64, i8> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i64, i16> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i64, i32> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i64, i64> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i64, i128> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i128, i8> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i128, i16> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i128, i32> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}

impl From<Scalar<i128, i128>> for Scalar<i128, i64> {
    fn from(source: Scalar<i128, i128>) -> Self {
        Self::from(&source)
    }
}